add 400+ unit tests for domain and application layers

Extract ReviewLogger trait to decouple import/integrations
from diary::log_review (cross-module coupling smell).

Add in-memory fakes for all repository ports, enabling
isolated testing of every use case module without a database.

Coverage: domain+application 22% → 80%, 427 tests.

crates/domain/src/models/goal.rs

@@ -109,3 +109,98 @@ impl GoalWithProgress {
         self.current_count >= self.goal.target_count
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::value_objects::UserId;
+
+    fn make_goal(year: u16, target: u32) -> Result<Goal, DomainError> {
+        Goal::new(UserId::generate(), year, target, GoalType::Movies)
+    }
+
+    #[test]
+    fn new_goal_valid() {
+        let g = make_goal(2024, 52);
+        assert!(g.is_ok());
+        let g = g.unwrap();
+        assert_eq!(g.year(), 2024);
+        assert_eq!(g.target_count(), 52);
+    }
+
+    #[test]
+    fn new_goal_rejects_year_before_2020() {
+        assert!(make_goal(2019, 10).is_err());
+    }
+
+    #[test]
+    fn new_goal_rejects_zero_target() {
+        assert!(make_goal(2024, 0).is_err());
+    }
+
+    #[test]
+    fn update_target_valid() {
+        let mut g = make_goal(2024, 10).unwrap();
+        assert!(g.update_target(50).is_ok());
+        assert_eq!(g.target_count(), 50);
+    }
+
+    #[test]
+    fn update_target_rejects_zero() {
+        let mut g = make_goal(2024, 10).unwrap();
+        assert!(g.update_target(0).is_err());
+    }
+
+    #[test]
+    fn from_persistence_preserves_fields() {
+        let id = GoalId::generate();
+        let uid = UserId::generate();
+        let ts = chrono::Utc::now().naive_utc();
+        let g = Goal::from_persistence(id.clone(), uid.clone(), 2025, 42, GoalType::Movies, ts);
+        assert_eq!(*g.id(), id);
+        assert_eq!(*g.user_id(), uid);
+        assert_eq!(g.year(), 2025);
+        assert_eq!(g.target_count(), 42);
+        assert_eq!(g.created_at(), &ts);
+    }
+
+    #[test]
+    fn percentage_calculation() {
+        let g = make_goal(2024, 100).unwrap();
+        let wp = GoalWithProgress {
+            goal: g,
+            current_count: 50,
+        };
+        assert!((wp.percentage() - 50.0).abs() < f64::EPSILON);
+    }
+
+    #[test]
+    fn percentage_caps_at_100() {
+        let g = make_goal(2024, 10).unwrap();
+        let wp = GoalWithProgress {
+            goal: g,
+            current_count: 20,
+        };
+        assert!((wp.percentage() - 100.0).abs() < f64::EPSILON);
+    }
+
+    #[test]
+    fn is_complete() {
+        let g = make_goal(2024, 10).unwrap();
+        let wp = GoalWithProgress {
+            goal: g,
+            current_count: 10,
+        };
+        assert!(wp.is_complete());
+    }
+
+    #[test]
+    fn is_not_complete() {
+        let g = make_goal(2024, 10).unwrap();
+        let wp = GoalWithProgress {
+            goal: g,
+            current_count: 9,
+        };
+        assert!(!wp.is_complete());
+    }
+}

crates/domain/src/models/person.rs

