From 4e3d5ccac99b24934c972e088cd7eb02bb95df06 Mon Sep 17 00:00:00 2001 From: Owen Jacobson Date: Tue, 17 Jun 2025 02:11:45 -0400 Subject: Handlers are _named operations_, which can be exposed via routes. Each domain module that exposes handlers does so through a `handlers` child module, ideally as a top-level symbol that can be plugged directly into Axum's `MethodRouter`. Modules could make exceptions to this - kill the doctrinaire inside yourself, after all - but none of the API modules that actually exist need such exceptions, and consistency is useful. The related details of request types, URL types, response types, errors, &c &c are then organized into modules under `handlers`, along with their respective tests. --- src/message/handlers/delete/mod.rs | 55 +++++++++++ src/message/handlers/delete/test.rs | 183 +++++++++++++++++++++++++++++++++++ src/message/handlers/mod.rs | 3 + src/message/mod.rs | 2 +- src/message/routes/message/mod.rs | 61 ------------ src/message/routes/message/test.rs | 184 ------------------------------------ src/message/routes/mod.rs | 1 - 7 files changed, 242 insertions(+), 247 deletions(-) create mode 100644 src/message/handlers/delete/mod.rs create mode 100644 src/message/handlers/delete/test.rs create mode 100644 src/message/handlers/mod.rs delete mode 100644 src/message/routes/message/mod.rs delete mode 100644 src/message/routes/message/test.rs delete mode 100644 src/message/routes/mod.rs (limited to 'src/message') diff --git a/src/message/handlers/delete/mod.rs b/src/message/handlers/delete/mod.rs new file mode 100644 index 0000000..5eac4eb --- /dev/null +++ b/src/message/handlers/delete/mod.rs @@ -0,0 +1,55 @@ +use axum::{ + extract::{Json, Path, State}, + http::StatusCode, + response::{self, IntoResponse}, +}; + +use crate::{ + app::App, + clock::RequestedAt, + error::{Internal, NotFound}, + message::{self, app::DeleteError}, + token::extract::Identity, +}; + +#[cfg(test)] +mod test; + +pub async fn handler( + State(app): State, + Path(message): Path, + RequestedAt(deleted_at): RequestedAt, + identity: Identity, +) -> Result { + app.messages() + .delete(&identity.user, &message, &deleted_at) + .await?; + + Ok(Response { id: message }) +} + +#[derive(Debug, serde::Serialize)] +pub struct Response { + pub id: message::Id, +} + +impl IntoResponse for Response { + fn into_response(self) -> response::Response { + (StatusCode::ACCEPTED, Json(self)).into_response() + } +} + +#[derive(Debug, thiserror::Error)] +#[error(transparent)] +pub struct Error(#[from] pub DeleteError); + +impl IntoResponse for Error { + fn into_response(self) -> response::Response { + let Self(error) = self; + match error { + DeleteError::NotSender(_) => (StatusCode::FORBIDDEN, error.to_string()).into_response(), + DeleteError::NotFound(_) | DeleteError::Deleted(_) => NotFound(error).into_response(), + DeleteError::Database(_) => Internal::from(error).into_response(), + } + } +} diff --git a/src/message/handlers/delete/test.rs b/src/message/handlers/delete/test.rs new file mode 100644 index 0000000..15aa2c2 --- /dev/null +++ b/src/message/handlers/delete/test.rs @@ -0,0 +1,183 @@ +use axum::extract::{Path, State}; + +use crate::{message::app, test::fixtures}; + +#[tokio::test] +pub async fn delete_message() { + // 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 message = fixtures::message::send(&app, &channel, &sender.user, &fixtures::now()).await; + + // Send the request + + let response = super::handler( + State(app.clone()), + Path(message.id.clone()), + fixtures::now(), + sender, + ) + .await + .expect("deleting a valid message succeeds"); + + // Verify the response + + assert_eq!(message.id, response.id); + + // Verify the semantics + + let snapshot = app.boot().snapshot().await.expect("boot always succeeds"); + assert!(!snapshot.messages.contains(&message)); +} + +#[tokio::test] +pub async fn delete_invalid_message_id() { + // Set up the environment + + let app = fixtures::scratch_app().await; + + // Send the request + + let deleter = fixtures::identity::create(&app, &fixtures::now()).await; + let message = fixtures::message::fictitious(); + let super::Error(error) = super::handler( + State(app.clone()), + Path(message.clone()), + fixtures::now(), + deleter, + ) + .await + .expect_err("deleting a nonexistent message fails"); + + // Verify the response + + assert!(matches!(error, app::DeleteError::NotFound(id) if id == message)); +} + +#[tokio::test] +pub async fn delete_deleted() { + // Set up the environment + + let app = fixtures::scratch_app().await; + let sender = fixtures::user::create(&app, &fixtures::now()).await; + let channel = fixtures::channel::create(&app, &fixtures::now()).await; + let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await; + + app.messages() + .delete(&sender, &message.id, &fixtures::now()) + .await + .expect("deleting a recently-sent message succeeds"); + + // Send the request + + let deleter = fixtures::identity::create(&app, &fixtures::now()).await; + let super::Error(error) = super::handler( + State(app.clone()), + Path(message.id.clone()), + fixtures::now(), + deleter, + ) + .await + .expect_err("deleting a deleted message fails"); + + // Verify the response + + assert!(matches!(error, app::DeleteError::Deleted(id) if id == message.id)); +} + +#[tokio::test] +pub async fn delete_expired() { + // Set up the environment + + let app = fixtures::scratch_app().await; + let sender = fixtures::user::create(&app, &fixtures::ancient()).await; + let channel = fixtures::channel::create(&app, &fixtures::ancient()).await; + let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await; + + app.messages() + .expire(&fixtures::now()) + .await + .expect("expiring messages always succeeds"); + + // Send the request + + let deleter = fixtures::identity::create(&app, &fixtures::now()).await; + let super::Error(error) = super::handler( + State(app.clone()), + Path(message.id.clone()), + fixtures::now(), + deleter, + ) + .await + .expect_err("deleting an expired message fails"); + + // Verify the response + + assert!(matches!(error, app::DeleteError::Deleted(id) if id == message.id)); +} + +#[tokio::test] +pub async fn delete_purged() { + // Set up the environment + + let app = fixtures::scratch_app().await; + let sender = fixtures::user::create(&app, &fixtures::ancient()).await; + let channel = fixtures::channel::create(&app, &fixtures::ancient()).await; + let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await; + + app.messages() + .expire(&fixtures::old()) + .await + .expect("expiring messages always succeeds"); + + app.messages() + .purge(&fixtures::now()) + .await + .expect("purging messages always succeeds"); + + // Send the request + + let deleter = fixtures::identity::create(&app, &fixtures::now()).await; + let super::Error(error) = super::handler( + State(app.clone()), + Path(message.id.clone()), + fixtures::now(), + deleter, + ) + .await + .expect_err("deleting a purged message fails"); + + // Verify the response + + assert!(matches!(error, app::DeleteError::NotFound(id) if id == message.id)); +} + +#[tokio::test] +pub async fn delete_not_sender() { + // Set up the environment + + let app = fixtures::scratch_app().await; + let sender = fixtures::user::create(&app, &fixtures::now()).await; + let channel = fixtures::channel::create(&app, &fixtures::now()).await; + let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await; + + // Send the request + + let deleter = fixtures::identity::create(&app, &fixtures::now()).await; + let super::Error(error) = super::handler( + State(app.clone()), + Path(message.id.clone()), + fixtures::now(), + deleter.clone(), + ) + .await + .expect_err("deleting a message someone else sent fails"); + + // Verify the response + + assert!( + matches!(error, app::DeleteError::NotSender(error_sender) if deleter.user == error_sender) + ); +} diff --git a/src/message/handlers/mod.rs b/src/message/handlers/mod.rs new file mode 100644 index 0000000..7e78475 --- /dev/null +++ b/src/message/handlers/mod.rs @@ -0,0 +1,3 @@ +mod delete; + +pub use delete::handler as delete; diff --git a/src/message/mod.rs b/src/message/mod.rs index fbaa4a3..e1643e6 100644 --- a/src/message/mod.rs +++ b/src/message/mod.rs @@ -1,10 +1,10 @@ pub mod app; mod body; pub mod event; +pub mod handlers; mod history; mod id; pub mod repo; -pub mod routes; mod snapshot; pub use self::{body::Body, event::Event, history::History, id::Id, snapshot::Message}; diff --git a/src/message/routes/message/mod.rs b/src/message/routes/message/mod.rs deleted file mode 100644 index a05d344..0000000 --- a/src/message/routes/message/mod.rs +++ /dev/null @@ -1,61 +0,0 @@ -#[cfg(test)] -mod test; - -pub mod delete { - use axum::{ - extract::{Json, Path, State}, - http::StatusCode, - response::{self, IntoResponse}, - }; - - use crate::{ - app::App, - clock::RequestedAt, - error::{Internal, NotFound}, - message::{self, app::DeleteError}, - token::extract::Identity, - }; - - pub async fn handler( - State(app): State, - Path(message): Path, - RequestedAt(deleted_at): RequestedAt, - identity: Identity, - ) -> Result { - app.messages() - .delete(&identity.user, &message, &deleted_at) - .await?; - - Ok(Response { id: message }) - } - - #[derive(Debug, serde::Serialize)] - pub struct Response { - pub id: message::Id, - } - - impl IntoResponse for Response { - fn into_response(self) -> response::Response { - (StatusCode::ACCEPTED, Json(self)).into_response() - } - } - - #[derive(Debug, thiserror::Error)] - #[error(transparent)] - pub struct Error(#[from] pub DeleteError); - - impl IntoResponse for Error { - fn into_response(self) -> response::Response { - let Self(error) = self; - match error { - DeleteError::NotSender(_) => { - (StatusCode::FORBIDDEN, error.to_string()).into_response() - } - DeleteError::NotFound(_) | DeleteError::Deleted(_) => { - NotFound(error).into_response() - } - DeleteError::Database(_) => Internal::from(error).into_response(), - } - } - } -} diff --git a/src/message/routes/message/test.rs b/src/message/routes/message/test.rs deleted file mode 100644 index 1888be7..0000000 --- a/src/message/routes/message/test.rs +++ /dev/null @@ -1,184 +0,0 @@ -use axum::extract::{Path, State}; - -use super::delete; -use crate::{message::app, test::fixtures}; - -#[tokio::test] -pub async fn delete_message() { - // 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 message = fixtures::message::send(&app, &channel, &sender.user, &fixtures::now()).await; - - // Send the request - - let response = delete::handler( - State(app.clone()), - Path(message.id.clone()), - fixtures::now(), - sender, - ) - .await - .expect("deleting a valid message succeeds"); - - // Verify the response - - assert_eq!(message.id, response.id); - - // Verify the semantics - - let snapshot = app.boot().snapshot().await.expect("boot always succeeds"); - assert!(!snapshot.messages.contains(&message)); -} - -#[tokio::test] -pub async fn delete_invalid_message_id() { - // Set up the environment - - let app = fixtures::scratch_app().await; - - // Send the request - - let deleter = fixtures::identity::create(&app, &fixtures::now()).await; - let message = fixtures::message::fictitious(); - let delete::Error(error) = delete::handler( - State(app.clone()), - Path(message.clone()), - fixtures::now(), - deleter, - ) - .await - .expect_err("deleting a nonexistent message fails"); - - // Verify the response - - assert!(matches!(error, app::DeleteError::NotFound(id) if id == message)); -} - -#[tokio::test] -pub async fn delete_deleted() { - // Set up the environment - - let app = fixtures::scratch_app().await; - let sender = fixtures::user::create(&app, &fixtures::now()).await; - let channel = fixtures::channel::create(&app, &fixtures::now()).await; - let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await; - - app.messages() - .delete(&sender, &message.id, &fixtures::now()) - .await - .expect("deleting a recently-sent message succeeds"); - - // Send the request - - let deleter = fixtures::identity::create(&app, &fixtures::now()).await; - let delete::Error(error) = delete::handler( - State(app.clone()), - Path(message.id.clone()), - fixtures::now(), - deleter, - ) - .await - .expect_err("deleting a deleted message fails"); - - // Verify the response - - assert!(matches!(error, app::DeleteError::Deleted(id) if id == message.id)); -} - -#[tokio::test] -pub async fn delete_expired() { - // Set up the environment - - let app = fixtures::scratch_app().await; - let sender = fixtures::user::create(&app, &fixtures::ancient()).await; - let channel = fixtures::channel::create(&app, &fixtures::ancient()).await; - let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await; - - app.messages() - .expire(&fixtures::now()) - .await - .expect("expiring messages always succeeds"); - - // Send the request - - let deleter = fixtures::identity::create(&app, &fixtures::now()).await; - let delete::Error(error) = delete::handler( - State(app.clone()), - Path(message.id.clone()), - fixtures::now(), - deleter, - ) - .await - .expect_err("deleting an expired message fails"); - - // Verify the response - - assert!(matches!(error, app::DeleteError::Deleted(id) if id == message.id)); -} - -#[tokio::test] -pub async fn delete_purged() { - // Set up the environment - - let app = fixtures::scratch_app().await; - let sender = fixtures::user::create(&app, &fixtures::ancient()).await; - let channel = fixtures::channel::create(&app, &fixtures::ancient()).await; - let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await; - - app.messages() - .expire(&fixtures::old()) - .await - .expect("expiring messages always succeeds"); - - app.messages() - .purge(&fixtures::now()) - .await - .expect("purging messages always succeeds"); - - // Send the request - - let deleter = fixtures::identity::create(&app, &fixtures::now()).await; - let delete::Error(error) = delete::handler( - State(app.clone()), - Path(message.id.clone()), - fixtures::now(), - deleter, - ) - .await - .expect_err("deleting a purged message fails"); - - // Verify the response - - assert!(matches!(error, app::DeleteError::NotFound(id) if id == message.id)); -} - -#[tokio::test] -pub async fn delete_not_sender() { - // Set up the environment - - let app = fixtures::scratch_app().await; - let sender = fixtures::user::create(&app, &fixtures::now()).await; - let channel = fixtures::channel::create(&app, &fixtures::now()).await; - let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await; - - // Send the request - - let deleter = fixtures::identity::create(&app, &fixtures::now()).await; - let delete::Error(error) = delete::handler( - State(app.clone()), - Path(message.id.clone()), - fixtures::now(), - deleter.clone(), - ) - .await - .expect_err("deleting a message someone else sent fails"); - - // Verify the response - - assert!( - matches!(error, app::DeleteError::NotSender(error_sender) if deleter.user == error_sender) - ); -} diff --git a/src/message/routes/mod.rs b/src/message/routes/mod.rs deleted file mode 100644 index e216a50..0000000 --- a/src/message/routes/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub mod message; -- cgit v1.2.3