99 lines
3.4 KiB
Rust
99 lines
3.4 KiB
Rust
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::{AssetMetadataRepository, AssetRepository};
|
|
use domain::value_objects::{Checksum, MetadataValue, StructuredData, SystemId};
|
|
use std::sync::Arc;
|
|
|
|
#[tokio::test]
|
|
async fn returns_asset_with_resolved_metadata() {
|
|
let asset_repo = Arc::new(InMemoryAssetRepository::new());
|
|
let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
|
|
|
|
let source = SourceReference {
|
|
volume_id: SystemId::new(),
|
|
relative_path: "photos/img.jpg".into(),
|
|
checksum: Checksum::new("a".repeat(64)).unwrap(),
|
|
};
|
|
let owner = SystemId::new();
|
|
let asset = Asset::new(
|
|
source,
|
|
AssetType::Image,
|
|
"image/jpeg",
|
|
1024,
|
|
owner,
|
|
);
|
|
asset_repo.save(&asset).await.unwrap();
|
|
|
|
// Add exif layer
|
|
let mut exif_data = StructuredData::new();
|
|
exif_data.insert("camera", MetadataValue::String("Nikon".into()));
|
|
exif_data.insert("title", MetadataValue::String("EXIF title".into()));
|
|
let exif = AssetMetadata::new(asset.asset_id, MetadataSource::ExifExtracted, exif_data);
|
|
meta_repo.save(&exif).await.unwrap();
|
|
|
|
// Add user layer (overrides title)
|
|
let mut user_data = StructuredData::new();
|
|
user_data.insert("title", MetadataValue::String("My Photo".into()));
|
|
let user_meta = AssetMetadata::new(asset.asset_id, MetadataSource::UserEdited, user_data);
|
|
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,
|
|
user_id: owner,
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(returned.asset_id, asset.asset_id);
|
|
// UserEdited overrides ExifExtracted
|
|
assert_eq!(resolved.get_string("title"), Some("My Photo"));
|
|
// ExifExtracted field preserved
|
|
assert_eq!(resolved.get_string("camera"), Some("Nikon"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn rejects_nonexistent() {
|
|
let asset_repo = Arc::new(InMemoryAssetRepository::new());
|
|
let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
|
|
|
|
let handler = GetAssetHandler::new(asset_repo, meta_repo);
|
|
let result = handler
|
|
.execute(GetAssetQuery {
|
|
asset_id: SystemId::new(),
|
|
user_id: SystemId::new(),
|
|
})
|
|
.await;
|
|
|
|
assert!(matches!(result, Err(DomainError::NotFound(_))));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn rejects_forbidden_access() {
|
|
let asset_repo = Arc::new(InMemoryAssetRepository::new());
|
|
let meta_repo = Arc::new(InMemoryAssetMetadataRepository::new());
|
|
|
|
let source = SourceReference {
|
|
volume_id: SystemId::new(),
|
|
relative_path: "photos/img.jpg".into(),
|
|
checksum: Checksum::new("a".repeat(64)).unwrap(),
|
|
};
|
|
let owner = SystemId::new();
|
|
let asset = Asset::new(source, AssetType::Image, "image/jpeg", 1024, owner);
|
|
asset_repo.save(&asset).await.unwrap();
|
|
|
|
let handler = GetAssetHandler::new(asset_repo, meta_repo);
|
|
let other_user = SystemId::new();
|
|
let result = handler
|
|
.execute(GetAssetQuery {
|
|
asset_id: asset.asset_id,
|
|
user_id: other_user,
|
|
})
|
|
.await;
|
|
|
|
assert!(matches!(result, Err(DomainError::Forbidden(_))));
|
|
}
|