garrison 0.9.0

Garrison - 面向 Rust 生态的一站式身份认证鉴权框架
Documentation
// Copyright (c) 2026 Kirky.X🌠
// SPDX-License-Identifier: Apache-2.0

//! 内置 AuthenticationFlow:经 `inventory::submit!` 编译期注册 4 个流程
//! (`default-password-flow` / `default-mfa-flow` / `default-social-flow` / `default-sso-flow`),
//! [`FlowRegistry::from_inventory`](super::registry::FlowRegistry::from_inventory) 自动收集。
//!
//! 密码 / 社交 / SSO 三条均为「登录步骤 + Conditional(HasCredential(totp), Mfa(totp), None)」可选 MFA;
//! `default-mfa-flow` 为「Login(password) → Mfa(totp)」强制 TOTP。

use super::builder::FlowBuilder;
use super::registry::FlowRegistration;
use super::{AuthCondition, AuthStep};

/// 构造 `default-password-flow`:Login(password) → Conditional(HasCredential(totp), Mfa(totp), None);
/// 用户已注册 TOTP 凭证时执行 MFA,否则跳过。
fn default_password_flow() -> super::AuthenticationFlow {
    FlowBuilder::new("default-password-flow")
        .login("password")
        .conditional(
            AuthCondition::HasCredential("totp".to_string()),
            AuthStep::Mfa {
                credential_type: Some("totp".to_string()),
            },
            None,
        )
        .build()
}

/// 构造 `default-mfa-flow`:Login(password) → Mfa(totp)。
fn default_mfa_flow() -> super::AuthenticationFlow {
    FlowBuilder::new("default-mfa-flow")
        .login("password")
        .mfa(Some("totp"))
        .build()
}

/// 构造 `default-social-flow`:SocialProvider(wechat) → Conditional(HasCredential(totp), Mfa(totp), None)。
fn default_social_flow() -> super::AuthenticationFlow {
    FlowBuilder::new("default-social-flow")
        .social("wechat")
        .conditional(
            AuthCondition::HasCredential("totp".to_string()),
            AuthStep::Mfa {
                credential_type: Some("totp".to_string()),
            },
            None,
        )
        .build()
}

/// 构造 `default-sso-flow`:SsoServer(default) → Conditional(HasCredential(totp), Mfa(totp), None)。
fn default_sso_flow() -> super::AuthenticationFlow {
    FlowBuilder::new("default-sso-flow")
        .sso("default")
        .conditional(
            AuthCondition::HasCredential("totp".to_string()),
            AuthStep::Mfa {
                credential_type: Some("totp".to_string()),
            },
            None,
        )
        .build()
}

inventory::submit! {
    FlowRegistration {
        name: "default-password-flow",
        flow: default_password_flow,
    }
}

inventory::submit! {
    FlowRegistration {
        name: "default-mfa-flow",
        flow: default_mfa_flow,
    }
}

inventory::submit! {
    FlowRegistration {
        name: "default-social-flow",
        flow: default_social_flow,
    }
}

inventory::submit! {
    FlowRegistration {
        name: "default-sso-flow",
        flow: default_sso_flow,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::account::authflow::FlowRegistry;

    /// `default-password-flow` 可从 Registry 查询且结构正确
    /// (Login + Conditional)。
    #[test]
    fn default_password_flow_registered() {
        let registry = FlowRegistry::from_inventory();
        let flow = registry
            .get("default-password-flow")
            .expect("default-password-flow 应已注册");
        assert_eq!(flow.name, "default-password-flow");
        assert_eq!(flow.steps.len(), 2);
        assert!(matches!(flow.steps[0], AuthStep::Login { .. }));
        assert!(matches!(flow.steps[1], AuthStep::Conditional { .. }));
        match &flow.steps[1] {
            AuthStep::Conditional {
                condition,
                if_step,
                else_step,
            } => {
                assert!(matches!(
                    condition,
                    AuthCondition::HasCredential(ref s) if s == "totp"
                ));
                assert!(matches!(
                    if_step.as_ref(),
                    AuthStep::Mfa { credential_type: Some(ref ct) } if ct == "totp"
                ));
                assert!(else_step.is_none());
            },
            _ => panic!("第二个步骤应为 Conditional"),
        }
    }

    /// `default-mfa-flow` 可从 Registry 查询且结构正确
    /// (Login + Mfa)。
    #[test]
    fn default_mfa_flow_registered() {
        let registry = FlowRegistry::from_inventory();
        let flow = registry
            .get("default-mfa-flow")
            .expect("default-mfa-flow 应已注册");
        assert_eq!(flow.name, "default-mfa-flow");
        assert_eq!(flow.steps.len(), 2);
        assert!(matches!(
            &flow.steps[0],
            AuthStep::Login { credential_type } if credential_type == "password"
        ));
        assert!(matches!(
            &flow.steps[1],
            AuthStep::Mfa { credential_type: Some(ref ct) } if ct == "totp"
        ));
    }

    /// `default-social-flow` 可从 Registry 查询且结构正确
    /// (SocialProvider + Conditional)。
    #[test]
    fn default_social_flow_registered() {
        let registry = FlowRegistry::from_inventory();
        let flow = registry
            .get("default-social-flow")
            .expect("default-social-flow 应已注册");
        assert_eq!(flow.name, "default-social-flow");
        assert_eq!(flow.steps.len(), 2);
        assert!(matches!(
            &flow.steps[0],
            AuthStep::SocialProvider { provider } if provider == "wechat"
        ));
        assert!(matches!(flow.steps[1], AuthStep::Conditional { .. }));
    }

    /// `default-sso-flow` 可从 Registry 查询且结构正确
    /// (SsoServer + Conditional)。
    #[test]
    fn default_sso_flow_registered() {
        let registry = FlowRegistry::from_inventory();
        let flow = registry
            .get("default-sso-flow")
            .expect("default-sso-flow 应已注册");
        assert_eq!(flow.name, "default-sso-flow");
        assert_eq!(flow.steps.len(), 2);
        assert!(matches!(
            &flow.steps[0],
            AuthStep::SsoServer { server_id } if server_id == "default"
        ));
        assert!(matches!(flow.steps[1], AuthStep::Conditional { .. }));
    }
}