style: cargo fmt --all

crates/application/tests/storage/commands/ingest_asset.rs

@@ -1,20 +1,18 @@
-use std::sync::Arc;
-use bytes::Bytes;
-use application::testing::{
-    InMemoryAssetRepository, InMemoryIngestSessionRepository,
-    InMemoryLibraryPathRepository, InMemoryQuotaRepository,
-    InMemoryStorageVolumeRepository, InMemoryUsageLedgerRepository,
-    InMemoryFileStorage, StubEventPublisher,
-};
 use application::storage::{
-    IngestAssetCommand, IngestAssetHandler,
+    IngestAssetCommand, IngestAssetHandler, RegisterLibraryPathCommand, RegisterLibraryPathHandler,
     RegisterVolumeCommand, RegisterVolumeHandler,
-    RegisterLibraryPathCommand, RegisterLibraryPathHandler,
 };
+use application::testing::{
+    InMemoryAssetRepository, InMemoryFileStorage, InMemoryIngestSessionRepository,
+    InMemoryLibraryPathRepository, InMemoryQuotaRepository, InMemoryStorageVolumeRepository,
+    InMemoryUsageLedgerRepository, StubEventPublisher,
+};
+use bytes::Bytes;
 use domain::entities::{IngestStatus, QuotaDefinition, TimePeriod, UsageType};
 use domain::errors::DomainError;
 use domain::ports::QuotaRepository;
 use domain::value_objects::SystemId;
