2 files changed, 0 insertions, 193 deletions
diff --git a/src/channel/handlers/send/mod.rs b/src/channel/handlers/send/mod.rs
deleted file mode 100644
index bde39e5..0000000
--- a/src/channel/handlers/send/mod.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use axum::{
-    extract::{Json, Path, State},
-    http::StatusCode,
-    response::{self, IntoResponse},
-};
-
-use crate::channel::handlers::PathInfo;
-use crate::{
-    app::App,
-    clock::RequestedAt,
-    error::{Internal, NotFound},
-    message::{Body, Message, app::SendError},
-    token::extract::Identity,
-};
-
-#[cfg(test)]
-mod test;
-
-pub async fn handler(
-    State(app): State<App>,
-    Path(channel): Path<PathInfo>,
-    RequestedAt(sent_at): RequestedAt,
-    identity: Identity,
-    Json(request): Json<Request>,
-) -> Result<Response, Error> {
-    let message = app
-        .messages()
-        .send(&channel, &identity.user, &sent_at, &request.body)
-        .await?;
-
-    Ok(Response(message))
-}
-
-#[derive(serde::Deserialize)]
-pub struct Request {
-    pub body: Body,
-}
-
-#[derive(Debug)]
-pub struct Response(pub Message);
-
-impl IntoResponse for Response {
-    fn into_response(self) -> response::Response {
-        let Self(message) = self;
-        (StatusCode::ACCEPTED, Json(message)).into_response()
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error(transparent)]
-pub struct Error(#[from] pub SendError);
-
-impl IntoResponse for Error {
-    fn into_response(self) -> response::Response {
-        let Self(error) = self;
-        match error {
-            SendError::ChannelNotFound(_) | SendError::ChannelDeleted(_) => {
-                NotFound(error).into_response()
-            }
-            SendError::Name(_) | SendError::Database(_) => Internal::from(error).into_response(),
-        }
-    }
-}
diff --git a/src/channel/handlers/send/test.rs b/src/channel/handlers/send/test.rs
deleted file mode 100644
index 70d45eb..0000000
--- a/src/channel/handlers/send/test.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use axum::extract::{Json, Path, State};
-use futures::stream::{self, StreamExt as _};
-
-use crate::{
-    channel,
-    event::Sequenced,
-    message::app::SendError,
-    test::fixtures::{self, future::Expect as _},
-};
-
-#[tokio::test]
-async fn messages_in_order() {
-    // Set up the environment
-
-    let app = fixtures::scratch_app().await;
-    let sender = fixtures::identity::create(&app, &fixtures::now()).await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-    let resume_point = fixtures::boot::resume_point(&app).await;
-
-    // Call the endpoint (twice)
-
-    let requests = vec![
-        (fixtures::now(), fixtures::message::propose()),
-        (fixtures::now(), fixtures::message::propose()),
-    ];
-
-    for (sent_at, body) in &requests {
-        let request = super::Request { body: body.clone() };
-
-        let _ = super::handler(
-            State(app.clone()),
-            Path(channel.id.clone()),
-            sent_at.clone(),
-            sender.clone(),
-            Json(request),
-        )
-        .await
-        .expect("sending to a valid channel succeeds");
-    }
-
-    // Verify the semantics
-
-    let mut events = app
-        .events()
-        .subscribe(resume_point)
-        .await
-        .expect("subscribing to a valid channel succeeds")
-        .filter_map(fixtures::event::stream::message)
-        .filter_map(fixtures::event::stream::message::sent)
-        .zip(stream::iter(requests));
-
-    while let Some((event, (sent_at, body))) = events
-        .next()
-        .expect_ready("an event should be ready for each message")
-        .await
-    {
-        assert_eq!(*sent_at, event.at());
-        assert_eq!(sender.user.id, event.message.sender);
-        assert_eq!(body, event.message.body);
-    }
-}
-
-#[tokio::test]
-async fn nonexistent_channel() {
-    // Set up the environment
-
-    let app = fixtures::scratch_app().await;
-    let sender = fixtures::identity::create(&app, &fixtures::now()).await;
-
-    // Call the endpoint
-
-    let sent_at = fixtures::now();
-    let channel = channel::Id::generate();
-    let request = super::Request {
-        body: fixtures::message::propose(),
-    };
-    let super::Error(error) = super::handler(
-        State(app),
-        Path(channel.clone()),
-        sent_at,
-        sender,
-        Json(request),
-    )
-    .await
-    .expect_err("sending to a nonexistent channel fails");
-
-    // Verify the structure of the response
-
-    assert!(matches!(
-        error,
-        SendError::ChannelNotFound(error_channel) if channel == error_channel
-    ));
-}
-
-#[tokio::test]
-async fn deleted_channel() {
-    // Set up the environment
-
-    let app = fixtures::scratch_app().await;
-    let sender = fixtures::identity::create(&app, &fixtures::now()).await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
-
-    app.channels()
-        .delete(&channel.id, &fixtures::now())
-        .await
-        .expect("deleting a new channel succeeds");
-
-    // Call the endpoint
-
-    let sent_at = fixtures::now();
-    let request = super::Request {
-        body: fixtures::message::propose(),
-    };
-    let super::Error(error) = super::handler(
-        State(app),
-        Path(channel.id.clone()),
-        sent_at,
-        sender,
-        Json(request),
-    )
-    .await
-    .expect_err("sending to a deleted channel fails");
-
-    // Verify the structure of the response
-
-    assert!(matches!(
-        error,
-        SendError::ChannelDeleted(error_channel) if channel.id == error_channel
-    ));
-}