GKaszewski/k-photos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: cargo fmt --all

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-05-31 05:31:42 +02:00
parent 4b31a0f74b
commit c2ebca0da0
138 changed files with 2422 additions and 1164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
crates/application/tests/catalog/commands/register_asset.rs
View File

@@ -1,8 +1,10 @@
use std::sync::Arc;
use application::catalog::{RegisterAssetCommand, RegisterAssetHandler};
use application::testing::{InMemoryAssetRepository, InMemoryDuplicateRepository, StubEventPublisher};
use application::testing::{
InMemoryAssetRepository, InMemoryDuplicateRepository, StubEventPublisher,
};
use domain::catalog::entities::AssetType;
use domain::value_objects::SystemId;
use std::sync::Arc;
fn valid_checksum() -> String {
"a".repeat(64)
@@ -14,24 +16,23 @@ async fn registers_asset() {
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 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();
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);
@@ -46,37 +47,39 @@ async fn flags_duplicate_when_checksum_exists() {
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 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();
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 (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();

47
crates/application/tests/catalog/commands/update_metadata.rs
View File

@@ -1,9 +1,11 @@
use std::sync::Arc;
use application::catalog::{UpdateMetadataCommand, UpdateMetadataHandler};
use application::testing::{InMemoryAssetRepository, InMemoryAssetMetadataRepository, StubEventPublisher};
use domain::catalog::entities::{Asset, AssetType, SourceReference, MetadataSource};
use application::testing::{
InMemoryAssetMetadataRepository, InMemoryAssetRepository, StubEventPublisher,
};
use domain::catalog::entities::{Asset, AssetType, MetadataSource, SourceReference};
use domain::errors::DomainError;
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
async fn seed_asset(repo: &InMemoryAssetRepository) -> Asset {
let source = SourceReference {
@@ -11,7 +13,13 @@ async fn seed_asset(repo: &InMemoryAssetRepository) -> Asset {
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());
let asset = Asset::new(
source,
AssetType::Image,
"image/jpeg",
1024,
SystemId::new(),
);
repo.save(&asset).await.unwrap();
asset
}
@@ -26,20 +34,19 @@ async fn updates_metadata() {
let asset = seed_asset(&asset_repo).await;
let handler = UpdateMetadataHandler::new(
asset_repo.clone(),
meta_repo.clone(),
events.clone(),
);
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();
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"));
@@ -54,11 +61,13 @@ async fn rejects_nonexistent_asset() {
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;
let result = handler
.execute(UpdateMetadataCommand {
asset_id: SystemId::new(),
user_id: SystemId::new(),
data: StructuredData::new(),
})
.await;
assert!(matches!(result, Err(DomainError::NotFound(_))));
}

33
crates/application/tests/catalog/queries/get_asset.rs
View File

@@ -1,10 +1,10 @@
use std::sync::Arc;
use application::catalog::{GetAssetQuery, GetAssetHandler};
use application::testing::{InMemoryAssetRepository, InMemoryAssetMetadataRepository};
use application::catalog::{GetAssetHandler, GetAssetQuery};
use application::testing::{InMemoryAssetMetadataRepository, InMemoryAssetRepository};
use domain::catalog::entities::{Asset, AssetMetadata, AssetType, MetadataSource, SourceReference};
use domain::errors::DomainError;
use domain::ports::{AssetRepository, AssetMetadataRepository};
use domain::ports::{AssetMetadataRepository, AssetRepository};
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
#[tokio::test]
async fn returns_asset_with_resolved_metadata() {
@@ -16,7 +16,13 @@ async fn returns_asset_with_resolved_metadata() {
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());
let asset = Asset::new(
source,
AssetType::Image,
"image/jpeg",
1024,
SystemId::new(),
);
asset_repo.save(&asset).await.unwrap();
// Add exif layer
@@ -33,9 +39,12 @@ async fn returns_asset_with_resolved_metadata() {
meta_repo.save(&user_meta).await.unwrap();
let handler = GetAssetHandler::new(asset_repo, meta_repo);
let (returned, resolved) = handler.execute(GetAssetQuery {
asset_id: asset.asset_id,
}).await.unwrap();
let (returned, resolved) = handler
.execute(GetAssetQuery {
asset_id: asset.asset_id,
})
.await
.unwrap();
assert_eq!(returned.asset_id, asset.asset_id);
// UserEdited overrides ExifExtracted
@@ -50,9 +59,11 @@ async fn rejects_nonexistent() {
let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
let handler = GetAssetHandler::new(asset_repo, meta_repo);
let result = handler.execute(GetAssetQuery {
asset_id: SystemId::new(),
}).await;
let result = handler
.execute(GetAssetQuery {
asset_id: SystemId::new(),
})
.await;
assert!(matches!(result, Err(DomainError::NotFound(_))));
}

32
crates/application/tests/catalog/queries/get_timeline.rs
View File

@@ -1,9 +1,9 @@
use std::sync::Arc;
use application::catalog::{GetTimelineQuery, GetTimelineHandler};
use application::testing::{InMemoryAssetRepository, InMemoryAssetMetadataRepository};
use application::catalog::{GetTimelineHandler, GetTimelineQuery};
use application::testing::{InMemoryAssetMetadataRepository, InMemoryAssetRepository};
use domain::catalog::entities::{Asset, AssetType, SourceReference};
use domain::ports::AssetRepository;
use domain::value_objects::{Checksum, SystemId};
use std::sync::Arc;
async fn seed_assets(repo: &InMemoryAssetRepository, owner: SystemId, count: usize) {
for i in 0..count {
@@ -28,11 +28,14 @@ async fn returns_paginated_assets() {
let handler = GetTimelineHandler::new(asset_repo, meta_repo);
let page = handler.execute(GetTimelineQuery {
owner_id: owner,
limit: 3,
offset: 0,
}).await.unwrap();
let page = handler
.execute(GetTimelineQuery {
owner_id: owner,
limit: 3,
offset: 0,
})
.await
.unwrap();
assert_eq!(page.len(), 3);
}
@@ -44,11 +47,14 @@ async fn returns_empty_for_no_assets() {
let handler = GetTimelineHandler::new(asset_repo, meta_repo);
let page = handler.execute(GetTimelineQuery {
owner_id: SystemId::new(),
limit: 10,
offset: 0,
}).await.unwrap();
let page = handler
.execute(GetTimelineQuery {
owner_id: SystemId::new(),
limit: 10,
offset: 0,
})
.await
.unwrap();
assert!(page.is_empty());
}

2
crates/application/tests/catalog/queries/mod.rs
View File

@@ -1,2 +1,2 @@
mod get_timeline;
mod get_asset;
mod get_timeline;