capy-framework 0.10.0

An opinionated full-stack Rust web framework with strong conventions and sensible defaults.
Documentation
//! Optional facade activation, production configuration and cookie contracts.
#![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"
    );
}