summaryrefslogtreecommitdiff
path: root/src/channel/handlers/create
diff options
context:
space:
mode:
Diffstat (limited to 'src/channel/handlers/create')
-rw-r--r--src/channel/handlers/create/mod.rs67
-rw-r--r--src/channel/handlers/create/test.rs250
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);
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-05 04:26:39 +0000