Rename "channel" to "conversation" within the server.

I've split this from the schema and API changes because, frankly, it's huge. Annoyingly so. There are no semantic changes in this, it's all symbol changes, but there are a _lot_ of them because the term "channel" leaks all over everything in a service whose primary role is managing messages sent to channels (now, conversations).

I found a buggy test while working on this! It's not fixed in this commit, because it felt mean to hide a real change in the middle of this much chaff.

1 files changed, 250 insertions, 0 deletions

diff --git a/src/conversation/handlers/create/test.rs b/src/conversation/handlers/create/test.rs
new file mode 100644
index 0000000..bc05b00
--- /dev/null
+++ b/src/conversation/handlers/create/test.rs
@@ -0,0 +1,250 @@
+use std::future;
+
+use axum::extract::{Json, State};
+use futures::stream::StreamExt as _;
+use itertools::Itertools;
+
+use crate::{
+    conversation::app,
+    name::Name,
+    test::fixtures::{self, future::Expect as _},
+};
+
+#[tokio::test]
+async fn new_conversation() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::now()).await;
+    let resume_point = fixtures::boot::resume_point(&app).await;
+
+    // Call the endpoint
+
+    let name = fixtures::conversation::propose();
+    let request = super::Request { name: name.clone() };
+    let super::Response(response) =
+        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
+            .await
+            .expect("creating a conversation in an empty app succeeds");
+
+    // Verify the structure of the response
+
+    assert_eq!(name, response.name);
+
+    // Verify the semantics
+
+    let snapshot = app.boot().snapshot().await.expect("boot always succeeds");
+    let created = snapshot
+        .events
+        .into_iter()
+        .filter_map(fixtures::event::conversation)
+        .filter_map(fixtures::event::conversation::created)
+        .exactly_one()
+        .expect("only one conversation has been created");
+    assert_eq!(response, created.conversation);
+
+    let conversation = app
+        .conversations()
+        .get(&response.id)
+        .await
+        .expect("the newly-created conversation exists");
+    assert_eq!(response, conversation);
+
+    let mut events = app
+        .events()
+        .subscribe(resume_point)
+        .await
+        .expect("subscribing never fails")
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::created)
+        .filter(|event| future::ready(event.conversation == response));
+
+    let event = events.next().expect_some("creation event published").await;
+
+    assert_eq!(event.conversation, response);
+}
+
+#[tokio::test]
+async fn duplicate_name() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
+
+    // Call the endpoint
+
+    let request = super::Request {
+        name: conversation.name.clone(),
+    };
+    let super::Error(error) =
+        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
+            .await
+            .expect_err("duplicate conversation name should fail the request");
+
+    // Verify the structure of the response
+
+    assert!(matches!(
+        error,
+        app::CreateError::DuplicateName(name) if conversation.name == name
+    ));
+}
+
+#[tokio::test]
+async fn conflicting_canonical_name() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::now()).await;
+
+    let existing_name = Name::from("rijksmuseum");
+    app.conversations()
+        .create(&existing_name, &fixtures::now())
+        .await
+        .expect("creating a conversation in an empty environment succeeds");
+
+    let conflicting_name = Name::from("r\u{0133}ksmuseum");
+
+    // Call the endpoint
+
+    let request = super::Request {
+        name: conflicting_name.clone(),
+    };
+    let super::Error(error) =
+        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
+            .await
+            .expect_err("duplicate conversation name should fail the request");
+
+    // Verify the structure of the response
+
+    assert!(matches!(
+        error,
+        app::CreateError::DuplicateName(name) if conflicting_name == name
+    ));
+}
+
+#[tokio::test]
+async fn invalid_name() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::now()).await;
+
+    // Call the endpoint
+
+    let name = fixtures::conversation::propose_invalid_name();
+    let request = super::Request { name: name.clone() };
+    let super::Error(error) = crate::conversation::handlers::create::handler(
+        State(app.clone()),
+        creator,
+        fixtures::now(),
+        Json(request),
+    )
+    .await
+    .expect_err("invalid conversation name should fail the request");
+
+    // Verify the structure of the response
+
+    assert!(matches!(
+        error,
+        app::CreateError::InvalidName(error_name) if name == error_name
+    ));
+}
+
+#[tokio::test]
+async fn name_reusable_after_delete() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::now()).await;
+    let name = fixtures::conversation::propose();
+
+    // Call the endpoint (first time)
+
+    let request = super::Request { name: name.clone() };
+    let super::Response(response) = super::handler(
+        State(app.clone()),
+        creator.clone(),
+        fixtures::now(),
+        Json(request),
+    )
+    .await
+    .expect("new conversation in an empty app");
+
+    // Delete the conversation
+
+    app.conversations()
+        .delete(&response.id, &fixtures::now())
+        .await
+        .expect("deleting a newly-created conversation succeeds");
+
+    // Call the endpoint (second time)
+
+    let request = super::Request { name: name.clone() };
+    let super::Response(response) =
+        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
+            .await
+            .expect("creation succeeds after original conversation deleted");
+
+    // Verify the structure of the response
+
+    assert_eq!(name, response.name);
+
+    // Verify the semantics
+
+    let conversation = app
+        .conversations()
+        .get(&response.id)
+        .await
+        .expect("the newly-created conversation exists");
+    assert_eq!(response, conversation);
+}
+
+#[tokio::test]
+async fn name_reusable_after_expiry() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let creator = fixtures::identity::create(&app, &fixtures::ancient()).await;
+    let name = fixtures::conversation::propose();
+
+    // Call the endpoint (first time)
+
+    let request = super::Request { name: name.clone() };
+    let super::Response(_) = super::handler(
+        State(app.clone()),
+        creator.clone(),
+        fixtures::ancient(),
+        Json(request),
+    )
+    .await
+    .expect("new conversation in an empty app");
+
+    // Expire the conversation
+
+    app.conversations()
+        .expire(&fixtures::now())
+        .await
+        .expect("expiry always succeeds");
+
+    // Call the endpoint (second time)
+
+    let request = super::Request { name: name.clone() };
+    let super::Response(response) =
+        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
+            .await
+            .expect("creation succeeds after original conversation expired");
+
+    // Verify the structure of the response
+
+    assert_eq!(name, response.name);
+
+    // Verify the semantics
+
+    let conversation = app
+        .conversations()
+        .get(&response.id)
+        .await
+        .expect("the newly-created conversation exists");
+    assert_eq!(response, conversation);
+}