init

crates/domain/tests/activity/activity_name_test.rs

@@ -0,0 +1,26 @@
+use domain::activity::ActivityName;
+use domain::errors::DomainError;
+
+#[test]
+fn valid_name_is_created() {
+    let name = ActivityName::new("exercise").unwrap();
+    assert_eq!(name.value(), "exercise");
+}
+
+#[test]
+fn name_trims_whitespace() {
+    let name = ActivityName::new("  friends  ").unwrap();
+    assert_eq!(name.value(), "friends");
+}
+
+#[test]
+fn empty_name_is_rejected() {
+    let result = ActivityName::new("");
+    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+}
+
+#[test]
+fn whitespace_only_name_is_rejected() {
+    let result = ActivityName::new("   ");
+    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+}

crates/domain/tests/activity/activity_test.rs

@@ -0,0 +1,99 @@
+use domain::activity::{Activity, ActivityName, CategoryName};
+use domain::errors::DomainError;
+use domain::user::UserId;
+
+#[test]
+fn new_activity_is_not_archived() {
+    let category = CategoryName::new("hobbies").unwrap();
+    let activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        Some(category.clone()),
+    );
+
+    assert!(!activity.is_archived());
+    assert_eq!(activity.name().value(), "gaming");
+    assert_eq!(activity.category().map(|c| c.value()), Some("hobbies"));
+}
+
+#[test]
+fn archive_sets_archived_flag() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    activity.archive().unwrap();
+
+    assert!(activity.is_archived());
+}
+
+#[test]
+fn archiving_already_archived_activity_fails() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    activity.archive().unwrap();
+    let result = activity.archive();
+
+    assert!(matches!(result, Err(DomainError::Conflict(_))));
+}
+
+#[test]
+fn unarchive_clears_archived_flag() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    activity.archive().unwrap();
+    activity.unarchive().unwrap();
+
+    assert!(!activity.is_archived());
+}
+
+#[test]
+fn unarchiving_active_activity_fails() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    let result = activity.unarchive();
+
+    assert!(matches!(result, Err(DomainError::Conflict(_))));
+}
+
+#[test]
+fn rename_updates_name() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    activity.rename(ActivityName::new("video games").unwrap());
+
+    assert_eq!(activity.name().value(), "video games");
+}
+
+#[test]
+fn set_category_updates_category() {
+    let mut activity = Activity::new(
+        UserId::generate(),
+        ActivityName::new("gaming").unwrap(),
+        None,
+    );
+
+    activity.set_category(Some(CategoryName::new("hobbies").unwrap()));
+    assert_eq!(activity.category().map(|c| c.value()), Some("hobbies"));
+
+    activity.set_category(None);
+    assert_eq!(activity.category(), None);
+}

crates/domain/tests/activity/category_name_test.rs

@@ -0,0 +1,32 @@
+use domain::activity::CategoryName;
+use domain::errors::DomainError;
+
+#[test]
+fn valid_category_name_is_created() {
+    let name = CategoryName::new("hobbies").unwrap();
+    assert_eq!(name.value(), "hobbies");
+}
+
+#[test]
+fn category_name_trims_whitespace() {
+    let name = CategoryName::new("  social  ").unwrap();
+    assert_eq!(name.value(), "social");
+}
+
+#[test]
+fn empty_category_name_is_rejected() {
+    let result = CategoryName::new("");
+    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+}
+
+#[test]
+fn whitespace_only_category_name_is_rejected() {
+    let result = CategoryName::new("   ");
+    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+}
+
+#[test]
+fn from_persistence_bypasses_validation() {
+    let name = CategoryName::from_persistence(String::new());
+    assert_eq!(name.value(), "");
+}