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

spa hardening, offline logging, rate limit fixes

Browse Source 
server:
- backup exporter, auth extractors, error shapes, CONTEXT (prior work)
- spa assets served outside the rate limit via route_layer
- requests_per_second went to per_second(), which takes an interval not a
  rate: 50 meant one request per 50s once burst was spent. now converted
  properly. 15/s, burst 60

spa fixes:
- account delete cleared snake_case token keys that were never written
- refresh interceptor could retry forever
- date ranges used local day boundaries stamped +00:00
- "all" period trend plotted one page; calendar days fabricated mood 3
- chart grid invisible: hsl(var(--border)) against rgba tokens
- blob url leak, orphaned media on failed save, devtools in prod bundle
- pt-safe/safe-area-pb classes never existed

spa features:
- offline outbox: entries queue to IndexedDB, replay with backoff, only
  server refusals count against an entry
- drafts persist, quick-log sheet, diary infinite scroll + filters
- route error boundary, stale-chunk recovery, no service worker in dev

a11y + perf:
- mood picker is a radiogroup, activity picker keyboard-operable,
  text alternatives for colour/emoji, locale week start
- dark glass over the bright photo: worst case 1.4:1 -> 4.9-9.6:1
- initial payload 1095->769kB raw, 306->230kB gzip; 38 unused components
  and 5 deps dropped; fonts 218->133kB

53 tests added (43 spa, 10 server)
This commit is contained in:
Gabriel Kaszewski
2026-08-28 14:59:21 +02:00
parent 23d052278a
commit bf148902ab
395 changed files with 13972 additions and 10635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
crates/application/tests/entry/create_entry_test.rs
View File

