style: cargo fmt --all

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

@@ -1,11 +1,13 @@
-use std::sync::Arc;
 use application::sidecar::{ResolveConflictCommand, ResolveConflictHandler};
-use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
+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};
+use std::sync::Arc;
 
 fn conflict_record(asset_id: SystemId, path: &str) -> SidecarRecord {
     let mut r = SidecarRecord::new(asset_id, path);
@@ -22,17 +24,30 @@ async fn db_wins_re_exports() {
     let asset_id = SystemId::new();
     let path = format!("sidecars/{}.xmp", asset_id);
 
-    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+    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();
+    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();
+    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();
@@ -48,22 +63,34 @@ async fn file_wins_re_imports() {
     let asset_id = SystemId::new();
     let path = format!("sidecars/{}.xmp", asset_id);
 
-    sidecar_repo.save(&conflict_record(asset_id, &path)).await.unwrap();
+    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();
+    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();
+    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"));
+    assert_eq!(
+        imported.unwrap().data.get_string("title"),
+        Some("File Value")
+    );
 }
 
 #[tokio::test]
@@ -73,13 +100,18 @@ async fn user_decision_returns_error() {
     let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
 
     let asset_id = SystemId::new();
-    sidecar_repo.save(&conflict_record(asset_id, "sidecars/x.xmp")).await.unwrap();
+    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;
+    let result = handler
+        .execute(ResolveConflictCommand {
+            asset_id,
+            policy: ConflictPolicy::RequireUserDecision,
+        })
+        .await;
 
     assert!(matches!(result, Err(DomainError::Validation(msg)) if msg.contains("Manual")));
 }