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.

2 files changed, 106 insertions, 0 deletions

diff --git a/src/invite/handlers/get/mod.rs b/src/invite/handlers/get/mod.rs
new file mode 100644
index 0000000..bb72586
--- /dev/null
+++ b/src/invite/handlers/get/mod.rs
@@ -0,0 +1,41 @@
+use axum::{
+    extract::{Json, Path, State},
+    response::{IntoResponse, Response},
+};
+
+use crate::{
+    app::App,
+    error::{Internal, NotFound},
+    invite::{Id, Summary, handlers::PathInfo},
+};
+
+#[cfg(test)]
+mod test;
+
+pub async fn handler(
+    State(app): State<App>,
+    Path(invite): Path<PathInfo>,
+) -> Result<Json<Summary>, Error> {
+    app.invites()
+        .get(&invite)
+        .await?
+        .map(Json)
+        .ok_or_else(move || Error::NotFound(invite))
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("invite not found: {0}")]
+    NotFound(Id),
+    #[error(transparent)]
+    Database(#[from] sqlx::Error),
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> Response {
+        match self {
+            Self::NotFound(_) => NotFound(self).into_response(),
+            Self::Database(_) => Internal::from(self).into_response(),
+        }
+    }
+}
diff --git a/src/invite/handlers/get/test.rs b/src/invite/handlers/get/test.rs
new file mode 100644
index 0000000..0f2f725
--- /dev/null
+++ b/src/invite/handlers/get/test.rs
@@ -0,0 +1,65 @@
+use axum::extract::{Json, Path, State};
+
+use crate::test::fixtures;
+
+#[tokio::test]
+async fn valid_invite() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let issuer = fixtures::user::create(&app, &fixtures::now()).await;
+    let invite = fixtures::invite::issue(&app, &issuer, &fixtures::now()).await;
+
+    // Call endpoint
+
+    let Json(response) = super::handler(State(app), Path(invite.id))
+        .await
+        .expect("get for an existing invite succeeds");
+
+    // Verify response
+
+    assert_eq!(issuer.name.display(), &response.issuer);
+    assert_eq!(invite.issued_at, response.issued_at);
+}
+
+#[tokio::test]
+async fn nonexistent_invite() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+
+    // Call endpoint
+
+    let invite = fixtures::invite::fictitious();
+    let error = super::handler(State(app), Path(invite.clone()))
+        .await
+        .expect_err("get for a nonexistent invite fails");
+
+    // Verify response
+
+    assert!(matches!(error, super::Error::NotFound(error_id) if invite == error_id));
+}
+
+#[tokio::test]
+async fn expired_invite() {
+    // Set up the environment
+
+    let app = fixtures::scratch_app().await;
+    let issuer = fixtures::user::create(&app, &fixtures::ancient()).await;
+    let invite = fixtures::invite::issue(&app, &issuer, &fixtures::ancient()).await;
+
+    app.invites()
+        .expire(&fixtures::now())
+        .await
+        .expect("expiring invites never fails");
+
+    // Call endpoint
+
+    let error = super::handler(State(app), Path(invite.id.clone()))
+        .await
+        .expect_err("get for an expired invite fails");
+
+    // Verify response
+
+    assert!(matches!(error, super::Error::NotFound(error_id) if invite.id == error_id));
+}