Reorganize and consolidate HTTP routes.

HTTP routes are now defined in a single, unified module, pulling them out of the topical modules they were formerly part of.

This is intended to improve the navigability of the codebase. Previously, finding the handler corresponding to a specific endpoint required prior familiarity, though in practice you could usually guess from topic area. Now, all routes are defined in one place; if you know the path, you can read down the list to find the handler.

Handlers themselves live with the domain they are most appropriately "part of," generally (in this version, universally) in a `handlers` submodule. The handlers themselves have been flattened down; rather than representing a path and a method, they now represent a named operation (which is suspiciously similar to the path in most cases). This means that we no longer have constructs like `crate::ui::routes::ch::channel` - it's now `crate::ui::handlers::channel` instead.

## Disclaimer

I Solemnly Swear I Didn't Change Any Handlers.

## Prior art

I've inadvertently reinvented Django's `urls.py` convention, and I've opted to lean into that.

Merges flatter-routes-reorg into main.

1 files changed, 242 insertions, 0 deletions

diff --git a/src/channel/handlers/create/test.rs b/src/channel/handlers/create/test.rs
new file mode 100644
index 0000000..3c770cf
--- /dev/null
+++ b/src/channel/handlers/create/test.rs
@@ -0,0 +1,242 @@
+use std::future;
+
+use axum::extract::{Json, State};
+use futures::stream::StreamExt as _;
+
+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");
+    assert!(snapshot.channels.iter().any(|channel| channel == &response));
+
+    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::channel)
+        .filter_map(fixtures::event::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);
+}