+use std::sync::Arc;
 
 struct Harness {
     ingest_repo: Arc<InMemoryIngestSessionRepository>,
@@ -55,19 +53,26 @@ impl Harness {
 
     async fn setup_volume_and_path(&self, owner: SystemId) -> SystemId {
         let vol_handler = RegisterVolumeHandler::new(self.vol_repo.clone());
-        let vol = vol_handler.execute(RegisterVolumeCommand {
-            volume_name: "main".into(),
-            uri_prefix: "file:///data".into(),
-            is_writable: true,
-        }).await.unwrap();
+        let vol = vol_handler
+            .execute(RegisterVolumeCommand {
+                volume_name: "main".into(),
+                uri_prefix: "file:///data".into(),
+                is_writable: true,
+            })
+            .await
+            .unwrap();
 
-        let path_handler = RegisterLibraryPathHandler::new(self.vol_repo.clone(), self.path_repo.clone());
-        let path = path_handler.execute(RegisterLibraryPathCommand {
-            volume_id: vol.volume_id,
-            relative_path: "photos/inbox".into(),
-            owner_id: owner,
-            is_ingest_destination: true,
-        }).await.unwrap();
+        let path_handler =
+            RegisterLibraryPathHandler::new(self.vol_repo.clone(), self.path_repo.clone());
+        let path = path_handler
+            .execute(RegisterLibraryPathCommand {
+                volume_id: vol.volume_id,
+                relative_path: "photos/inbox".into(),
+                owner_id: owner,
+                is_ingest_destination: true,
+            })
+            .await
+            .unwrap();
         path.path_id
     }
 }
@@ -83,15 +88,18 @@ async fn ingests_successfully() {
     let path_id = h.setup_volume_and_path(user).await;
 
     let handler = h.ingest_handler();
-    let (asset, session) = handler.execute(IngestAssetCommand {
-        uploader_id: user,
-        client_device_id: "iphone-1".into(),
-        filename: "photo.jpg".into(),
-        checksum: valid_checksum(),
-        target_path_id: path_id,
-        file_size: 1024,
-        data: Bytes::from(vec![0u8; 1024]),
-    }).await.unwrap();
+    let (asset, session) = handler
+        .execute(IngestAssetCommand {
+            uploader_id: user,
+            client_device_id: "iphone-1".into(),
+            filename: "photo.jpg".into(),
+            checksum: valid_checksum(),
+            target_path_id: path_id,
+            file_size: 1024,
+            data: Bytes::from(vec![0u8; 1024]),
+        })
+        .await
+        .unwrap();
 
     assert_eq!(asset.mime_type, "image/jpeg");
     assert_eq!(asset.file_size, 1024);
@@ -111,15 +119,17 @@ async fn rejects_quota_exceeded() {
     h.quota_repo.save(&quota).await.unwrap();
 
     let handler = h.ingest_handler();
-    let result = handler.execute(IngestAssetCommand {
-        uploader_id: user,
-        client_device_id: "iphone-1".into(),
-        filename: "big.jpg".into(),
-        checksum: valid_checksum(),
-        target_path_id: path_id,
-        file_size: 1024,
-        data: Bytes::from(vec![0u8; 1024]),
-    }).await;
+    let result = handler
+        .execute(IngestAssetCommand {
+            uploader_id: user,
+            client_device_id: "iphone-1".into(),
+            filename: "big.jpg".into(),
+            checksum: valid_checksum(),
+            target_path_id: path_id,
+            file_size: 1024,
+            data: Bytes::from(vec![0u8; 1024]),
+        })
+        .await;
 
     assert!(matches!(result, Err(DomainError::QuotaExceeded(_))));
 }
@@ -131,15 +141,17 @@ async fn rejects_invalid_checksum() {
     let path_id = h.setup_volume_and_path(user).await;
 
     let handler = h.ingest_handler();
-    let result = handler.execute(IngestAssetCommand {
-        uploader_id: user,
-        client_device_id: "iphone-1".into(),
-        filename: "photo.jpg".into(),
-        checksum: "tooshort".into(),
-        target_path_id: path_id,
-        file_size: 1024,
-        data: Bytes::from(vec![0u8; 1024]),
-    }).await;
+    let result = handler
+        .execute(IngestAssetCommand {
+            uploader_id: user,
+            client_device_id: "iphone-1".into(),
+            filename: "photo.jpg".into(),
+            checksum: "tooshort".into(),
+            target_path_id: path_id,
+            file_size: 1024,
+            data: Bytes::from(vec![0u8; 1024]),
+        })
+        .await;
 
     assert!(matches!(result, Err(DomainError::Validation(_))));
 }
@@ -151,11 +163,14 @@ async fn rejects_non_ingest_path() {
 
     // Create volume + non-ingest path directly
     let vol_handler = RegisterVolumeHandler::new(h.vol_repo.clone());
-    let vol = vol_handler.execute(RegisterVolumeCommand {
-        volume_name: "main".into(),
-        uri_prefix: "file:///data".into(),
-        is_writable: true,
-    }).await.unwrap();
+    let vol = vol_handler
+        .execute(RegisterVolumeCommand {
+            volume_name: "main".into(),
+            uri_prefix: "file:///data".into(),
+            is_writable: true,
+        })
+        .await
+        .unwrap();
 
     let path = domain::entities::LibraryPath::new_user_owned(
         vol.volume_id,
@@ -167,15 +182,17 @@ async fn rejects_non_ingest_path() {
     h.path_repo.save(&path).await.unwrap();
 
     let handler = h.ingest_handler();
-    let result = handler.execute(IngestAssetCommand {
-        uploader_id: user,
-        client_device_id: "iphone-1".into(),
-        filename: "photo.jpg".into(),
-        checksum: valid_checksum(),
-        target_path_id: path.path_id,
-        file_size: 1024,
-        data: Bytes::from(vec![0u8; 1024]),
-    }).await;
+    let result = handler
+        .execute(IngestAssetCommand {
+            uploader_id: user,
+            client_device_id: "iphone-1".into(),
+            filename: "photo.jpg".into(),
+            checksum: valid_checksum(),
+            target_path_id: path.path_id,
+            file_size: 1024,
+            data: Bytes::from(vec![0u8; 1024]),
+        })
+        .await;
 
     assert!(matches!(result, Err(DomainError::Validation(_))));
 }