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.

2 files changed, 0 insertions, 317 deletions

diff --git a/src/channel/handlers/create/mod.rs b/src/channel/handlers/create/mod.rs
deleted file mode 100644
index 2c860fc..0000000
--- a/src/channel/handlers/create/mod.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use axum::{
-    extract::{Json, State},
-    http::StatusCode,
-    response::{self, IntoResponse},
-};
-
-use crate::{
-    app::App,
-    channel::{Channel, app},
-    clock::RequestedAt,
-    error::Internal,
-    name::Name,
-    token::extract::Identity,
-};
-
-#[cfg(test)]
-mod test;
-
-pub async fn handler(
-    State(app): State<App>,
-    _: Identity, // requires auth, but doesn't actually care who you are
-    RequestedAt(created_at): RequestedAt,
-    Json(request): Json<Request>,
-) -> Result<Response, Error> {
-    let channel = app
-        .channels()
-        .create(&request.name, &created_at)
-        .await
-        .map_err(Error)?;
-
-    Ok(Response(channel))
-}
-
-#[derive(serde::Deserialize)]
-pub struct Request {
-    pub name: Name,
-}
-
-#[derive(Debug)]
-pub struct Response(pub Channel);
-
-impl IntoResponse for Response {
-    fn into_response(self) -> response::Response {
-        let Self(channel) = self;
-        (StatusCode::ACCEPTED, Json(channel)).into_response()
-    }
-}
-
-#[derive(Debug)]
-pub struct Error(pub app::CreateError);
-
-impl IntoResponse for Error {
-    fn into_response(self) -> response::Response {
-        let Self(error) = self;
-        match error {
-            app::CreateError::DuplicateName(_) => {
-                (StatusCode::CONFLICT, error.to_string()).into_response()
-            }
-            app::CreateError::InvalidName(_) => {
-                (StatusCode::BAD_REQUEST, error.to_string()).into_response()
-            }
-            app::CreateError::Name(_) | app::CreateError::Database(_) => {
-                Internal::from(error).into_response()
-            }
-        }
-    }
-}
diff --git a/src/channel/handlers/create/test.rs b/src/channel/handlers/create/test.rs
deleted file mode 100644
index 31bb778..0000000
--- a/src/channel/handlers/create/test.rs
+++ /dev/null
@@ -1,250 +0,0 @@
-use std::future;
-
-use axum::extract::{Json, State};
-use futures::stream::StreamExt as _;
-use itertools::Itertools;
-
-use crate::{
-    channel::app,
-    name::Name,
-    test::fixtures::{self, future::Expect as _},
-};
-
-#[tokio::test]
-async fn new_channel() {
-    // 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::channel::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 channel 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::channel)
-        .filter_map(fixtures::event::channel::created)
-        .exactly_one()
-        .expect("only one channel has been created");
-    assert_eq!(response, created.channel);
-
-    let channel = app
-        .channels()
-        .get(&response.id)
-        .await
-        .expect("the newly-created channel exists");
-    assert_eq!(response, channel);
-
-    let mut events = app
-        .events()
-        .subscribe(resume_point)
-        .await
-        .expect("subscribing never fails")
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::created)
-        .filter(|event| future::ready(event.channel == response));
-
-    let event = events.next().expect_some("creation event published").await;
-
-    assert_eq!(event.channel, 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 channel = fixtures::channel::create(&app, &fixtures::now()).await;
-
-    // Call the endpoint
-
-    let request = super::Request {
-        name: channel.name.clone(),
-    };
-    let super::Error(error) =
-        super::handler(State(app.clone()), creator, fixtures::now(), Json(request))
-            .await
-            .expect_err("duplicate channel name should fail the request");
-
-    // Verify the structure of the response
-
-    assert!(matches!(
-        error,
-        app::CreateError::DuplicateName(name) if channel.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.channels()
-        .create(&existing_name, &fixtures::now())
-        .await
-        .expect("creating a channel 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 channel 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::channel::propose_invalid_name();
-    let request = super::Request { name: name.clone() };
-    let super::Error(error) = crate::channel::handlers::create::handler(
-        State(app.clone()),
-        creator,
-        fixtures::now(),
-        Json(request),
-    )
-    .await
-    .expect_err("invalid channel 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::channel::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 channel in an empty app");
-
-    // Delete the channel
-
-    app.channels()
-        .delete(&response.id, &fixtures::now())
-        .await
-        .expect("deleting a newly-created channel 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 channel deleted");
-
-    // Verify the structure of the response
-
-    assert_eq!(name, response.name);
-
-    // Verify the semantics
-
-    let channel = app
-        .channels()
-        .get(&response.id)
-        .await
-        .expect("the newly-created channel exists");
-    assert_eq!(response, channel);
-}
-
-#[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::channel::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 channel in an empty app");
-
-    // Delete the channel
-
-    app.channels()
-        .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 channel expired");
-
-    // Verify the structure of the response
-
-    assert_eq!(name, response.name);
-
-    // Verify the semantics
-
-    let channel = app
-        .channels()
-        .get(&response.id)
-        .await
-        .expect("the newly-created channel exists");
-    assert_eq!(response, channel);
-}