@@ -111,3 +111,62 @@ pub struct CrewCredit {
     pub department: String,
     pub poster_path: Option<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn person_new() {
+        let ext = ExternalPersonId::new("tmdb:12345");
+        let pid = PersonId::from_external(&ext);
+        let p = Person::new(
+            pid,
+            ext,
+            "Keanu Reeves".into(),
+            Some("Acting".into()),
+            Some("/profiles/keanu.jpg".into()),
+        );
+        assert_eq!(p.name(), "Keanu Reeves");
+        assert_eq!(p.known_for_department(), Some("Acting"));
+        assert_eq!(p.profile_path(), Some("/profiles/keanu.jpg"));
+        assert_eq!(p.external_id().value(), "tmdb:12345");
+        assert_eq!(p.external_id().tmdb_id(), Some(12345));
+    }
+
+    #[test]
+    fn person_id_from_external() {
+        let ext = ExternalPersonId::new("tmdb:99999");
+        let pid = PersonId::from_external(&ext);
+        // UUIDv5 is deterministic — just ensure it's a valid uuid
+        let _ = pid.value();
+    }
+
+    #[test]
+    fn person_id_deterministic() {
+        let ext = ExternalPersonId::new("tmdb:42");
+        let a = PersonId::from_external(&ext);
+        let b = PersonId::from_external(&ext);
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn person_credits_default_empty() {
+        let ext = ExternalPersonId::new("tmdb:1");
+        let pid = PersonId::from_external(&ext);
+        let p = Person::new(pid, ext, "Test".into(), None, None);
+        let credits = PersonCredits {
+            person: p,
+            cast: vec![],
+            crew: vec![],
+        };
+        assert!(credits.cast.is_empty());
+        assert!(credits.crew.is_empty());
+    }
+
+    #[test]
+    fn external_person_id_tmdb_id_none_for_other() {
+        let ext = ExternalPersonId::new("imdb:nm0000206");
+        assert_eq!(ext.tmdb_id(), None);
+    }
+}

crates/domain/src/models/tests.rs

@@ -36,3 +36,197 @@ fn update_profile_clears_with_none() {
     assert_eq!(user.bio(), None);
     assert_eq!(user.avatar_path(), None);
 }
+
+// ── Movie ────────────────────────────────────────────────────────────────────
+
+fn make_movie() -> Movie {
+    Movie::new(
+        Some(crate::value_objects::ExternalMetadataId::new("tt1234567".into()).unwrap()),
+        crate::value_objects::MovieTitle::new("Blade Runner".into()).unwrap(),
+        crate::value_objects::ReleaseYear::new(1982).unwrap(),
+        Some("Ridley Scott".into()),
+        Some(crate::value_objects::PosterPath::new("/poster.jpg".into()).unwrap()),
+    )
+}
+
+#[test]
+fn movie_new_sets_fields() {
+    let m = make_movie();
+    assert_eq!(m.title().value(), "Blade Runner");
+    assert_eq!(m.release_year().value(), 1982);
+    assert_eq!(m.director(), Some("Ridley Scott"));
+    assert!(m.poster_path().is_some());
+    assert!(m.external_metadata_id().is_some());
+}
+
+#[test]
+fn movie_update_poster() {
+    let mut m = make_movie();
+    let new_poster = crate::value_objects::PosterPath::new("/new.jpg".into()).unwrap();
+    m.update_poster(new_poster);
+    assert_eq!(m.poster_path().unwrap().value(), "/new.jpg");
+}
+
+// ── Review ───────────────────────────────────────────────────────────────────
+
+use crate::value_objects::{Comment, MovieId, Rating, ReviewId};
+
+fn make_review() -> Review {
+    Review::new(
+        MovieId::generate(),
+        UserId::generate(),
+        Rating::new(4).unwrap(),
+        Some(Comment::new("great".into()).unwrap()),
+        chrono::Utc::now().naive_utc(),
+    )
+    .unwrap()
+}
+
+#[test]
+fn review_new_sets_local_source() {
+    let r = make_review();
+    assert_eq!(*r.source(), ReviewSource::Local);
+    assert!(!r.is_remote());
+}
+
+#[test]
+fn review_stars() {
+    let r = make_review(); // rating=4
+    assert_eq!(r.stars(), [true, true, true, true, false]);
+}
+
+#[test]
+fn review_from_persistence() {
+    let id = ReviewId::generate();
+    let mid = MovieId::generate();
+    let uid = UserId::generate();
+    let ts = chrono::Utc::now().naive_utc();
+    let r = Review::from_persistence(PersistedReview {
+        id: id.clone(),
+        movie_id: mid.clone(),
+        user_id: uid.clone(),
+        rating: Rating::new(2).unwrap(),
+        comment: None,
+        watched_at: ts,
+        created_at: ts,
+        source: ReviewSource::Remote {
+            actor_url: "https://example.com/actor".into(),
+        },
+    });
+    assert_eq!(*r.id(), id);
+    assert!(r.is_remote());
+    assert_eq!(r.comment(), None);
+}
+
+// ── User ─────────────────────────────────────────────────────────────────────
+
+#[test]
+fn user_new() {
+    let u = User::new(
+        Email::new("x@y.com".into()).unwrap(),
+        Username::new("bob".into()).unwrap(),
+        PasswordHash::new("hashed".into()).unwrap(),
+        UserRole::Admin,
+    );
+    assert_eq!(u.email().value(), "x@y.com");
+    assert_eq!(u.username().value(), "bob");
+    assert_eq!(u.role().as_str(), "admin");
+    assert_eq!(u.bio(), None);
+}
+
+#[test]
+fn user_update_password() {
+    let mut u = make_user();
+    u.update_password(PasswordHash::new("new_hash".into()).unwrap());
+    assert_eq!(u.password_hash().value(), "new_hash");
+}
+
+// ── GoalType ─────────────────────────────────────────────────────────────────
+
+#[test]
+fn goal_type_as_str() {
+    assert_eq!(GoalType::Movies.as_str(), "movies");
+}
+
+#[test]
+fn goal_type_from_str() {
+    assert_eq!("movies".parse::<GoalType>().unwrap(), GoalType::Movies);
+    assert!("invalid".parse::<GoalType>().is_err());
+}
+
+// ── UserRole ─────────────────────────────────────────────────────────────────
+
+#[test]
+fn user_role_as_str() {
+    assert_eq!(UserRole::Standard.as_str(), "standard");
+    assert_eq!(UserRole::Admin.as_str(), "admin");
+}
+
+// ── ProfileField ─────────────────────────────────────────────────────────────
+
+#[test]
+fn profile_field_construction() {
+    let f = ProfileField {
+        name: "Website".into(),
+        value: "https://example.com".into(),
+    };
+    assert_eq!(f.name, "Website");
+    assert_eq!(f.value, "https://example.com");
+}
+
+// ── MovieStats ───────────────────────────────────────────────────────────────
+
+#[test]
+fn movie_stats_construction() {
+    let s = MovieStats {
+        total_count: 100,
+        avg_rating: Some(3.5),
+        federated_count: 10,
+        rating_histogram: [5, 10, 30, 40, 15],
+    };
+    assert_eq!(s.total_count, 100);
+    assert_eq!(s.rating_histogram[4], 15);
+}
+
+// ── FeedEntry ────────────────────────────────────────────────────────────────
+
+#[test]
+fn feed_entry_display_name_from_email() {
+    let entry = DiaryEntry::new(make_movie(), make_review());
+    let fe = FeedEntry::new(entry, "alice@example.com".into());
+    assert_eq!(fe.user_display_name(), "alice");
+    assert_eq!(fe.user_email(), "alice@example.com");
+}
+
+// ── MonthActivity ────────────────────────────────────────────────────────────
+
+#[test]
+fn month_activity_construction() {
+    let ma = MonthActivity {
+        year_month: "2024-06".into(),
+        month_label: "June".into(),
+        count: 5,
+        entries: vec![],
+    };
+    assert_eq!(ma.year_month, "2024-06");
+    assert_eq!(ma.count, 5);
+    assert!(ma.entries.is_empty());
+}
+
+// ── Movie::is_manual_match ───────────────────────────────────────────────────
+
+#[test]
+fn movie_is_manual_match_same_title_year() {
+    let m = make_movie();
+    let title = crate::value_objects::MovieTitle::new("Blade Runner".into()).unwrap();
+    let year = crate::value_objects::ReleaseYear::new(1982).unwrap();
+    assert!(m.is_manual_match(&title, &year, Some("ridley scott")));
+}
+
+#[test]
+fn movie_is_manual_match_different_director_fails() {
+    let m = make_movie();
+    let title = crate::value_objects::MovieTitle::new("Blade Runner".into()).unwrap();
+    let year = crate::value_objects::ReleaseYear::new(1982).unwrap();
+    assert!(!m.is_manual_match(&title, &year, Some("Denis Villeneuve")));
+}

crates/domain/src/models/watch_event.rs

@@ -234,3 +234,143 @@ pub struct ParsedPlaybackEvent {
     pub tmdb_id: Option<String>,
     pub imdb_id: Option<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ts() -> NaiveDateTime {
+        chrono::NaiveDate::from_ymd_opt(2024, 6, 1)
+            .unwrap()
+            .and_hms_opt(12, 0, 0)
+            .unwrap()
+    }
+
+    #[test]
+    fn watch_event_new_has_pending_status() {
+        let e = WatchEvent::new(
+            UserId::generate(),
+            "Dune".into(),
+            Some(2021),
+            None,
+            WatchEventSource::Jellyfin,
+            ts(),
+            None,
+        );
+        assert_eq!(*e.status(), WatchEventStatus::Pending);
+    }
+
+    #[test]
+    fn watch_event_getters() {
+        let uid = UserId::generate();
+        let mid = MovieId::generate();
+        let e = WatchEvent::new(
+            uid.clone(),
+            "Arrival".into(),
+            Some(2016),
+            Some("ext123".into()),
+            WatchEventSource::Plex,
+            ts(),
+            Some(mid.clone()),
+        );
+        assert_eq!(*e.user_id(), uid);
+        assert_eq!(e.title(), "Arrival");
+        assert_eq!(e.year(), Some(2016));
+        assert_eq!(e.external_metadata_id(), Some("ext123"));
+        assert_eq!(*e.source(), WatchEventSource::Plex);
+        assert_eq!(e.watched_at(), &ts());
+        assert_eq!(*e.movie_id().unwrap(), mid);
+    }
+
+    #[test]
+    fn webhook_token_new() {
+        let uid = UserId::generate();
+        let t = WebhookToken::new(
+            uid.clone(),
+            "hash123".into(),
+            WatchEventSource::Jellyfin,
+            Some("my server".into()),
+        );
+        assert_eq!(*t.user_id(), uid);
+        assert_eq!(t.token_hash(), "hash123");
+        assert_eq!(*t.provider(), WatchEventSource::Jellyfin);
+        assert_eq!(t.label(), Some("my server"));
+        assert!(t.last_used_at().is_none());
+    }
+
+    #[test]
+    fn webhook_token_from_persistence() {
+        let id = WebhookTokenId::generate();
+        let uid = UserId::generate();
+        let created = ts();
+        let used = chrono::NaiveDate::from_ymd_opt(2024, 7, 1)
+            .unwrap()
+            .and_hms_opt(0, 0, 0)
+            .unwrap();
+        let t = WebhookToken::from_persistence(
+            id.clone(),
+            uid.clone(),
+            "h".into(),
+            WatchEventSource::Plex,
+            None,
+            created,
+            Some(used),
+        );
+        assert_eq!(*t.id(), id);
+        assert_eq!(*t.user_id(), uid);
+        assert_eq!(t.token_hash(), "h");
+        assert_eq!(*t.provider(), WatchEventSource::Plex);
+        assert_eq!(t.label(), None);
+        assert_eq!(t.created_at(), &created);
+        assert_eq!(t.last_used_at(), Some(&used));
+    }
+
+    #[test]
+    fn watch_event_source_display() {
+        assert_eq!(WatchEventSource::Jellyfin.to_string(), "jellyfin");
+        assert_eq!(WatchEventSource::Plex.to_string(), "plex");
+    }
+
+    #[test]
+    fn watch_event_source_from_str() {
+        assert_eq!(
+            "jellyfin".parse::<WatchEventSource>().unwrap(),
+            WatchEventSource::Jellyfin
+        );
+        assert_eq!(
+            "plex".parse::<WatchEventSource>().unwrap(),
+            WatchEventSource::Plex
+        );
+        assert!("unknown".parse::<WatchEventSource>().is_err());
+    }
+
+    #[test]
+    fn watch_event_status_display() {
+        assert_eq!(WatchEventStatus::Pending.to_string(), "pending");
+        assert_eq!(WatchEventStatus::Confirmed.to_string(), "confirmed");
+        assert_eq!(WatchEventStatus::Dismissed.to_string(), "dismissed");
+    }
+
+    #[test]
+    fn watch_event_status_from_str() {
+        for s in ["pending", "confirmed", "dismissed"] {
+            let parsed: WatchEventStatus = s.parse().unwrap();
+            assert_eq!(parsed.to_string(), s);
+        }
+        assert!("bogus".parse::<WatchEventStatus>().is_err());
+    }
+
+    #[test]
+    fn parsed_playback_event_fields() {
+        let p = ParsedPlaybackEvent {
+            title: "Matrix".into(),
+            year: Some(1999),
+            tmdb_id: Some("603".into()),
+            imdb_id: Some("tt0133093".into()),
+        };
+        assert_eq!(p.title, "Matrix");
+        assert_eq!(p.year, Some(1999));
+        assert_eq!(p.tmdb_id.as_deref(), Some("603"));
+        assert_eq!(p.imdb_id.as_deref(), Some("tt0133093"));
+    }
+}