app: add catalog commands/queries (RegisterAsset, UpdateMetadata, GetTimeline, GetAsset)

crates/application/tests/catalog/commands/mod.rs

@@ -0,0 +1,2 @@
+mod register_asset;
+mod update_metadata;

crates/application/tests/catalog/commands/register_asset.rs

@@ -0,0 +1,85 @@
+use std::sync::Arc;
+use application::catalog::{RegisterAssetCommand, RegisterAssetHandler};
+use application::testing::{InMemoryAssetRepository, InMemoryDuplicateRepository, StubEventPublisher};
+use domain::catalog::entities::AssetType;
+use domain::value_objects::SystemId;
+
+fn valid_checksum() -> String {
+    "a".repeat(64)
+}
+
+#[tokio::test]
+async fn registers_asset() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let dup_repo = Arc::new(InMemoryDuplicateRepository::new());
+    let events = Arc::new(StubEventPublisher::new());
+
+    let handler = RegisterAssetHandler::new(
+        asset_repo.clone(),
+        dup_repo.clone(),
+        events.clone(),
+    );
+
+    let owner = SystemId::new();
+    let volume = SystemId::new();
+
+    let (asset, dup) = handler.execute(RegisterAssetCommand {
+        volume_id: volume,
+        relative_path: "photos/img.jpg".into(),
+        checksum: valid_checksum(),
+        asset_type: AssetType::Image,
+        mime_type: "image/jpeg".into(),
+        file_size: 1024,
+        owner_id: owner,
+    }).await.unwrap();
+
+    assert_eq!(asset.mime_type, "image/jpeg");
+    assert_eq!(asset.file_size, 1024);
+    assert_eq!(asset.owner_user_id, owner);
+    assert!(dup.is_none());
+    assert_eq!(events.published().await.len(), 1);
+}
+
+#[tokio::test]
+async fn flags_duplicate_when_checksum_exists() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let dup_repo = Arc::new(InMemoryDuplicateRepository::new());
+    let events = Arc::new(StubEventPublisher::new());
+
+    let handler = RegisterAssetHandler::new(
+        asset_repo.clone(),
+        dup_repo.clone(),
+        events.clone(),
+    );
+
+    let owner = SystemId::new();
+    let volume = SystemId::new();
+    let checksum = valid_checksum();
+
+    // First asset
+    let (first, _) = handler.execute(RegisterAssetCommand {
+        volume_id: volume,
+        relative_path: "photos/img1.jpg".into(),
+        checksum: checksum.clone(),
+        asset_type: AssetType::Image,
+        mime_type: "image/jpeg".into(),
+        file_size: 1024,
+        owner_id: owner,
+    }).await.unwrap();
+
+    // Second asset with same checksum
+    let (second, dup) = handler.execute(RegisterAssetCommand {
+        volume_id: volume,
+        relative_path: "photos/img2.jpg".into(),
+        checksum,
+        asset_type: AssetType::Image,
+        mime_type: "image/jpeg".into(),
+        file_size: 1024,
+        owner_id: owner,
+    }).await.unwrap();
+
+    let group = dup.expect("should flag duplicate");
+    let candidate_ids: Vec<_> = group.candidates.iter().map(|c| c.asset_id).collect();
+    assert!(candidate_ids.contains(&first.asset_id));
+    assert!(candidate_ids.contains(&second.asset_id));
+}

crates/application/tests/catalog/commands/update_metadata.rs

@@ -0,0 +1,64 @@
+use std::sync::Arc;
+use application::catalog::{UpdateMetadataCommand, UpdateMetadataHandler};
+use application::testing::{InMemoryAssetRepository, InMemoryAssetMetadataRepository, StubEventPublisher};
+use domain::catalog::entities::{Asset, AssetType, SourceReference, MetadataSource};
+use domain::errors::DomainError;
+use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
+
+async fn seed_asset(repo: &InMemoryAssetRepository) -> Asset {
+    let source = SourceReference {
+        volume_id: SystemId::new(),
+        relative_path: "photos/img.jpg".into(),
+        checksum: Checksum::new("a".repeat(64)).unwrap(),
+    };
+    let asset = Asset::new(source, AssetType::Image, "image/jpeg", 1024, SystemId::new());
+    repo.save(&asset).await.unwrap();
+    asset
+}
+
+use domain::ports::AssetRepository;
+
+#[tokio::test]
+async fn updates_metadata() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let events = Arc::new(StubEventPublisher::new());
+
+    let asset = seed_asset(&asset_repo).await;
+
+    let handler = UpdateMetadataHandler::new(
+        asset_repo.clone(),
+        meta_repo.clone(),
+        events.clone(),
+    );
+
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("Sunset".into()));
+
+    let result = handler.execute(UpdateMetadataCommand {
+        asset_id: asset.asset_id,
+        user_id: SystemId::new(),
+        data,
+    }).await.unwrap();
+
+    assert_eq!(result.metadata_source, MetadataSource::UserEdited);
+    assert_eq!(result.data.get_string("title"), Some("Sunset"));
+    assert_eq!(events.published().await.len(), 1);
+}
+
+#[tokio::test]
+async fn rejects_nonexistent_asset() {
+    let asset_repo = Arc::new(InMemoryAssetRepository::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+    let events = Arc::new(StubEventPublisher::new());
+
+    let handler = UpdateMetadataHandler::new(asset_repo, meta_repo, events);
+
+    let result = handler.execute(UpdateMetadataCommand {
+        asset_id: SystemId::new(),
+        user_id: SystemId::new(),
+        data: StructuredData::new(),
+    }).await;
+
+    assert!(matches!(result, Err(DomainError::NotFound(_))));
+}