Merge remote-tracking branch 'codeberg/main' into push-notify

9 files changed, 108 insertions, 52 deletions

diff --git a/src/test/fixtures/boot.rs b/src/test/fixtures/boot.rs
index 120726f..7421512 100644
--- a/src/test/fixtures/boot.rs
+++ b/src/test/fixtures/boot.rs
@@ -1,7 +1,12 @@
-use crate::{app::App, event::Sequence};
+use axum::extract::FromRef;
 
-pub async fn resume_point(app: &App) -> Sequence {
-    app.boot()
+use crate::{boot::app::Boot, event::Sequence};
+
+pub async fn resume_point<App>(app: &App) -> Sequence
+where
+    Boot: FromRef<App>,
+{
+    Boot::from_ref(app)
         .snapshot()
         .await
         .expect("boot always succeeds")
diff --git a/src/test/fixtures/conversation.rs b/src/test/fixtures/conversation.rs
index fb2f58d..f0d8c8c 100644
--- a/src/test/fixtures/conversation.rs
+++ b/src/test/fixtures/conversation.rs
@@ -1,3 +1,4 @@
+use axum::extract::FromRef;
 use faker_rand::{
     en_us::{addresses::CityName, names::FullName},
     faker_impl_from_templates,
@@ -6,15 +7,17 @@ use faker_rand::{
 use rand;
 
 use crate::{
-    app::App,
     clock::RequestedAt,
-    conversation::{self, Conversation},
+    conversation::{self, Conversation, app::Conversations},
     name::Name,
 };
 
-pub async fn create(app: &App, created_at: &RequestedAt) -> Conversation {
+pub async fn create<App>(app: &App, created_at: &RequestedAt) -> Conversation
+where
+    Conversations: FromRef<App>,
+{
     let name = propose();
-    app.conversations()
+    Conversations::from_ref(app)
         .create(&name, created_at)
         .await
         .expect("should always succeed if the conversation is actually new")
diff --git a/src/test/fixtures/cookie.rs b/src/test/fixtures/cookie.rs
index 7dc5083..0b5ec9b 100644
--- a/src/test/fixtures/cookie.rs
+++ b/src/test/fixtures/cookie.rs
@@ -1,21 +1,25 @@
+use axum::extract::FromRef;
 use uuid::Uuid;
 
 use crate::{
-    app::App, clock::RequestedAt, name::Name, password::Password, token::extract::IdentityCookie,
+    clock::RequestedAt, login::app::Logins, name::Name, password::Password,
+    token::extract::IdentityCookie,
 };
 
 pub fn not_logged_in() -> IdentityCookie {
     IdentityCookie::new()
 }
 
-pub async fn logged_in(
+pub async fn logged_in<App>(
     app: &App,
     credentials: &(Name, Password),
     now: &RequestedAt,
-) -> IdentityCookie {
+) -> IdentityCookie
+where
+    Logins: FromRef<App>,
+{
     let (name, password) = credentials;
-    let secret = app
-        .logins()
+    let secret = Logins::from_ref(app)
         .with_password(name, password, now)
         .await
         .expect("should succeed given known-valid credentials");
diff --git a/src/test/fixtures/identity.rs b/src/test/fixtures/identity.rs
index 93e4a38..20929f9 100644
--- a/src/test/fixtures/identity.rs
+++ b/src/test/fixtures/identity.rs
@@ -1,11 +1,15 @@
+use axum::extract::FromRef;
+
 use crate::{
     app::App,
     clock::RequestedAt,
+    login::app::Logins,
     name::Name,
     password::Password,
     test::fixtures,
     token::{
         Token,
+        app::Tokens,
         extract::{Identity, IdentityCookie},
     },
 };
@@ -15,23 +19,30 @@ pub async fn create(app: &App, created_at: &RequestedAt) -> Identity {
     logged_in(app, &credentials, created_at).await
 }
 
-pub async fn from_cookie(
+pub async fn from_cookie<App>(
     app: &App,
     cookie: &IdentityCookie,
     validated_at: &RequestedAt,
-) -> Identity {
+) -> Identity
+where
+    Tokens: FromRef<App>,
+{
     let secret = cookie.secret().expect("identity token has a secret");
-    app.tokens()
+    Tokens::from_ref(app)
         .validate(&secret, validated_at)
         .await
         .expect("always validates newly-issued secret")
 }
 
-pub async fn logged_in(
+pub async fn logged_in<App>(
     app: &App,
     credentials: &(Name, Password),
     issued_at: &RequestedAt,
-) -> Identity {
+) -> Identity
+where
+    Tokens: FromRef<App>,
+    Logins: FromRef<App>,
+{
     let secret = fixtures::cookie::logged_in(app, credentials, issued_at).await;
     from_cookie(app, &secret, issued_at).await
 }
diff --git a/src/test/fixtures/invite.rs b/src/test/fixtures/invite.rs
index 654d1b4..5a5d4d0 100644
--- a/src/test/fixtures/invite.rs
+++ b/src/test/fixtures/invite.rs
@@ -1,12 +1,16 @@
+use axum::extract::FromRef;
+
 use crate::{
-    app::App,
     clock::DateTime,
-    invite::{self, Invite},
+    invite::{self, Invite, app::Invites},
     login::Login,
 };
 
-pub async fn issue(app: &App, issuer: &Login, issued_at: &DateTime) -> Invite {
-    app.invites()
+pub async fn issue<App>(app: &App, issuer: &Login, issued_at: &DateTime) -> Invite
+where
+    Invites: FromRef<App>,
+{
+    Invites::from_ref(app)
         .issue(issuer, issued_at)
         .await
         .expect("issuing invites never fails")
diff --git a/src/test/fixtures/message.rs b/src/test/fixtures/message.rs
index 92ac1f5..0bd0b7a 100644
--- a/src/test/fixtures/message.rs
+++ b/src/test/fixtures/message.rs
@@ -1,22 +1,25 @@
+use axum::extract::FromRef;
 use faker_rand::lorem::Paragraphs;
 
 use crate::{
-    app::App,
     clock::RequestedAt,
     conversation::Conversation,
     login::Login,
-    message::{self, Body, Message},
+    message::{self, Body, Message, app::Messages},
 };
 
-pub async fn send(
+pub async fn send<App>(
     app: &App,
     conversation: &Conversation,
     sender: &Login,
     sent_at: &RequestedAt,
-) -> Message {
+) -> Message
+where
+    Messages: FromRef<App>,
+{
     let body = propose();
 
-    app.messages()
+    Messages::from_ref(app)
         .send(&conversation.id, sender, sent_at, &body)
         .await
         .expect("should succeed if the conversation exists")
diff --git a/src/test/verify/identity.rs b/src/test/verify/identity.rs
index 8e2d36e..fba2a4d 100644
--- a/src/test/verify/identity.rs
+++ b/src/test/verify/identity.rs
@@ -1,31 +1,43 @@
+use axum::extract::FromRef;
+
 use crate::{
-    app::App,
     login::Login,
     name::Name,
     test::{fixtures, verify},
-    token::{app::ValidateError, extract::IdentityCookie},
+    token::{
+        app::{Tokens, ValidateError},
+        extract::IdentityCookie,
+    },
 };
 
-pub async fn valid_for_name(app: &App, identity: &IdentityCookie, name: &Name) {
+pub async fn valid_for_name<App>(app: &App, identity: &IdentityCookie, name: &Name)
+where
+    Tokens: FromRef<App>,
+{
     let secret = identity
         .secret()
         .expect("identity cookie must be set to be valid");
     verify::token::valid_for_name(app, &secret, name).await;
 }
 
-pub async fn valid_for_login(app: &App, identity: &IdentityCookie, login: &Login) {
+pub async fn valid_for_login<App>(app: &App, identity: &IdentityCookie, login: &Login)
+where
+    Tokens: FromRef<App>,
+{
     let secret = identity
         .secret()
         .expect("identity cookie must be set to be valid");
     verify::token::valid_for_login(app, &secret, login).await;
 }
 
-pub async fn invalid(app: &App, identity: &IdentityCookie) {
+pub async fn invalid<App>(app: &App, identity: &IdentityCookie)
+where
+    Tokens: FromRef<App>,
+{
     let secret = identity
         .secret()
         .expect("identity cookie must be set to be invalid");
-    let validate_err = app
-        .tokens()
+    let validate_err = Tokens::from_ref(app)
         .validate(&secret, &fixtures::now())
         .await
         .expect_err("identity cookie secret must be invalid");
diff --git a/src/test/verify/login.rs b/src/test/verify/login.rs
index ae2e91e..aad01bc 100644
--- a/src/test/verify/login.rs
+++ b/src/test/verify/login.rs
@@ -1,23 +1,30 @@
+use axum::extract::FromRef;
+
 use crate::{
-    app::App,
-    login::app::LoginError,
+    login::app::{LoginError, Logins},
     name::Name,
     password::Password,
     test::{fixtures, verify},
+    token::app::Tokens,
 };
 
-pub async fn valid_login(app: &App, name: &Name, password: &Password) {
-    let secret = app
-        .logins()
+pub async fn valid_login<App>(app: &App, name: &Name, password: &Password)
+where
+    Logins: FromRef<App>,
+    Tokens: FromRef<App>,
+{
+    let secret = Logins::from_ref(app)
         .with_password(name, password, &fixtures::now())
         .await
         .expect("login credentials expected to be valid");
     verify::token::valid_for_name(&app, &secret, &name).await;
 }
 
-pub async fn invalid_login(app: &App, name: &Name, password: &Password) {
-    let error = app
-        .logins()
+pub async fn invalid_login<App>(app: &App, name: &Name, password: &Password)
+where
+    Logins: FromRef<App>,
+{
+    let error = Logins::from_ref(app)
         .with_password(name, password, &fixtures::now())
         .await
         .expect_err("login credentials expected not to be valid");
diff --git a/src/test/verify/token.rs b/src/test/verify/token.rs
index adc4397..1b61a19 100644
--- a/src/test/verify/token.rs
+++ b/src/test/verify/token.rs
@@ -1,32 +1,39 @@
+use axum::extract::FromRef;
+
 use crate::{
-    app::App,
     login::Login,
     name::Name,
     test::fixtures,
-    token::{Secret, app},
+    token::{Secret, app, app::Tokens},
 };
 
-pub async fn valid_for_name(app: &App, secret: &Secret, name: &Name) {
-    let identity = app
-        .tokens()
+pub async fn valid_for_name<App>(app: &App, secret: &Secret, name: &Name)
+where
+    Tokens: FromRef<App>,
+{
+    let identity = Tokens::from_ref(app)
         .validate(secret, &fixtures::now())
         .await
         .expect("provided secret is valid");
     assert_eq!(name, &identity.login.name);
 }
 
-pub async fn valid_for_login(app: &App, secret: &Secret, login: &Login) {
-    let identity = app
-        .tokens()
+pub async fn valid_for_login<App>(app: &App, secret: &Secret, login: &Login)
+where
+    Tokens: FromRef<App>,
+{
+    let identity = Tokens::from_ref(app)
         .validate(secret, &fixtures::now())
         .await
         .expect("provided secret is valid");
     assert_eq!(login, &identity.login);
 }
 
-pub async fn invalid(app: &App, secret: &Secret) {
-    let error = app
-        .tokens()
+pub async fn invalid<App>(app: &App, secret: &Secret)
+where
+    Tokens: FromRef<App>,
+{
+    let error = Tokens::from_ref(app)
         .validate(secret, &fixtures::now())
         .await
         .expect_err("provided secret is invalid");