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

16
crates/application/tests/sidecar/commands/detect_external_changes.rs
View File

@@ -1,10 +1,10 @@
use std::sync::Arc;
use application::sidecar::{DetectExternalChangesCommand, DetectExternalChangesHandler};
use application::sidecar::hash_helper::hash_structured_data;
use application::sidecar::{DetectExternalChangesCommand, DetectExternalChangesHandler};
use application::testing::{InMemorySidecarRepository, InMemorySidecarWriter};
use domain::entities::{SidecarRecord, SyncStatus};
use domain::ports::{SidecarRepository, SidecarWriterPort};
use domain::value_objects::{MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
#[tokio::test]
async fn detects_changed_sidecar() {
@@ -31,7 +31,11 @@ async fn detects_changed_sidecar() {
let changed = handler.execute(DetectExternalChangesCommand).await.unwrap();
assert_eq!(changed, 1);
let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
let updated = sidecar_repo
.find_by_asset(&asset_id)
.await
.unwrap()
.unwrap();
assert_eq!(updated.sync_status, SyncStatus::PendingRead);
}
@@ -58,6 +62,10 @@ async fn ignores_unchanged_sidecar() {
let changed = handler.execute(DetectExternalChangesCommand).await.unwrap();
assert_eq!(changed, 0);
let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
let updated = sidecar_repo
.find_by_asset(&asset_id)
.await
.unwrap()
.unwrap();
assert_eq!(updated.sync_status, SyncStatus::InSync);
}

16
crates/application/tests/sidecar/commands/export_sidecar.rs
View File

@@ -1,10 +1,12 @@
use std::sync::Arc;
use application::sidecar::{ExportSidecarCommand, ExportSidecarHandler};
use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
use application::testing::{
InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter,
};
use domain::catalog::entities::{AssetMetadata, MetadataSource};
use domain::entities::SyncStatus;
use domain::ports::SidecarRepository;
use domain::value_objects::{MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
#[tokio::test]
async fn exports_sidecar_marks_in_sync() {
@@ -20,7 +22,10 @@ async fn exports_sidecar_marks_in_sync() {
meta_repo.save(&metadata).await.unwrap();
let handler = ExportSidecarHandler::new(meta_repo, sidecar_repo.clone(), writer.clone());
let record = handler.execute(ExportSidecarCommand { asset_id }).await.unwrap();
let record = handler
.execute(ExportSidecarCommand { asset_id })
.await
.unwrap();
assert_eq!(record.sync_status, SyncStatus::InSync);
assert!(record.last_known_file_hash.is_some());
@@ -39,7 +44,10 @@ async fn creates_new_record_if_none_exists() {
let asset_id = SystemId::new();
let handler = ExportSidecarHandler::new(meta_repo, sidecar_repo.clone(), writer);
let record = handler.execute(ExportSidecarCommand { asset_id }).await.unwrap();
let record = handler
.execute(ExportSidecarCommand { asset_id })
.await
.unwrap();
assert_eq!(record.asset_id, asset_id);
assert_eq!(record.sync_status, SyncStatus::InSync);

20
crates/application/tests/sidecar/commands/full_export.rs
View File

@@ -1,12 +1,12 @@
use std::sync::Arc;
use application::sidecar::{FullExportCommand, FullExportHandler};
use application::testing::{
InMemoryAssetRepository, InMemoryAssetMetadataRepository,
InMemorySidecarRepository, InMemorySidecarWriter,
InMemoryAssetMetadataRepository, InMemoryAssetRepository, InMemorySidecarRepository,
InMemorySidecarWriter,
};
use domain::catalog::entities::{Asset, AssetMetadata, AssetType, MetadataSource, SourceReference};
use domain::ports::AssetRepository;
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
fn make_asset(owner: SystemId) -> Asset {
let source = SourceReference {
@@ -33,10 +33,20 @@ async fn exports_all_user_assets() {
let mut data = StructuredData::new();
data.insert("title", MetadataValue::String("Sunset".into()));
use domain::ports::AssetMetadataRepository;
meta_repo.save(&AssetMetadata::new(a1.asset_id, MetadataSource::UserEdited, data)).await.unwrap();
meta_repo
.save(&AssetMetadata::new(
a1.asset_id,
MetadataSource::UserEdited,
data,
))
.await
.unwrap();
let handler = FullExportHandler::new(asset_repo, meta_repo, sidecar_repo, writer.clone());
let count = handler.execute(FullExportCommand { owner_id: owner }).await.unwrap();
let count = handler
.execute(FullExportCommand { owner_id: owner })
.await
.unwrap();
assert_eq!(count, 2);

25
crates/application/tests/sidecar/commands/full_import.rs
View File

@@ -1,13 +1,15 @@
use std::sync::Arc;
use application::sidecar::{FullImportCommand, FullImportHandler};
use application::testing::{
InMemoryAssetRepository, InMemoryAssetMetadataRepository,
InMemorySidecarRepository, InMemorySidecarWriter,
InMemoryAssetMetadataRepository, InMemoryAssetRepository, InMemorySidecarRepository,
InMemorySidecarWriter,
};
use domain::catalog::entities::{Asset, AssetType, MetadataSource, SourceReference};
use domain::entities::SidecarRecord;
use domain::ports::{AssetMetadataRepository, AssetRepository, SidecarRepository, SidecarWriterPort};
use domain::ports::{
AssetMetadataRepository, AssetRepository, SidecarRepository, SidecarWriterPort,
};
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
fn make_asset(owner: SystemId) -> Asset {
let source = SourceReference {
@@ -38,10 +40,16 @@ async fn imports_from_existing_sidecars() {
writer.write_sidecar(&data, &path).await.unwrap();
let handler = FullImportHandler::new(asset_repo, meta_repo.clone(), sidecar_repo, writer);
let count = handler.execute(FullImportCommand { owner_id: owner }).await.unwrap();
let count = handler
.execute(FullImportCommand { owner_id: owner })
.await
.unwrap();
assert_eq!(count, 1);
let imported = meta_repo.find_by_asset_and_source(&asset.asset_id, MetadataSource::ExifExtracted).await.unwrap();
let imported = meta_repo
.find_by_asset_and_source(&asset.asset_id, MetadataSource::ExifExtracted)
.await
.unwrap();
assert!(imported.is_some());
assert_eq!(imported.unwrap().data.get_string("lens"), Some("50mm"));
}
@@ -59,7 +67,10 @@ async fn skips_missing_sidecars() {
// No sidecar record, no sidecar file
let handler = FullImportHandler::new(asset_repo, meta_repo, sidecar_repo, writer);
let count = handler.execute(FullImportCommand { owner_id: owner }).await.unwrap();
let count = handler
.execute(FullImportCommand { owner_id: owner })
.await
.unwrap();
assert_eq!(count, 0);
}

17
crates/application/tests/sidecar/commands/import_sidecar.rs
View File

@@ -1,11 +1,13 @@
use std::sync::Arc;
use application::sidecar::{ImportSidecarCommand, ImportSidecarHandler};
use application::testing::{InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter};
use application::testing::{
InMemoryAssetMetadataRepository, InMemorySidecarRepository, InMemorySidecarWriter,
};
use domain::catalog::entities::MetadataSource;
use domain::entities::{SidecarRecord, SyncStatus};
use domain::errors::DomainError;
use domain::ports::{SidecarRepository, SidecarWriterPort};
use domain::value_objects::{MetadataValue, StructuredData, SystemId};
use std::sync::Arc;
#[tokio::test]
async fn imports_pending_read_sidecar() {
@@ -27,12 +29,19 @@ async fn imports_pending_read_sidecar() {
writer.write_sidecar(&data, &path).await.unwrap();
let handler = ImportSidecarHandler::new(sidecar_repo.clone(), writer, meta_repo);
let metadata = handler.execute(ImportSidecarCommand { asset_id }).await.unwrap();
let metadata = handler
.execute(ImportSidecarCommand { asset_id })
.await
.unwrap();
assert_eq!(metadata.metadata_source, MetadataSource::ExifExtracted);
assert_eq!(metadata.data.get_string("camera"), Some("Canon"));
let updated = sidecar_repo.find_by_asset(&asset_id).await.unwrap().unwrap();
let updated = sidecar_repo
.find_by_asset(&asset_id)
.await
.unwrap()
.unwrap();
assert_eq!(updated.sync_status, SyncStatus::InSync);
}

6
crates/application/tests/sidecar/commands/mod.rs
View File

@@ -1,6 +1,6 @@
mod export_sidecar;
mod detect_external_changes;
mod import_sidecar;
mod resolve_conflict;
mod export_sidecar;
mod full_export;
mod full_import;
mod import_sidecar;
mod resolve_conflict;

72
crates/application/tests/sidecar/commands/resolve_conflict.rs
View File

@@ -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")));
}