#![cfg(feature = "auth")]
use capy_framework::{
self as capy,
auth::{MemoryResetDelivery, ResetDelivery, ResetMessage},
prelude::*,
};
use capy_testing::TestApp;
use std::{future::Future, pin::Pin, sync::Arc};
struct Delivery;
impl ResetDelivery for Delivery {
fn deliver(&self, _: ResetMessage) -> Pin<Box<dyn Future<Output = Result<()>> + Send + '_>> {
Box::pin(async { Ok(()) })
}
}
#[test]
fn auth_is_optional_and_production_refuses_insecure_settings_or_local_delivery() {
let config = AppConfig::default();
let doc = App::new().config(config.clone()).openapi().unwrap();
assert!(doc.as_value()["paths"]["/api/auth/me"].is_null());
let mut production = config;
production.app.environment = "production".into();
assert!(App::new()
.auth(MemoryResetDelivery::default())
.config(production.clone())
.openapi()
.is_err());
let doc = App::new()
.auth(Delivery)
.config(production.clone())
.openapi()
.unwrap();
assert_eq!(
doc.as_value()["components"]["securitySchemes"]["session"]["name"],
"__Host-session"
);
production.auth.secure = Some(false);
assert!(App::new()
.auth(Delivery)
.config(production)
.openapi()
.is_err());
}
#[capy::tokio::test(crate = "capy::tokio")]
async fn production_cookie_flags_and_custom_name_match_openapi() {
use capy::migration::MigrationTrait;
let mut config = AppConfig::default();
config.app.environment = "production".into();
config.database.url = "sqlite::memory:".into();
config.auth.cookie_name = Some("__Host-private_app".into());
let db = capy::db::connect(&config.database).await.unwrap();
capy::auth::migration::IdentityMigration
.up(&capy::migration::SchemaManager::new(&db))
.await
.unwrap();
let builder = App::new().auth(Delivery).config(config.clone());
assert_eq!(
builder.openapi().unwrap().as_value()["components"]["securitySchemes"]["session"]["name"],
"__Host-private_app"
);
let app = TestApp::new(builder.into_router(AppContext {
config: Arc::new(config),
db,
}));
let response = app
.get("/api/auth/csrf")
.header("x-capy-csrf".parse().unwrap(), "1".parse().unwrap())
.send()
.await;
response.assert_ok();
let cookie = response.headers["set-cookie"].to_str().unwrap();
for flag in [
"__Host-private_app=",
"Secure",
"HttpOnly",
"SameSite=Lax",
"Path=/",
] {
assert!(cookie.contains(flag));
}
assert!(!cookie.contains("Domain="));
assert_eq!(response.headers["cache-control"], "no-store");
let debug = format!("{response:?}");
assert!(!debug.contains(
&response.json::<Value>()["csrf_token"]
.as_str()
.unwrap()
.to_owned()
));
}
#[capy::tokio::test(crate = "capy::tokio")]
async fn auth_logs_and_request_observations_exclude_credentials() {
use capy::{migration::MigrationTrait, tracing::instrument::WithSubscriber};
use std::{io::Write, sync::Mutex};
#[derive(Clone)]
struct Capture(Arc<Mutex<Vec<u8>>>);
impl Write for Capture {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.0.lock().unwrap().extend_from_slice(bytes);
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let captured = Arc::new(Mutex::new(Vec::new()));
let writer = Capture(captured.clone());
let subscriber = tracing_subscriber::fmt()
.with_ansi(false)
.without_time()
.with_env_filter("info,sqlx=warn,sea_orm=warn")
.with_writer(move || writer.clone())
.finish();
let secrets = async {
let mut config = AppConfig::default(); config.database.url = "sqlite::memory:".into();
let db = capy::db::connect(&config.database).await.unwrap();
capy::auth::migration::IdentityMigration.up(&capy::migration::SchemaManager::new(&db)).await.unwrap();
let inbox = MemoryResetDelivery::default();
let observations = Arc::new(Mutex::new(String::new()));
let observed = observations.clone();
let app = TestApp::new(App::new().auth(inbox.clone()).observe_requests(move |event: &capy::RequestObservation| {
observed.lock().unwrap().push_str(&format!("{event:?}"));
}).into_router(AppContext { config: Arc::new(config), db }));
let csrf = app.get("/api/auth/csrf").header("x-capy-csrf".parse().unwrap(), "1".parse().unwrap()).send().await;
let cookie = csrf.cookie("session").unwrap(); let token = csrf.json::<Value>()["csrf_token"].as_str().unwrap().to_owned();
let response = app.post("/api/auth/register").cookie(cookie).header("x-csrf-token".parse().unwrap(), token.parse().unwrap())
.json(json!({"name":"Trace User", "email":"trace-private@example.com", "password":"trace-password-secret"})).send().await;
response.assert_created();
let cookie = response.cookie("session").unwrap();
let raw_session = cookie.to_str().unwrap().split_once('=').unwrap().1.to_owned();
let csrf = app.get("/api/auth/csrf").cookie(cookie.clone()).header("x-capy-csrf".parse().unwrap(), "1".parse().unwrap()).send().await;
let token2 = csrf.json::<Value>()["csrf_token"].as_str().unwrap().to_owned();
app.post("/api/auth/forgot-password").cookie(cookie).header("x-csrf-token".parse().unwrap(), token2.parse().unwrap())
.json(json!({"email":"trace-private@example.com"})).send().await.assert_ok();
let reset = inbox.take().pop().unwrap().token.expose().to_owned();
let secrets = vec![raw_session, token, token2, reset, "trace-password-secret".into(), "trace-private@example.com".into()];
for secret in &secrets { assert!(!observations.lock().unwrap().contains(secret)); }
secrets
}.with_subscriber(subscriber).await;
let log = String::from_utf8(captured.lock().unwrap().clone()).unwrap();
assert!(log.contains("auth.register.success"));
assert!(log.contains("auth.password_reset.requested"));
for secret in secrets {
assert!(
!log.contains(&secret),
"Auth diagnostic leaked a credential or account identifier"
);
}
}
#[capy::tokio::test(crate = "capy::tokio")]
async fn auth_preserves_explicit_static_cache_policy() {
let mut config = AppConfig::default();
config.database.url = "sqlite::memory:".into();
let db = capy::db::connect(&config.database).await.unwrap();
let app = TestApp::new(
App::new()
.auth(MemoryResetDelivery::default())
.routes(Routes::new().get("/asset.js", || async {
(
[("cache-control", "public, max-age=31536000, immutable")],
"const asset = true",
)
}))
.into_router(AppContext {
config: Arc::new(config),
db,
}),
);
let response = app.get("/asset.js").send().await;
response.assert_ok();
assert_eq!(
response.headers["cache-control"],
"public, max-age=31536000, immutable"
);
}