app: add sidecar sync commands (export, detect, import, resolve, full export/import)

crates/application/tests/sidecar/commands/resolve_conflict.rs

@@ -0,0 +1,85 @@
+use std::sync::Arc;
+use application::sidecar::{ResolveConflictCommand, ResolveConflictHandler};
+use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
+use domain::catalog::entities::{AssetMetadata, MetadataSource};
+use domain::entities::{ConflictPolicy, SidecarRecord, SyncStatus};
+use domain::errors::DomainError;
+use domain::ports::{AssetMetadataRepository, SidecarRepository, SidecarWriterPort};
+use domain::value_objects::{MetadataValue, StructuredData, SystemId};
+
+fn conflict_record(asset_id: SystemId, path: &str) -> SidecarRecord {
+    let mut r = SidecarRecord::new(asset_id, path);
+    r.mark_conflict();
+    r
+}
+
+#[tokio::test]
+async fn db_wins_re_exports() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+
+    let mut data = StructuredData::new();
+    data.insert("title", MetadataValue::String("DB Value".into()));
+    meta_repo.save(&AssetMetadata::new(asset_id, MetadataSource::UserEdited, data)).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer.clone(), meta_repo);
+    let record = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::DbWins,
+    }).await.unwrap();
+
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+    let written = writer.get(&path).await.unwrap();
+    assert_eq!(written.get_string("title"), Some("DB Value"));
+}
+
+#[tokio::test]
+async fn file_wins_re_imports() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    let path = format!("sidecars/{}.xmp", asset_id);
+
+    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+
+    let mut file_data = StructuredData::new();
+    file_data.insert("title", MetadataValue::String("File Value".into()));
+    writer.write_sidecar(&file_data, &path).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo.clone(), writer, meta_repo.clone());
+    let record = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::FileWins,
+    }).await.unwrap();
+
+    assert_eq!(record.sync_status, SyncStatus::InSync);
+    let imported = meta_repo.find_by_asset_and_source(&asset_id, MetadataSource::ExifExtracted).await.unwrap();
+    assert!(imported.is_some());
+    assert_eq!(imported.unwrap().data.get_string("title"), Some("File Value"));
+}
+
+#[tokio::test]
+async fn user_decision_returns_error() {
+    let sidecar_repo = Arc::new(InMemorySidecarRepository::new());
+    let writer = Arc::new(InMemorySidecarWriter::new());
+    let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
+
+    let asset_id = SystemId::new();
+    sidecar_repo.save(&conflict_record(asset_id, "sidecars/x.xmp")).await.unwrap();
+
+    let handler = ResolveConflictHandler::new(sidecar_repo, writer, meta_repo);
+    let result = handler.execute(ResolveConflictCommand {
+        asset_id,
+        policy: ConflictPolicy::RequireUserDecision,
+    }).await;
+
+    assert!(matches!(result, Err(DomainError::Validation(msg)) if msg.contains("Manual")));
+}