test: move domain tests to tests/

Self dev-dep w/ test-helpers for domain::testing. Also moved social blanket-impl + InMemoryStore tests (public API only). No private-item exceptions.

crates/domain/tests/value_objects/value_objects_test.rs

@@ -0,0 +1,295 @@
+use domain::value_objects::*;
+
+#[test]
+fn movie_id_generate_unique() {
+    let a = MovieId::generate();
+    let b = MovieId::generate();
+    assert_ne!(a, b);
+}
+
+#[test]
+fn rating_valid_range() {
+    assert!(Rating::new(1).is_ok());
+    assert!(Rating::new(5).is_ok());
+    assert_eq!(Rating::new(3).unwrap().value(), 3);
+}
+
+#[test]
+fn rating_invalid() {
+    assert!(Rating::new(0).is_err());
+    assert!(Rating::new(6).is_err());
+    assert!(Rating::new(255).is_err());
+}
+
+#[test]
+fn movie_title_valid() {
+    let t = MovieTitle::new("Test".into());
+    assert!(t.is_ok());
+    assert_eq!(t.unwrap().value(), "Test");
+}
+
+#[test]
+fn movie_title_empty_rejected() {
+    assert!(MovieTitle::new("".into()).is_err());
+    assert!(MovieTitle::new("   ".into()).is_err());
+}
+
+#[test]
+fn release_year_valid() {
+    assert!(ReleaseYear::new(2024).is_ok());
+    assert_eq!(ReleaseYear::new(1888).unwrap().value(), 1888);
+}
+
+#[test]
+fn release_year_too_early() {
+    assert!(ReleaseYear::new(1887).is_err());
+}
+
+#[test]
+fn email_valid() {
+    let e = Email::new("a@b.com".into());
+    assert!(e.is_ok());
+    assert_eq!(e.unwrap().value(), "a@b.com");
+}
+
+#[test]
+fn email_invalid() {
+    assert!(Email::new("invalid".into()).is_err());
+    assert!(Email::new("".into()).is_err());
+}
+
+#[test]
+fn username_valid() {
+    let u = Username::new("test".into());
+    assert!(u.is_ok());
+    assert_eq!(u.unwrap().value(), "test");
+}
+
+#[test]
+fn username_lowercases() {
+    assert_eq!(Username::new("Alice".into()).unwrap().value(), "alice");
+}
+
+#[test]
+fn username_rejects_too_short() {
+    assert!(Username::new("a".into()).is_err());
+}
+
+#[test]
+fn username_rejects_special_chars() {
+    assert!(Username::new("no spaces".into()).is_err());
+    assert!(Username::new("no@at".into()).is_err());
+}
+
+#[test]
+fn poster_path_valid() {
+    let p = PosterPath::new("path/to/poster".into());
+    assert!(p.is_ok());
+    assert_eq!(p.unwrap().value(), "path/to/poster");
+}
+
+#[test]
+fn poster_path_empty_rejected() {
+    assert!(PosterPath::new("".into()).is_err());
+}
+
+#[test]
+fn comment_valid() {
+    let c = Comment::new("nice movie".into());
+    assert!(c.is_ok());
+    assert_eq!(c.unwrap().value(), "nice movie");
+}
+
+#[test]
+fn comment_empty_is_ok() {
+    // empty comment allowed — only max-length checked
+    assert!(Comment::new("".into()).is_ok());
+}
+
+#[test]
+fn external_metadata_id_valid() {
+    let e = ExternalMetadataId::new("tt1234567".into());
+    assert!(e.is_ok());
+    assert_eq!(e.unwrap().value(), "tt1234567");
+}
+
+#[test]
+fn external_metadata_id_empty_rejected() {
+    assert!(ExternalMetadataId::new("".into()).is_err());
+    assert!(ExternalMetadataId::new("   ".into()).is_err());
+}
+
+#[test]
+fn password_hash_valid() {
+    assert!(PasswordHash::new("hash".into()).is_ok());
+}
+
+#[test]
+fn password_hash_empty_rejected() {
+    assert!(PasswordHash::new("".into()).is_err());
+}
+
+#[test]
+fn poster_url_valid() {
+    let u = PosterUrl::new("https://img.com/poster.jpg".into());
+    assert!(u.is_ok());
+    assert_eq!(u.unwrap().value(), "https://img.com/poster.jpg");
+}
+
+#[test]
+fn poster_url_empty_rejected() {
+    assert!(PosterUrl::new("".into()).is_err());
+}
+
+#[test]
+fn password_min_length_enforced() {
+    assert!(Password::new("short".to_string()).is_err());
+    assert!(Password::new("1234567".to_string()).is_err()); // 7 chars
+}
+
+#[test]
+fn password_valid_at_eight_chars() {
+    let p = Password::new("12345678".to_string());
+    assert!(p.is_ok());
+    assert_eq!(p.unwrap().value(), "12345678");
+}
+
+#[test]
+fn password_value_preserves_content() {
+    let raw = "supersecret!".to_string();
+    assert_eq!(Password::new(raw.clone()).unwrap().value(), raw);
+}
+
+#[test]
+fn watch_medium_parses_valid_strings() {
+    let cases = [
+        ("cinema", WatchMedium::Cinema),
+        ("streaming", WatchMedium::Streaming),
+        ("tv", WatchMedium::TV),
+        ("physical_media", WatchMedium::PhysicalMedia),
+        ("download", WatchMedium::Download),
+        ("media_server", WatchMedium::MediaServer),
+        ("other", WatchMedium::Other),
+    ];
+    for (input, expected) in cases {
+        let parsed: WatchMedium = input.parse().unwrap();
+        assert_eq!(parsed, expected);
+    }
+}
+
+#[test]
+fn watch_medium_rejects_invalid() {
+    assert!("nonsense".parse::<WatchMedium>().is_err());
+    assert!("".parse::<WatchMedium>().is_err());
+}
+
+#[test]
+fn watch_medium_display_round_trips() {
+    let variants = [
+        WatchMedium::Cinema,
+        WatchMedium::Streaming,
+        WatchMedium::TV,
+        WatchMedium::PhysicalMedia,
+        WatchMedium::Download,
+        WatchMedium::MediaServer,
+        WatchMedium::Other,
+    ];
+    for v in variants {
+        let s = v.to_string();
+        let parsed: WatchMedium = s.parse().unwrap();
+        assert_eq!(parsed, v);
+    }
+}
+
+// ── InstanceIdentity ────────────────────────────────────────────────────────
+
+fn instance() -> InstanceIdentity {
+    InstanceIdentity::new("https://md.example")
+}
+
+#[test]
+fn instance_normalizes_trailing_slash() {
+    assert_eq!(
+        InstanceIdentity::new("https://md.example/").base_url(),
+        "https://md.example"
+    );
+    assert_eq!(
+        InstanceIdentity::new("https://md.example").base_url(),
+        "https://md.example"
+    );
+}
+
+#[test]
+fn instance_host_strips_scheme_and_path() {
+    assert_eq!(instance().host(), "md.example");
+    assert_eq!(
+        InstanceIdentity::new("http://localhost:3000").host(),
+        "localhost:3000"
+    );
+}
+
+#[test]
+fn instance_builds_actor_url_for_local_user() {
+    let uid = UserId::from_uuid(uuid::Uuid::nil());
+    assert_eq!(
+        instance().actor_url_for(&uid),
+        format!("https://md.example/users/{}", uuid::Uuid::nil())
+    );
+}
+
+#[test]
+fn instance_builds_handle_and_image_url() {
+    assert_eq!(instance().handle_for("gabriel"), "@gabriel@md.example");
+    assert_eq!(
+        instance().image_url_for("avatars/a.webp"),
+        "https://md.example/images/avatars/a.webp"
+    );
+}
+
+#[test]
+fn instance_identifies_own_actor_url_as_local() {
+    let uid = UserId::from_uuid(uuid::Uuid::new_v4());
+    let url = instance().actor_url_for(&uid);
+    assert_eq!(instance().identify(&url), SocialIdentity::Local(uid));
+}
+
+#[test]
+fn instance_identifies_foreign_actor_url_as_remote() {
+    let url = "https://other.example/users/bob";
+    assert_eq!(
+        instance().identify(url),
+        SocialIdentity::Remote {
+            actor_url: url.to_string()
+        }
+    );
+}
+
+#[test]
+fn instance_identifies_own_host_with_bad_uuid_as_remote() {
+    let url = "https://md.example/users/not-a-uuid";
+    assert_eq!(
+        instance().identify(url),
+        SocialIdentity::Remote {
+            actor_url: url.to_string()
+        }
+    );
+}
+
+#[test]
+fn instance_actor_url_round_trips_both_variants() {
+    let i = instance();
+    let local = SocialIdentity::Local(UserId::from_uuid(uuid::Uuid::new_v4()));
+    let remote = SocialIdentity::Remote {
+        actor_url: "https://other.example/users/bob".into(),
+    };
+    assert_eq!(i.identify(&i.actor_url_of(&local)), local);
+    assert_eq!(i.identify(&i.actor_url_of(&remote)), remote);
+}
+
+#[test]
+fn instance_rejects_prefix_collision() {
+    // A different instance whose base_url merely starts the same must not read as local.
+    let i = InstanceIdentity::new("https://md.example");
+    let url = "https://md.example.evil.test/users/00000000-0000-0000-0000-000000000000";
+    assert!(matches!(i.identify(url), SocialIdentity::Remote { .. }));
+}