@@ -16,6 +16,7 @@ fn deps() -> (Arc<InMemoryStore>, create_entry::Deps) {
Arc::new(InMemoryDimensionStore::new(DimensionKind::Activities));
let deps = create_entry::Deps {
activities: store.clone(),
entries: store.clone(),
dimensions: vec![content, activities],
events: store.clone(),
@@ -47,6 +48,9 @@ async fn creates_entry_with_optional_dimensions() {
let (store, deps) = deps();
let user = test_user("bob");
let activity = domain::testing::test_activity(user.id().clone(), "gaming");
domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
.await
.unwrap();
let cmd = CreateEntryCommand {
user_id: user.id().clone(),
@@ -63,3 +67,190 @@ async fn creates_entry_with_optional_dimensions() {
assert_eq!(entry.mood(), Mood::Rad);
assert_eq!(store.entry_count(), 1);
}
#[tokio::test]
async fn an_entry_cannot_wear_another_accounts_activity() {
let (store, deps) = deps();
let user = test_user("alice");
let stranger = test_user("mallory");
let theirs = domain::testing::test_activity(stranger.id().clone(), "fencing");
domain::ports::ActivityCommandPort::save(store.as_ref(), &theirs)
.await
.unwrap();
let cmd = CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Good,
logged_at: test_logged_at(),
dimensions: vec![DimensionValue::activities(vec![theirs.id().clone()])],
};
let refused = create_entry::execute(cmd, &deps).await;
assert!(
matches!(
refused,
Err(application::errors::ApplicationError::Domain(
domain::errors::DomainError::Forbidden(_)
))
),
"tagging a stranger's activity must be refused, got {refused:?}"
);
assert_eq!(store.entry_count(), 0, "nothing should have been written");
}
#[tokio::test]
async fn an_entry_cannot_wear_an_activity_that_does_not_exist() {
let (store, deps) = deps();
let user = test_user("alice");
let cmd = CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Good,
logged_at: test_logged_at(),
dimensions: vec![DimensionValue::activities(vec![
domain::activity::ActivityId::generate(),
])],
};
assert!(create_entry::execute(cmd, &deps).await.is_err());
assert_eq!(store.entry_count(), 0);
}
#[tokio::test]
async fn an_archived_activity_cannot_be_tagged_onto_a_new_entry() {
let (store, deps) = deps();
let user = test_user("alice");
let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
retired.archive().unwrap();
domain::ports::ActivityCommandPort::save(store.as_ref(), &retired)
.await
.unwrap();
let cmd = CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Good,
logged_at: test_logged_at(),
dimensions: vec![DimensionValue::activities(vec![retired.id().clone()])],
};
let refused = create_entry::execute(cmd, &deps).await;
assert!(
matches!(
refused,
Err(application::errors::ApplicationError::Validation(_))
),
"an archived activity is retired, not forbidden, got {refused:?}"
);
assert_eq!(store.entry_count(), 0);
}
#[tokio::test]
async fn unarchiving_makes_an_activity_taggable_again() {
let (store, deps) = deps();
let user = test_user("alice");
let mut activity = domain::testing::test_activity(user.id().clone(), "fencing");
activity.archive().unwrap();
activity.unarchive().unwrap();
domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
.await
.unwrap();
let cmd = CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Good,
logged_at: test_logged_at(),
dimensions: vec![DimensionValue::activities(vec![activity.id().clone()])],
};
create_entry::execute(cmd, &deps).await.unwrap();
assert_eq!(store.entry_count(), 1);
}
#[tokio::test]
async fn many_entries_land_in_one_request() {
let store = Arc::new(InMemoryStore::new());
let content: Arc<dyn EntryDimensionPort> =
Arc::new(InMemoryDimensionStore::new(DimensionKind::Content));
let user = test_user("alice");
let deps = application::entry::use_cases::create_entries::Deps {
entries: store.clone(),
dimensions: vec![content],
activities: store.clone(),
events: store.clone(),
};
let wanted: Vec<CreateEntryCommand> = [Mood::Good, Mood::Bad, Mood::Rad]
.into_iter()
.map(|mood| CreateEntryCommand {
user_id: user.id().clone(),
mood,
logged_at: test_logged_at(),
dimensions: vec![],
})
.collect();
let created =
application::entry::use_cases::create_entries::execute(user.id().clone(), wanted, &deps)
.await
.unwrap();
assert_eq!(created.len(), 3);
assert_eq!(store.entry_count(), 3);
assert_eq!(
store.published_events().len(),
3,
"each entry is its own event"
);
}
#[tokio::test]
async fn one_bad_activity_refuses_the_whole_batch() {
let store = Arc::new(InMemoryStore::new());
let user = test_user("alice");
let stranger = test_user("mallory");
let theirs = domain::testing::test_activity(stranger.id().clone(), "fencing");
domain::ports::ActivityCommandPort::save(store.as_ref(), &theirs)
.await
.unwrap();
let deps = application::entry::use_cases::create_entries::Deps {
entries: store.clone(),
dimensions: vec![],
activities: store.clone(),
events: store.clone(),
};
let wanted = vec![
CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Good,
logged_at: test_logged_at(),
dimensions: vec![],
},
CreateEntryCommand {
user_id: user.id().clone(),
mood: Mood::Bad,
logged_at: test_logged_at(),
dimensions: vec![DimensionValue::activities(vec![theirs.id().clone()])],
},
];
let refused =
application::entry::use_cases::create_entries::execute(user.id().clone(), wanted, &deps)
.await;
assert!(refused.is_err());
assert_eq!(
store.entry_count(),
0,
"the first entry must not survive a batch that was refused"
);
}

8
crates/application/tests/entry/dimension_test.rs
View File

