Include historical events in the boot response.

The returned events are all events up to and including the `resume_point` in the same response. If combined with the events from `/api/events?resume_point=x`, using the same `resume_point`, the client will have a complete event history, less any events from histories that have been purged.

1 files changed, 124 insertions, 1 deletions

diff --git a/src/boot/handlers/boot/test.rs b/src/boot/handlers/boot/test.rs
index 0a7622b..d68618e 100644
--- a/src/boot/handlers/boot/test.rs
+++ b/src/boot/handlers/boot/test.rs
@@ -1,4 +1,5 @@
 use axum::extract::State;
+use itertools::Itertools as _;
 
 use crate::test::fixtures;
 
@@ -15,7 +16,7 @@ async fn returns_identity() {
 }
 
 #[tokio::test]
-async fn includes_logins() {
+async fn includes_users() {
     let app = fixtures::scratch_app().await;
     let spectator = fixtures::user::create(&app, &fixtures::now()).await;
 
@@ -25,6 +26,16 @@ async fn includes_logins() {
         .expect("boot always succeeds");
 
     assert!(response.snapshot.users.contains(&spectator));
+
+    let created = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::user)
+        .filter_map(fixtures::event::user::created)
+        .exactly_one()
+        .expect("only one user has been created");
+    assert_eq!(spectator, created.user)
 }
 
 #[tokio::test]
@@ -38,6 +49,16 @@ async fn includes_channels() {
         .expect("boot always succeeds");
 
     assert!(response.snapshot.channels.contains(&channel));
+
+    let created = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::channel)
+        .filter_map(fixtures::event::channel::created)
+        .exactly_one()
+        .expect("only one channel has been created");
+    assert_eq!(channel, created.channel);
 }
 
 #[tokio::test]
@@ -53,6 +74,16 @@ async fn includes_messages() {
         .expect("boot always succeeds");
 
     assert!(response.snapshot.messages.contains(&message));
+
+    let sent = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::message)
+        .filter_map(fixtures::event::message::sent)
+        .exactly_one()
+        .expect("only one message has been sent");
+    assert_eq!(message, sent.message);
 }
 
 #[tokio::test]
@@ -74,6 +105,29 @@ async fn excludes_expired_messages() {
         .expect("boot always succeeds");
 
     assert!(!response.snapshot.messages.contains(&expired_message));
+
+    let sent = response
+        .snapshot
+        .events
+        .iter()
+        .cloned()
+        .filter_map(fixtures::event::message)
+        .filter_map(fixtures::event::message::sent)
+        .exactly_one()
+        .expect("only one message has been sent");
+    // We don't expect `expired_message` to match the event exactly, as the body will have been
+    // tombstoned and the message given a `deleted_at` date.
+    assert_eq!(expired_message.id, sent.message.id);
+
+    let deleted = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::message)
+        .filter_map(fixtures::event::message::deleted)
+        .exactly_one()
+        .expect("only one message has expired");
+    assert_eq!(expired_message.id, deleted.id);
 }
 
 #[tokio::test]
@@ -94,6 +148,29 @@ async fn excludes_deleted_messages() {
         .expect("boot always succeeds");
 
     assert!(!response.snapshot.messages.contains(&deleted_message));
+
+    let sent = response
+        .snapshot
+        .events
+        .iter()
+        .cloned()
+        .filter_map(fixtures::event::message)
+        .filter_map(fixtures::event::message::sent)
+        .exactly_one()
+        .expect("only one message has been sent");
+    // We don't expect `deleted_message` to match the event exactly, as the body will have been
+    // tombstoned and the message given a `deleted_at` date.
+    assert_eq!(deleted_message.id, sent.message.id);
+
+    let deleted = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::message)
+        .filter_map(fixtures::event::message::deleted)
+        .exactly_one()
+        .expect("only one message has been deleted");
+    assert_eq!(deleted_message.id, deleted.id);
 }
 
 #[tokio::test]
@@ -112,6 +189,29 @@ async fn excludes_expired_channels() {
         .expect("boot always succeeds");
 
     assert!(!response.snapshot.channels.contains(&expired_channel));
+
+    let created = response
+        .snapshot
+        .events
+        .iter()
+        .cloned()
+        .filter_map(fixtures::event::channel)
+        .filter_map(fixtures::event::channel::created)
+        .exactly_one()
+        .expect("only one channel has been created");
+    // We don't expect `expired_channel` to match the event exactly, as the name will have been
+    // tombstoned and the channel given a `deleted_at` date.
+    assert_eq!(expired_channel.id, created.channel.id);
+
+    let deleted = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::channel)
+        .filter_map(fixtures::event::channel::deleted)
+        .exactly_one()
+        .expect("only one channel has expired");
+    assert_eq!(expired_channel.id, deleted.id);
 }
 
 #[tokio::test]
@@ -130,4 +230,27 @@ async fn excludes_deleted_channels() {
         .expect("boot always succeeds");
 
     assert!(!response.snapshot.channels.contains(&deleted_channel));
+
+    let created = response
+        .snapshot
+        .events
+        .iter()
+        .cloned()
+        .filter_map(fixtures::event::channel)
+        .filter_map(fixtures::event::channel::created)
+        .exactly_one()
+        .expect("only one channel has been created");
+    // We don't expect `deleted_channel` to match the event exactly, as the name will have been
+    // tombstoned and the channel given a `deleted_at` date.
+    assert_eq!(deleted_channel.id, created.channel.id);
+
+    let deleted = response
+        .snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::channel)
+        .filter_map(fixtures::event::channel::deleted)
+        .exactly_one()
+        .expect("only one channel has been deleted");
+    assert_eq!(deleted_channel.id, deleted.id);
 }