GKaszewski/movies-diary
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: remaining MEDIUM — CQRS splits, DI Deps, profile dedup, event Value, response enum

Browse Source 
M1: MovieRepository→MovieCommand/MovieQuery, WatchEventRepository→
WatchEventCommand/WatchEventQuery
M2: goals/ and import/ use Deps structs
M7: extract upload_image helper in update_profile
M8: FederationDeliveryRequested activity_json String→serde_json::Value
M11: UserProfileResponse uses ProfileViewData enum
This commit is contained in:
Gabriel Kaszewski
2026-07-10 03:50:43 +02:00
parent 12da356a40
commit dee013c7eb
99 changed files with 1262 additions and 896 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
crates/application/src/import/apply_mapping.rs
View File

@@ -3,22 +3,21 @@ use std::sync::Arc;
use domain::{
errors::DomainError,
models::{AnnotatedRow, import::RowResult},
ports::{DocumentParser, ImportSessionRepository, MovieRepository},
ports::MovieQuery,
value_objects::{ExternalMetadataId, ImportSessionId, MovieTitle, ReleaseYear, UserId},
};
use crate::import::commands::ApplyImportMappingCommand;
use super::{commands::ApplyImportMappingCommand, deps::ApplyMappingDeps};
pub async fn execute(
import_session: Arc<dyn ImportSessionRepository>,
document_parser: Arc<dyn DocumentParser>,
movie: Arc<dyn MovieRepository>,
deps: &ApplyMappingDeps,
cmd: ApplyImportMappingCommand,
) -> Result<Vec<AnnotatedRow>, DomainError> {
let user_id = UserId::from_uuid(cmd.user_id);
let session_id = ImportSessionId::from_uuid(cmd.session_id);
let mappings = cmd.mappings;
let mut session = import_session
let mut session = deps
.import_session
.get(&session_id, &user_id)
.await?
.ok_or_else(|| DomainError::NotFound("import session".into()))?;
@@ -28,20 +27,20 @@ pub async fn execute(
.clone()
.ok_or_else(|| DomainError::ValidationError("session has no parsed file".into()))?;
let mut annotated = document_parser.apply_mapping(&parsed, &mappings);
let mut annotated = deps.document_parser.apply_mapping(&parsed, &mappings);
mark_duplicates(movie, &mut annotated).await?;
mark_duplicates(deps.movie_query.clone(), &mut annotated).await?;
session.field_mappings = Some(mappings);
session.row_results = Some(annotated.clone());
import_session.update(&session).await?;
deps.import_session.update(&session).await?;
Ok(annotated)
}
async fn mark_duplicates(
movie: Arc<dyn MovieRepository>,
movie: Arc<dyn MovieQuery>,
rows: &mut [AnnotatedRow],
) -> Result<(), DomainError> {
let mut ext_ids = Vec::new();

17
crates/application/src/import/apply_profile.rs
View File

@@ -1,34 +1,33 @@
use std::sync::Arc;
use crate::import::commands::ApplyImportProfileCommand;
use domain::{
errors::DomainError,
ports::{ImportProfileRepository, ImportSessionRepository},
value_objects::{ImportProfileId, ImportSessionId, UserId},
};
use super::{commands::ApplyImportProfileCommand, deps::ApplyProfileDeps};
/// Copies the profile's field_mappings onto the session. Caller must then invoke
/// apply_import_mapping to regenerate row_results with the new mappings.
pub async fn execute(
import_profile: Arc<dyn ImportProfileRepository>,
import_session: Arc<dyn ImportSessionRepository>,
deps: &ApplyProfileDeps,
cmd: ApplyImportProfileCommand,
) -> Result<(), DomainError> {
let user_id = UserId::from_uuid(cmd.user_id);
let session_id = ImportSessionId::from_uuid(cmd.session_id);
let profile_id = ImportProfileId::from_uuid(cmd.profile_id);
let profile = import_profile
let profile = deps
.import_profile
.get(&profile_id, &user_id)
.await?
.ok_or_else(|| DomainError::NotFound("import profile".into()))?;
let mut session = import_session
let mut session = deps
.import_session
.get(&session_id, &user_id)
.await?
.ok_or_else(|| DomainError::NotFound("import session".into()))?;
session.field_mappings = Some(profile.field_mappings);
session.row_results = None;
import_session.update(&session).await
deps.import_session.update(&session).await
}
#[cfg(test)]

15
crates/application/src/import/create_session.rs
View File

@@ -1,13 +1,10 @@
use std::sync::Arc;
use domain::{
errors::DomainError,
models::ImportSession,
ports::{DocumentParser, ImportSessionRepository},
value_objects::{ImportSessionId, UserId},
};
use crate::import::commands::CreateImportSessionCommand;
use super::{commands::CreateImportSessionCommand, deps::CreateSessionDeps};
pub struct CreateSessionResult {
pub session_id: ImportSessionId,
@@ -16,14 +13,14 @@ pub struct CreateSessionResult {
}
pub async fn execute(
import_session: Arc<dyn ImportSessionRepository>,
document_parser: Arc<dyn DocumentParser>,
deps: &CreateSessionDeps,
cmd: CreateImportSessionCommand,
) -> Result<CreateSessionResult, DomainError> {
let user_id = UserId::from_uuid(cmd.user_id);
import_session.delete_expired_for_user(&user_id).await?;
deps.import_session.delete_expired_for_user(&user_id).await?;
let parsed = document_parser
let parsed = deps
.document_parser
.parse(&cmd.bytes, cmd.format)
.map_err(|e| DomainError::ValidationError(e.to_string()))?;
@@ -34,7 +31,7 @@ pub async fn execute(
let session_id = session.id.clone();
session.parsed_file = Some(parsed);
import_session.create(&session).await?;
deps.import_session.create(&session).await?;
Ok(CreateSessionResult {
session_id,

31
crates/application/src/import/deps.rs Normal file
View File

@@ -0,0 +1,31 @@
use std::sync::Arc;
use domain::ports::{DocumentParser, ImportProfileRepository, ImportSessionRepository, MovieQuery};
use crate::ports::ReviewLogger;
pub struct CreateSessionDeps {
pub import_session: Arc<dyn ImportSessionRepository>,
pub document_parser: Arc<dyn DocumentParser>,
}
pub struct ApplyMappingDeps {
pub import_session: Arc<dyn ImportSessionRepository>,
pub document_parser: Arc<dyn DocumentParser>,
pub movie_query: Arc<dyn MovieQuery>,
}
pub struct ApplyProfileDeps {
pub import_profile: Arc<dyn ImportProfileRepository>,
pub import_session: Arc<dyn ImportSessionRepository>,
}
pub struct ExecuteImportDeps {
pub import_session: Arc<dyn ImportSessionRepository>,
pub review_logger: Arc<dyn ReviewLogger>,
}
pub struct SaveProfileDeps {
pub import_session: Arc<dyn ImportSessionRepository>,
pub import_profile: Arc<dyn ImportProfileRepository>,
}

14
crates/application/src/import/execute.rs
View File

@@ -4,7 +4,6 @@ use chrono::NaiveDateTime;
use domain::{
errors::DomainError,
models::{ImportRow, import::RowResult},
ports::ImportSessionRepository,
value_objects::{ImportSessionId, UserId},
};
use uuid::Uuid;
@@ -12,9 +11,10 @@ use uuid::Uuid;
use crate::{
diary::commands::{LogReviewCommand, MovieInput},
import::commands::ExecuteImportCommand,
ports::ReviewLogger,
};
use super::deps::ExecuteImportDeps;
const CONCURRENCY_LIMIT: usize = 10;
pub struct ImportSummary {
@@ -24,14 +24,14 @@ pub struct ImportSummary {
}
pub async fn execute(
import_session: Arc<dyn ImportSessionRepository>,
review_logger: Arc<dyn ReviewLogger>,
deps: &ExecuteImportDeps,
cmd: ExecuteImportCommand,
) -> Result<ImportSummary, DomainError> {
let user_id = UserId::from_uuid(cmd.user_id);
let session_id = ImportSessionId::from_uuid(cmd.session_id);
let confirmed_indices = cmd.confirmed_indices;
let session = import_session
let session = deps
.import_session
.get(&session_id, &user_id)
.await?
.ok_or_else(|| DomainError::NotFound("import session".into()))?;
@@ -59,7 +59,7 @@ pub async fn execute(
Err(e) => failed.push((idx, e)),
Ok(log_cmd) => {
let permit = Arc::clone(&semaphore).acquire_owned().await.unwrap();
let logger = Arc::clone(&review_logger);
let logger = deps.review_logger.clone();
tasks.spawn(async move {
let result = logger.log_review(log_cmd).await.map_err(|e| e.to_string());
drop(permit);
@@ -78,7 +78,7 @@ pub async fn execute(
}
}
import_session.delete(&session_id).await?;
deps.import_session.delete(&session_id).await?;
Ok(ImportSummary {
imported,

1
crates/application/src/import/mod.rs
View File

@@ -4,6 +4,7 @@ pub mod cleanup;
pub mod commands;
pub mod create_session;
pub mod delete_profile;
pub mod deps;
pub mod execute;
pub mod list_profiles;
pub mod save_profile;

14
crates/application/src/import/save_profile.rs
View File

@@ -1,23 +1,21 @@
use std::sync::Arc;
use crate::import::commands::SaveImportProfileCommand;
use chrono::Utc;
use domain::{
errors::DomainError,
models::ImportProfile,
ports::{ImportProfileRepository, ImportSessionRepository},
value_objects::{ImportProfileId, ImportSessionId, UserId},
};
use super::{commands::SaveImportProfileCommand, deps::SaveProfileDeps};
pub async fn execute(
import_session: Arc<dyn ImportSessionRepository>,
import_profile: Arc<dyn ImportProfileRepository>,
deps: &SaveProfileDeps,
cmd: SaveImportProfileCommand,
) -> Result<ImportProfileId, DomainError> {
let user_id = UserId::from_uuid(cmd.user_id);
let session_id = ImportSessionId::from_uuid(cmd.session_id);
let session = import_session
let session = deps
.import_session
.get(&session_id, &user_id)
.await?
.ok_or_else(|| DomainError::NotFound("import session".into()))?;
@@ -32,7 +30,7 @@ pub async fn execute(
Utc::now().naive_utc(),
);
let id = profile.id.clone();
import_profile.save(&profile).await?;
deps.import_profile.save(&profile).await?;
Ok(id)
}

67
crates/application/src/import/tests/apply_mapping.rs
View File

@@ -7,11 +7,12 @@ use domain::{
AnnotatedRow, Movie,
import::{ImportRow, ParsedFile, RowResult},
},
ports::{DocumentParser, MovieRepository},
ports::{DocumentParser, MovieCommand},
testing::{InMemoryImportSessionRepository, InMemoryMovieRepository},
value_objects::{ExternalMetadataId, MovieTitle, ReleaseYear},
};
use crate::import::deps::{ApplyMappingDeps, CreateSessionDeps};
use crate::import::{
apply_mapping,
commands::{ApplyImportMappingCommand, CreateImportSessionCommand},
@@ -25,9 +26,13 @@ async fn applies_mapping_to_session() {
let b = TestContextBuilder::new();
let user_id = Uuid::new_v4();
let create_deps = CreateSessionDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: b.document_parser.clone(),
};
let session = create_session::execute(
Arc::clone(&sessions) as _,
b.document_parser.clone(),
&create_deps,
CreateImportSessionCommand {
user_id,
bytes: b"title\nTest".to_vec(),
@@ -37,10 +42,14 @@ async fn applies_mapping_to_session() {
.await
.unwrap();
let mapping_deps = ApplyMappingDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: b.document_parser.clone(),
movie_query: b.movie_query.clone(),
};
let rows = apply_mapping::execute(
Arc::clone(&sessions) as _,
b.document_parser.clone(),
b.movie_repo.clone(),
&mapping_deps,
ApplyImportMappingCommand {
user_id,
session_id: session.session_id.value(),
@@ -58,10 +67,14 @@ async fn fails_when_session_not_found() {
let sessions = InMemoryImportSessionRepository::new();
let b = TestContextBuilder::new();
let deps = ApplyMappingDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: b.document_parser.clone(),
movie_query: b.movie_query.clone(),
};
let result = apply_mapping::execute(
Arc::clone(&sessions) as _,
b.document_parser.clone(),
b.movie_repo.clone(),
&deps,
ApplyImportMappingCommand {
user_id: Uuid::new_v4(),
session_id: Uuid::new_v4(),
@@ -132,9 +145,13 @@ async fn marks_duplicate_by_external_id() {
let user_id = Uuid::new_v4();
let create_deps = CreateSessionDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: Arc::clone(&parser) as _,
};
let session = create_session::execute(
Arc::clone(&sessions) as _,
Arc::clone(&parser) as _,
&create_deps,
CreateImportSessionCommand {
user_id,
bytes: b"title\nKnown Movie".to_vec(),
@@ -144,10 +161,14 @@ async fn marks_duplicate_by_external_id() {
.await
.unwrap();
let mapping_deps = ApplyMappingDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: Arc::clone(&parser) as _,
movie_query: Arc::clone(&movies) as _,
};
let rows = apply_mapping::execute(
Arc::clone(&sessions) as _,
Arc::clone(&parser) as _,
Arc::clone(&movies) as _,
&mapping_deps,
ApplyImportMappingCommand {
user_id,
session_id: session.session_id.value(),
@@ -185,9 +206,13 @@ async fn marks_duplicate_by_title_and_year() {
let user_id = Uuid::new_v4();
let create_deps = CreateSessionDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: Arc::clone(&parser) as _,
};
let session = create_session::execute(
Arc::clone(&sessions) as _,
Arc::clone(&parser) as _,
&create_deps,
CreateImportSessionCommand {
user_id,
bytes: b"title\nDuplicate Film".to_vec(),
@@ -197,10 +222,14 @@ async fn marks_duplicate_by_title_and_year() {
.await
.unwrap();
let mapping_deps = ApplyMappingDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: Arc::clone(&parser) as _,
movie_query: Arc::clone(&movies) as _,
};
let rows = apply_mapping::execute(
Arc::clone(&sessions) as _,
Arc::clone(&parser) as _,
Arc::clone(&movies) as _,
&mapping_deps,
ApplyImportMappingCommand {
user_id,
session_id: session.session_id.value(),

25
crates/application/src/import/tests/apply_profile.rs
View File

@@ -7,6 +7,7 @@ use domain::testing::{InMemoryImportProfileRepository, InMemoryImportSessionRepo
use domain::value_objects::{ImportProfileId, UserId};
use uuid::Uuid;
use crate::import::deps::ApplyProfileDeps;
use crate::import::{apply_profile, commands::ApplyImportProfileCommand};
#[tokio::test]
@@ -14,9 +15,13 @@ async fn fails_when_profile_not_found() {
let profiles = InMemoryImportProfileRepository::new();
let sessions = InMemoryImportSessionRepository::new();
let deps = ApplyProfileDeps {
import_profile: Arc::clone(&profiles) as _,
import_session: Arc::clone(&sessions) as _,
};
let result = apply_profile::execute(
Arc::clone(&profiles) as _,
Arc::clone(&sessions) as _,
&deps,
ApplyImportProfileCommand {
user_id: Uuid::new_v4(),
session_id: Uuid::new_v4(),
@@ -44,9 +49,13 @@ async fn fails_when_session_not_found() {
let profile_id = profile.id.clone();
profiles.save(&profile).await.unwrap();
let deps = ApplyProfileDeps {
import_profile: Arc::clone(&profiles) as _,
import_session: Arc::clone(&sessions) as _,
};
let result = apply_profile::execute(
Arc::clone(&profiles) as _,
Arc::clone(&sessions) as _,
&deps,
ApplyImportProfileCommand {
user_id,
session_id: Uuid::new_v4(),
@@ -82,9 +91,13 @@ async fn applies_profile_mappings_to_session() {
let session_id = session.id.clone();
sessions.create(&session).await.unwrap();
let deps = ApplyProfileDeps {
import_profile: Arc::clone(&profiles) as _,
import_session: Arc::clone(&sessions) as _,
};
apply_profile::execute(
Arc::clone(&profiles) as _,
Arc::clone(&sessions) as _,
&deps,
ApplyImportProfileCommand {
user_id,
session_id: session_id.value(),

9
crates/application/src/import/tests/create_session.rs
View File

@@ -4,6 +4,7 @@ use uuid::Uuid;
use domain::testing::InMemoryImportSessionRepository;
use crate::import::deps::CreateSessionDeps;
use crate::import::{commands::CreateImportSessionCommand, create_session};
use crate::test_helpers::TestContextBuilder;
@@ -12,9 +13,13 @@ async fn creates_session_with_parsed_file() {
let sessions = InMemoryImportSessionRepository::new();
let b = TestContextBuilder::new();
let deps = CreateSessionDeps {
import_session: Arc::clone(&sessions) as _,
document_parser: b.document_parser.clone(),
};
let result = create_session::execute(
Arc::clone(&sessions) as _,
b.document_parser.clone(),
&deps,
CreateImportSessionCommand {
user_id: Uuid::new_v4(),
bytes: b"col1\nval1".to_vec(),

121
crates/application/src/import/tests/execute.rs
View File

@@ -7,6 +7,7 @@ use domain::value_objects::UserId;
use uuid::Uuid;
use crate::import::commands::ExecuteImportCommand;
use crate::import::deps::ExecuteImportDeps;
use crate::import::execute;
use crate::test_helpers::NoopReviewLogger;
@@ -50,9 +51,13 @@ async fn imports_confirmed_rows() {
let sid = session.id.clone();
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -76,9 +81,13 @@ async fn skips_unconfirmed_rows() {
let sid = session.id.clone();
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -96,9 +105,13 @@ async fn skips_unconfirmed_rows() {
async fn fails_when_session_not_found() {
let sessions = InMemoryImportSessionRepository::new();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: Uuid::new_v4(),
session_id: Uuid::new_v4(),
@@ -131,9 +144,13 @@ async fn handles_datetime_format() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -168,9 +185,13 @@ async fn fails_on_invalid_rating() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -205,9 +226,13 @@ async fn fails_on_missing_watched_at() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -242,9 +267,13 @@ async fn imports_row_with_external_metadata_id() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -279,9 +308,13 @@ async fn imports_row_with_director_and_comment() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -316,9 +349,13 @@ async fn handles_space_separated_datetime_format() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -348,9 +385,13 @@ async fn reports_invalid_row_result_errors() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -387,9 +428,13 @@ async fn fails_on_missing_rating() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -425,9 +470,13 @@ async fn fails_on_unparseable_date() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -463,9 +512,13 @@ async fn imports_row_without_release_year() {
}]);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -489,9 +542,13 @@ async fn deletes_session_after_import() {
sessions.create(&session).await.unwrap();
assert_eq!(sessions.count(), 1);
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),
@@ -533,10 +590,14 @@ async fn imports_more_rows_than_concurrency_limit() {
session.row_results = Some(rows);
sessions.create(&session).await.unwrap();
let deps = ExecuteImportDeps {
import_session: Arc::clone(&sessions) as _,
review_logger: Arc::new(NoopReviewLogger),
};
let confirmed_indices: Vec<usize> = (0..15).collect();
let result = execute::execute(
Arc::clone(&sessions) as _,
Arc::new(NoopReviewLogger),
&deps,
ExecuteImportCommand {
user_id: uid,
session_id: sid.value(),

17
crates/application/src/import/tests/save_profile.rs
View File

@@ -6,6 +6,7 @@ use domain::testing::{InMemoryImportProfileRepository, InMemoryImportSessionRepo
use domain::value_objects::UserId;
use uuid::Uuid;
use crate::import::deps::SaveProfileDeps;
use crate::import::{commands::SaveImportProfileCommand, save_profile};
#[tokio::test]
@@ -13,9 +14,13 @@ async fn fails_when_session_not_found() {
let sessions = InMemoryImportSessionRepository::new();
let profiles = InMemoryImportProfileRepository::new();
let deps = SaveProfileDeps {
import_session: Arc::clone(&sessions) as _,
import_profile: Arc::clone(&profiles) as _,
};
let result = save_profile::execute(
Arc::clone(&sessions) as _,
Arc::clone(&profiles) as _,
&deps,
SaveImportProfileCommand {
user_id: Uuid::new_v4(),
session_id: Uuid::new_v4(),
@@ -38,9 +43,13 @@ async fn saves_profile_from_session() {
session.field_mappings = Some(vec![]);
sessions.create(&session).await.unwrap();
let deps = SaveProfileDeps {
import_session: Arc::clone(&sessions) as _,
import_profile: Arc::clone(&profiles) as _,
};
let result = save_profile::execute(
Arc::clone(&sessions) as _,
Arc::clone(&profiles) as _,
&deps,
SaveImportProfileCommand {
user_id,
session_id: sid.value(),