@@ -1,6 +1,5 @@
use std::sync::Arc;
use domain::activity::ActivityId;
use domain::attachment::{PhotoId, VoiceMemoId};
use domain::dimension::{DimensionKind, DimensionValue};
use domain::entry::{Mood, MoodEntry};
@@ -105,11 +104,16 @@ async fn an_entry_composes_every_kind_of_dimension_it_has() {
let store = Arc::new(domain::testing::InMemoryStore::new());
let user = test_user("erin");
let activity_id = ActivityId::generate();
let activity = domain::testing::test_activity(user.id().clone(), "reading");
domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
.await
.unwrap();
let activity_id = activity.id().clone();
let photo_id = PhotoId::generate();
let voice_memo_id = VoiceMemoId::generate();
let deps = create_entry::Deps {
activities: store.clone(),
entries: store.clone(),
dimensions: dimensions.ports(),
events: store.clone(),

67
crates/application/tests/entry/filter_test.rs
View File

@@ -1,67 +0,0 @@
use std::sync::Arc;
use domain::entry::Mood;
use domain::ports::MoodEntryCommandPort;
use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
use application::entry::queries::{FilterByActivityQuery, FilterByMoodQuery};
use application::entry::use_cases::{filter_by_activity, filter_by_mood};
#[tokio::test]
async fn filters_by_mood() {
let store = Arc::new(InMemoryStore::new());
let user = test_user("alice");
store
.save(&test_entry(user.id().clone(), Mood::Good))
.await
.unwrap();
store
.save(&test_entry(user.id().clone(), Mood::Good))
.await
.unwrap();
store
.save(&test_entry(user.id().clone(), Mood::Bad))
.await
.unwrap();
let deps = filter_by_mood::Deps {
query: store.clone(),
};
let query = FilterByMoodQuery {
user_id: user.id().clone(),
mood: Mood::Good,
};
let entries = filter_by_mood::execute(query, &deps).await.unwrap();
assert_eq!(entries.len(), 2);
}
#[tokio::test]
async fn filters_by_activity() {
let store = Arc::new(InMemoryStore::new());
let user = test_user("alice");
let activity = test_activity(user.id().clone(), "exercise");
let tagged = test_entry(user.id().clone(), Mood::Good);
store.save(&tagged).await.unwrap();
store.assign_activities(tagged.id(), vec![activity.id().clone()]);
store
.save(&test_entry(user.id().clone(), Mood::Meh))
.await
.unwrap();
let deps = filter_by_activity::Deps {
query: store.clone(),
};
let query = FilterByActivityQuery {
user_id: user.id().clone(),
activity_id: activity.id().clone(),
};
let entries = filter_by_activity::execute(query, &deps).await.unwrap();
assert_eq!(entries.len(), 1);
}

167
crates/application/tests/entry/list_entries_test.rs
View File

@@ -1,60 +1,165 @@
use std::sync::Arc;
use domain::entry::Mood;
use domain::entry::{EntrySelection, Mood, Pagination};
use domain::ports::MoodEntryCommandPort;
use domain::testing::{InMemoryStore, test_entry, test_user};
use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
use domain::user::User;
use application::entry::queries::ListEntriesQuery;
use application::entry::use_cases::list_entries;
const A_GENEROUS_PAGE: i64 = 500;
fn everything_of(user: &User) -> ListEntriesQuery {
ListEntriesQuery {
selection: EntrySelection::everything_of(user.id().clone()),
page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
}
}
async fn logged(store: &Arc<InMemoryStore>, user: &User, mood: Mood) -> domain::entry::MoodEntry {
let entry = test_entry(user.id().clone(), mood);
store.save(&entry).await.unwrap();
entry
}
#[tokio::test]
async fn lists_entries_for_user() {
async fn lists_only_the_asking_account() {
let store = Arc::new(InMemoryStore::new());
let alice = test_user("alice");
let bob = test_user("bob");
store
.save(&test_entry(alice.id().clone(), Mood::Good))
.await
.unwrap();
store
.save(&test_entry(alice.id().clone(), Mood::Rad))
.await
.unwrap();
store
.save(&test_entry(bob.id().clone(), Mood::Meh))
.await
.unwrap();
logged(&store, &alice, Mood::Good).await;
logged(&store, &alice, Mood::Rad).await;
logged(&store, &bob, Mood::Meh).await;
let deps = list_entries::Deps {
query: store.clone(),
};
let page = list_entries::execute(everything_of(&alice), &deps)
.await
.unwrap();
let query = ListEntriesQuery {
limit: None,
offset: None,
user_id: alice.id().clone(),
range: None,
};
let entries = list_entries::execute(query, &deps).await.unwrap();
assert_eq!(entries.len(), 2);
assert_eq!(page.items().len(), 2);
assert_eq!(page.total(), 2);
}
#[tokio::test]
async fn returns_empty_for_user_with_no_entries() {
async fn an_account_with_nothing_logged_gets_an_empty_page() {
let store = Arc::new(InMemoryStore::new());
let deps = list_entries::Deps {
query: store.clone(),
};
let page = list_entries::execute(everything_of(&test_user("nobody")), &deps)
.await
.unwrap();
assert!(page.items().is_empty());
assert_eq!(page.total(), 0);
assert!(!page.more_after_this());
}
#[tokio::test]
async fn the_total_counts_the_selection_not_the_page() {
let store = Arc::new(InMemoryStore::new());
let alice = test_user("alice");
for _ in 0..7 {
logged(&store, &alice, Mood::Good).await;
}
let deps = list_entries::Deps {
query: store.clone(),
};
let query = ListEntriesQuery {
limit: None,
offset: None,
user_id: test_user("nobody").id().clone(),
range: None,
selection: EntrySelection::everything_of(alice.id().clone()),
page: Pagination::new(3, 0, A_GENEROUS_PAGE).unwrap(),
};
let entries = list_entries::execute(query, &deps).await.unwrap();
assert!(entries.is_empty());
let page = list_entries::execute(query, &deps).await.unwrap();
assert_eq!(page.items().len(), 3, "the page holds what was asked for");
assert_eq!(page.total(), 7, "the total is what a client pages through");
assert!(page.more_after_this());
}
#[tokio::test]
async fn the_last_page_says_there_is_nothing_after_it() {
let store = Arc::new(InMemoryStore::new());
let alice = test_user("alice");
for _ in 0..5 {
logged(&store, &alice, Mood::Good).await;
}
let deps = list_entries::Deps {
query: store.clone(),
};
let query = ListEntriesQuery {
selection: EntrySelection::everything_of(alice.id().clone()),
page: Pagination::new(3, 3, A_GENEROUS_PAGE).unwrap(),
};
let page = list_entries::execute(query, &deps).await.unwrap();
assert_eq!(page.items().len(), 2);
assert_eq!(page.total(), 5);
assert!(!page.more_after_this());
}
#[tokio::test]
async fn a_selection_can_narrow_to_one_mood() {
let store = Arc::new(InMemoryStore::new());
let alice = test_user("alice");
logged(&store, &alice, Mood::Good).await;
logged(&store, &alice, Mood::Good).await;
logged(&store, &alice, Mood::Bad).await;
let deps = list_entries::Deps {
query: store.clone(),
};
let query = ListEntriesQuery {
selection: EntrySelection::everything_of(alice.id().clone()).of_mood(Some(Mood::Good)),
page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
};
let page = list_entries::execute(query, &deps).await.unwrap();
assert_eq!(page.items().len(), 2);
assert_eq!(page.total(), 2);
}
#[tokio::test]
async fn a_selection_can_narrow_to_one_activity() {
let store = Arc::new(InMemoryStore::new());
let alice = test_user("alice");
let exercise = test_activity(alice.id().clone(), "exercise");
let tagged = logged(&store, &alice, Mood::Good).await;
store.assign_activities(tagged.id(), vec![exercise.id().clone()]);
logged(&store, &alice, Mood::Meh).await;
let deps = list_entries::Deps {
query: store.clone(),
};
let query = ListEntriesQuery {
selection: EntrySelection::everything_of(alice.id().clone())
.tagged_with(Some(exercise.id().clone())),
page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
};
let page = list_entries::execute(query, &deps).await.unwrap();
assert_eq!(page.items().len(), 1);
assert_eq!(page.items()[0].id(), tagged.id());
}
#[tokio::test]
async fn a_page_bigger_than_the_server_serves_is_refused() {
assert!(Pagination::new(1_000, 0, 200).is_err());
assert!(Pagination::new(0, 0, 200).is_err());
assert!(Pagination::new(10, -1, 200).is_err());
}

69
crates/application/tests/entry/mood_stats_test.rs
View File

@@ -80,3 +80,72 @@ fn user_in(name: &str, timezone: &str) -> domain::user::User {
user.update_timezone(Some(Timezone::new(timezone).unwrap()));
user
}
fn a_user_in_warsaw() -> domain::user::User {
user_in("alice", "Europe/Warsaw")
}
async fn stats_of(
store: &Arc<InMemoryStore>,
user: &domain::user::User,
range: Option<domain::entry::DateRange>,
) -> get_mood_stats::MoodStats {
let deps = get_mood_stats::Deps {
query: store.clone(),
users: store.clone(),
};
get_mood_stats::execute(
MoodStatsQuery {
user_id: user.id().clone(),
range,
},
&deps,
)
.await
.unwrap()
}
#[tokio::test]
async fn the_bounds_are_the_days_the_journal_actually_spans() {
let store = Arc::new(InMemoryStore::new());
let user = a_user_in_warsaw();
UserCommandPort::save(store.as_ref(), &user).await.unwrap();
for days_ago in [0, 5, 40] {
let entry = domain::testing::test_entry_days_ago(user.id().clone(), Mood::Good, days_ago);
MoodEntryCommandPort::save(store.as_ref(), &entry)
.await
.unwrap();
}
let stats = stats_of(&store, &user, None).await;
let today = domain::entry::Date::from_instant(
&chrono::Utc::now().fixed_offset(),
&domain::user::Timezone::new("Europe/Warsaw").unwrap(),
);
assert_eq!(
stats.last_logged_on,
Some(today),
"the newest entry was logged today"
);
assert!(
stats.first_logged_on.unwrap() < today,
"the oldest was forty days back"
);
}
#[tokio::test]
async fn an_empty_journal_has_no_bounds() {
let store = Arc::new(InMemoryStore::new());
let user = a_user_in_warsaw();
UserCommandPort::save(store.as_ref(), &user).await.unwrap();
let stats = stats_of(&store, &user, None).await;
assert_eq!(stats.total_entries, 0);
assert_eq!(stats.first_logged_on, None);
assert_eq!(stats.last_logged_on, None);
}

20
crates/application/tests/entry/replace_activity_test.rs
View File

@@ -2,7 +2,7 @@ use std::sync::Arc;
use domain::activity::ActivityId;
use domain::entry::Mood;
use domain::ports::{ActivityCommandPort, MoodEntryCommandPort, MoodEntryQueryPort};
use domain::ports::{ActivityCommandPort, MoodEntryCommandPort};
use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
use application::entry::use_cases::replace_activity;
@@ -29,8 +29,8 @@ async fn replaces_activity_on_entries() {
.await
.unwrap();
let now_tagged_new = store.find_by_activity(user.id(), new.id()).await.unwrap();
let still_tagged_old = store.find_by_activity(user.id(), old.id()).await.unwrap();
let now_tagged_new = tagged_with(&store, &user, new.id()).await;
let still_tagged_old = tagged_with(&store, &user, old.id()).await;
assert_eq!(now_tagged_new.len(), 1);
assert!(still_tagged_old.is_empty());
@@ -80,3 +80,17 @@ async fn rejects_target_owned_by_different_user() {
.await;
assert!(result.is_err());
}
async fn tagged_with(
store: &Arc<InMemoryStore>,
user: &domain::user::User,
activity_id: &domain::activity::ActivityId,
) -> Vec<domain::entry::MoodEntry> {
let selection = domain::entry::EntrySelection::everything_of(user.id().clone())
.tagged_with(Some(activity_id.clone()));
let page = domain::entry::Pagination::new(500, 0, 500).unwrap();
domain::ports::MoodEntryQueryPort::select(store.as_ref(), &selection, page)
.await
.unwrap()
}

144
crates/application/tests/entry/update_entry_test.rs
View File

@@ -7,7 +7,8 @@ use domain::entry::Mood;
use domain::ports::EntryDimensionPort;
use domain::ports::MoodEntryCommandPort;
use domain::testing::{
InMemoryDimensionStore, InMemoryStore, test_entry, test_logged_at, test_user,
InMemoryActivityDimension, InMemoryDimensionStore, InMemoryStore, test_entry, test_logged_at,
test_user,
};
use domain::user::UserId;
@@ -26,6 +27,7 @@ async fn setup() -> (
store.save(&entry).await.unwrap();
let deps = update_entry::Deps {
activities: store.clone(),
command: store.clone(),
dimensions: vec![
Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
@@ -45,9 +47,9 @@ async fn updates_mood() {
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Mood::Rad,
mood: Some(Mood::Rad),
logged_at: Some(test_logged_at()),
dimensions: vec![],
dimensions: Some(vec![]),
};
let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
@@ -60,6 +62,7 @@ async fn updates_mood() {
async fn updating_nonexistent_entry_fails() {
let store = Arc::new(InMemoryStore::new());
let deps = update_entry::Deps {
activities: store.clone(),
command: store.clone(),
dimensions: vec![
Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
@@ -72,9 +75,9 @@ async fn updating_nonexistent_entry_fails() {
let cmd = UpdateEntryCommand {
entry_id: domain::entry::MoodEntryId::generate(),
mood: Mood::Good,
mood: Some(Mood::Good),
logged_at: Some(test_logged_at()),
dimensions: vec![],
dimensions: Some(vec![]),
};
let result = update_entry::execute(cmd, UserId::generate(), &deps).await;
@@ -87,9 +90,9 @@ async fn rejects_update_by_different_user() {
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Mood::Rad,
mood: Some(Mood::Rad),
logged_at: Some(test_logged_at()),
dimensions: vec![],
dimensions: Some(vec![]),
};
let other_user = UserId::generate();
@@ -103,9 +106,9 @@ async fn an_update_carrying_no_date_leaves_the_entry_where_it_was() {
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Mood::Rad,
mood: Some(Mood::Rad),
logged_at: None,
dimensions: vec![],
dimensions: Some(vec![]),
};
let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
@@ -124,12 +127,131 @@ async fn an_update_carrying_a_date_moves_the_entry_to_it() {
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Mood::Rad,
mood: Some(Mood::Rad),
logged_at: Some(moved_to),
dimensions: vec![],
dimensions: Some(vec![]),
};
let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
assert_eq!(updated.logged_at(), &moved_to);
}
async fn an_entry_already_wearing(
user: &domain::user::User,
activity: &domain::activity::Activity,
) -> (
Arc<InMemoryStore>,
update_entry::Deps,
domain::entry::MoodEntry,
) {
let store = Arc::new(InMemoryStore::new());
let entry = test_entry(user.id().clone(), Mood::Meh);
MoodEntryCommandPort::save(store.as_ref(), &entry)
.await
.unwrap();
domain::ports::ActivityCommandPort::save(store.as_ref(), activity)
.await
.unwrap();
let tags: Arc<InMemoryActivityDimension> =
Arc::new(InMemoryActivityDimension::sharing(store.clone()));
tags.save(
entry.id(),
&[domain::dimension::DimensionValue::activities(vec![
activity.id().clone(),
])],
)
.await
.unwrap();
let deps = update_entry::Deps {
activities: store.clone(),
command: store.clone(),
dimensions: vec![tags as Arc<dyn EntryDimensionPort>],
query: store.clone(),
media_storage: store.clone(),
events: store.clone(),
};
(store, deps, entry)
}
#[tokio::test]
async fn an_entry_that_already_wears_an_archived_activity_can_still_be_edited() {
let user = test_user("alice");
let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
retired.archive().unwrap();
let (_store, deps, entry) = an_entry_already_wearing(&user, &retired).await;
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Some(Mood::Rad),
logged_at: None,
dimensions: Some(vec![domain::dimension::DimensionValue::activities(vec![
retired.id().clone(),
])]),
};
let updated = update_entry::execute(cmd, entry.user_id().clone(), &deps)
.await
.expect("archived activities remain on the entries that already wear them");
assert_eq!(updated.mood(), Mood::Rad);
}
#[tokio::test]
async fn an_archived_activity_cannot_be_added_to_an_entry_that_lacks_it() {
let user = test_user("alice");
let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
retired.archive().unwrap();
let worn = domain::testing::test_activity(user.id().clone(), "reading");
let (store, deps, entry) = an_entry_already_wearing(&user, &worn).await;
domain::ports::ActivityCommandPort::save(store.as_ref(), &retired)
.await
.unwrap();
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Some(Mood::Rad),
logged_at: None,
dimensions: Some(vec![domain::dimension::DimensionValue::activities(vec![
worn.id().clone(),
retired.id().clone(),
])]),
};
let refused = update_entry::execute(cmd, entry.user_id().clone(), &deps).await;
assert!(
matches!(
refused,
Err(application::errors::ApplicationError::Validation(_))
),
"editing an entry is not a way past the archive, got {refused:?}"
);
}
#[tokio::test]
async fn an_archived_activity_can_be_taken_off_an_entry() {
let user = test_user("alice");
let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
retired.archive().unwrap();
let (_store, deps, entry) = an_entry_already_wearing(&user, &retired).await;
let cmd = UpdateEntryCommand {
entry_id: entry.id().clone(),
mood: Some(Mood::Rad),
logged_at: None,
dimensions: Some(vec![]),
};
update_entry::execute(cmd, entry.user_id().clone(), &deps)
.await
.expect("dropping a retired tag is always allowed");
}