use super::QrLoginService;
use super::{
QrLoginAction, QrLoginConfig, QrLoginPollOutcome, QrLoginSessionData, QrLoginStatus,
QrLoginWebContext,
};
use crate::dao::InMemoryDao;
use crate::error::GarrisonError;
use crate::i18n::{set_locale, GarrisonLocale};
use std::sync::Arc;
fn service() -> QrLoginService {
QrLoginService::new(
Arc::new(InMemoryDao::new()),
"test-secret-key-0123456789abcdef-0123456789abcdef",
)
.unwrap()
}
fn service_with_domains(domains: &[&str]) -> QrLoginService {
QrLoginService::new(
Arc::new(InMemoryDao::new()),
"test-secret-key-0123456789abcdef-0123456789abcdef",
)
.unwrap()
.with_config(QrLoginConfig {
allowed_domains: Some(domains.iter().map(|s| (*s).to_string()).collect()),
..Default::default()
})
}
fn web_context() -> QrLoginWebContext {
QrLoginWebContext {
ip: Some("203.0.113.7".to_string()),
user_agent: Some(
"Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 Chrome/126.0 Safari/537.36"
.to_string(),
),
created_at_ms: 1_725_000_000_000,
}
}
fn ticket_of(qr_content: &str) -> &str {
qr_content
.split("t=")
.nth(1)
.expect("qr_content 应含 t= 参数")
}
fn assert_error_text(err: &GarrisonError, text: &str) {
set_locale(GarrisonLocale::En);
let rendered = match err {
GarrisonError::InvalidParam(m)
| GarrisonError::InvalidToken(m)
| GarrisonError::Dao(m)
| GarrisonError::Internal(m) => m.clone(),
other => format!("{other:?}"),
};
assert!(rendered.contains(text), "应含 {text:?},实际: {rendered}");
}
#[tokio::test]
async fn new_rejects_empty_secret() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let err = QrLoginService::new(Arc::new(InMemoryDao::new()), "")
.expect_err("empty secret must be rejected");
assert_error_text(&err, "secret must not be empty");
}
#[tokio::test]
async fn new_rejects_short_secret() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let err = QrLoginService::new(Arc::new(InMemoryDao::new()), "a".repeat(31))
.expect_err("31-byte secret must be rejected");
assert_error_text(&err, "at least 32 bytes");
}
#[tokio::test]
async fn new_accepts_32_byte_secret() {
let svc = QrLoginService::new(Arc::new(InMemoryDao::new()), "b".repeat(32))
.expect("32-byte secret must be accepted");
assert!(
svc.with_config(QrLoginConfig::default())
.config
.session_ttl_secs
> 0
);
}
#[test]
fn session_data_serde_roundtrip() {
let data = QrLoginSessionData {
qr_id: "abc123".to_string(),
status: QrLoginStatus::Scanned,
tenant_id: 3,
app_login_id: Some("user-1".to_string()),
confirm_token_hash: Some("deadbeef".to_string()),
web: web_context(),
};
let json = serde_json::to_string(&data).unwrap();
let back: QrLoginSessionData = serde_json::from_str(&json).unwrap();
assert_eq!(back.qr_id, data.qr_id);
assert_eq!(back.status, data.status);
assert_eq!(back.tenant_id, data.tenant_id);
assert_eq!(back.app_login_id, data.app_login_id);
assert_eq!(back.confirm_token_hash, data.confirm_token_hash);
assert_eq!(back.web.ip, data.web.ip);
assert_eq!(back.web.user_agent, data.web.user_agent);
assert_eq!(back.web.created_at_ms, data.web.created_at_ms);
}
#[test]
fn session_data_tenant_defaults_to_zero() {
let json = r#"{"qr_id":"x","status":"Pending","web":{}}"#;
let data: QrLoginSessionData = serde_json::from_str(json).unwrap();
assert_eq!(data.tenant_id, 0);
assert_eq!(data.status, QrLoginStatus::Pending);
assert!(data.app_login_id.is_none());
assert_eq!(data.web.created_at_ms, 0);
}
#[tokio::test]
async fn create_issues_signed_ticket_and_pending_session() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
assert_eq!(created.expires_in_secs, 120);
assert_eq!(created.qr_id.len(), 64, "qr_id 应为 64 hex");
assert_eq!(created.bind_token.len(), 64, "bind_token 应为 64 hex");
assert!(
!created.qr_content.contains(&created.bind_token),
"二维码内容不得泄露 bind_token"
);
let qr_id = svc
.verify_ticket_signature(ticket_of(&created.qr_content))
.unwrap();
assert_eq!(qr_id, created.qr_id);
let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
assert_eq!(data.status, QrLoginStatus::Pending);
assert_eq!(data.web.ip.as_deref(), Some("203.0.113.7"));
}
#[tokio::test]
async fn scan_moves_pending_to_scanned_and_issues_confirm_token() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
assert_eq!(view.expires_in_secs, 60);
assert_eq!(view.web_created_at_ms, 1_725_000_000_000);
assert_eq!(view.web_device_label, "Chrome", "UA 应解析为 Chrome");
assert!(!view.confirm_token.is_empty());
let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
assert_eq!(data.status, QrLoginStatus::Scanned);
assert_eq!(data.app_login_id.as_deref(), Some("user-1"));
assert_eq!(
data.confirm_token_hash.as_deref(),
Some(QrLoginService::token_digest(&view.confirm_token).as_str())
);
}
#[tokio::test]
async fn scan_rejects_forged_ticket() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let err = svc
.scan(
"garrison://qrlogin?t=forged_random.not_a_valid_sig",
"user-1",
None,
)
.await
.unwrap_err();
assert_error_text(&err, "ticket signature is invalid");
}
#[tokio::test]
async fn scan_allows_allowlisted_domain() {
let svc = service_with_domains(&["app.example.com"]);
let created = svc.create_session(web_context()).await.unwrap();
assert!(
created.qr_content.starts_with("https://app.example.com/"),
"白名单模式下 qr_content 应使用白名单域名,实际: {}",
created.qr_content
);
svc.scan(&created.qr_content, "user-1", None).await.unwrap();
}
#[tokio::test]
async fn scan_rejects_non_allowlisted_domain() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service_with_domains(&["app.example.com"]);
let created = svc.create_session(web_context()).await.unwrap();
let ticket = ticket_of(&created.qr_content);
let evil = format!("https://evil.example.com/qrlogin/confirm?t={ticket}");
let err = svc.scan(&evil, "user-1", None).await.unwrap_err();
assert_error_text(&err, "domain is not allowed");
}
#[tokio::test]
async fn scan_rejects_repeated_scan_and_cancelled_session() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
svc.scan(&created.qr_content, "user-1", None).await.unwrap();
let err = svc
.scan(&created.qr_content, "user-1", None)
.await
.unwrap_err();
assert_error_text(&err, "already been scanned");
let created2 = svc.create_session(web_context()).await.unwrap();
let view2 = svc
.scan(&created2.qr_content, "user-1", None)
.await
.unwrap();
svc.confirm(&view2.confirm_token, "user-1", QrLoginAction::Cancel, None)
.await
.unwrap();
let err2 = svc
.scan(&created2.qr_content, "user-1", None)
.await
.unwrap_err();
assert_error_text(&err2, "has been cancelled");
}
#[tokio::test]
async fn confirm_by_other_user_rejected_indistinguishable() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
let err = svc
.confirm(&view.confirm_token, "user-2", QrLoginAction::Confirm, None)
.await
.expect_err("other user must not confirm");
assert_error_text(&err, "confirm token is invalid");
let svc2 = service();
let err2 = svc2
.confirm("nonexistent-token", "user-1", QrLoginAction::Confirm, None)
.await
.expect_err("invalid token must fail");
assert_eq!(format!("{}", err), format!("{}", err2));
}
#[tokio::test]
async fn confirm_moves_scanned_to_confirmed_and_replay_fails() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap();
let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
assert_eq!(data.status, QrLoginStatus::Confirmed);
let err = svc
.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap_err();
assert_error_text(&err, "confirm token is invalid");
}
#[tokio::test]
async fn confirm_pending_session_fails() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let token = "pending-path-confirm-token";
svc.store_confirm_token_for_test(token, &created.qr_id)
.await;
let err = svc
.confirm(token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap_err();
assert_error_text(&err, "has not been scanned");
}
#[tokio::test]
async fn cancel_action_moves_to_cancelled() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
.await
.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Cancelled
);
}
#[tokio::test]
async fn poll_confirmed_exchanges_atomically() {
let svc = Arc::new(service());
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap();
let s1 = Arc::clone(&svc);
let s2 = Arc::clone(&svc);
let qr_id = created.qr_id.clone();
let bind = created.bind_token.clone();
let (r1, r2) = tokio::join!(s1.poll(&qr_id, &bind), s2.poll(&qr_id, &bind));
let outcomes = [r1.unwrap(), r2.unwrap()];
let confirmed = outcomes
.iter()
.filter(|o| matches!(o, QrLoginPollOutcome::Confirmed { .. }))
.count();
let expired = outcomes
.iter()
.filter(|o| matches!(o, QrLoginPollOutcome::Expired))
.count();
assert_eq!(confirmed, 1, "并发兑换仅一者成功");
assert_eq!(expired, 1, "另一者应见 Expired");
if let QrLoginPollOutcome::Confirmed { login_id, .. } = &outcomes[0] {
assert_eq!(login_id, "user-1");
}
}
#[tokio::test]
async fn poll_outcomes_and_post_exchange_confirm() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Pending
);
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Scanned
);
assert_eq!(
svc.poll("nonexistent-qr-id", &created.bind_token)
.await
.unwrap(),
QrLoginPollOutcome::Expired
);
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap();
assert!(matches!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Confirmed { .. }
));
let err = svc
.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap_err();
assert_error_text(&err, "confirm token is invalid");
}
#[tokio::test]
async fn confirm_replay_after_cancel_fails_fail_closed() {
let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
.await
.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Cancelled
);
let err = svc
.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
.await
.unwrap_err();
assert_error_text(&err, "confirm token is invalid");
}
#[tokio::test]
async fn poll_with_wrong_bind_token_is_expired() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
assert_eq!(
svc.poll(&created.qr_id, "wrong-bind-token").await.unwrap(),
QrLoginPollOutcome::Expired
);
}
#[tokio::test]
async fn poll_bind_token_replay_is_expired() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Pending
);
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Pending
);
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
.await
.unwrap();
assert!(matches!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Confirmed { .. }
));
assert_eq!(
svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
QrLoginPollOutcome::Expired,
"重放已消费的 bind_token 必须 Expired"
);
}
#[cfg(all(feature = "listener", feature = "protocol-qrlogin"))]
mod app_context_event_tests {
use super::*;
use crate::error::GarrisonResult;
use crate::listener::{GarrisonEvent, GarrisonListener, GarrisonListenerManager};
use std::sync::Mutex;
struct CapturingListener(Mutex<Vec<GarrisonEvent>>);
#[async_trait::async_trait]
impl GarrisonListener for CapturingListener {
async fn on_event(&self, event: &GarrisonEvent) -> GarrisonResult<()> {
self.0.lock().unwrap().push(event.clone());
Ok(())
}
}
fn ctx() -> Option<(String, String)> {
Some(("198.51.100.9".to_string(), "TestAgent/1.0".to_string()))
}
#[tokio::test]
async fn scan_event_carries_app_context() {
let captured = std::sync::Arc::new(CapturingListener(Mutex::new(Vec::new())));
let lm = GarrisonListenerManager::new();
lm.register(std::sync::Arc::clone(&captured) as std::sync::Arc<dyn GarrisonListener>);
let svc = service().with_listener_manager(std::sync::Arc::new(lm));
let created = svc.create_session(web_context()).await.unwrap();
let view = svc
.scan(&created.qr_content, "user-1", ctx())
.await
.unwrap();
let _ = view.confirm_token;
let events = captured.0.lock().unwrap();
let scanned = events
.iter()
.find_map(|e| match e {
GarrisonEvent::QrLoginScanned {
app_login_id,
request_context,
..
} => Some((app_login_id.clone(), request_context.clone())),
_ => None,
})
.expect("应广播 QrLoginScanned");
assert_eq!(scanned.0, "user-1");
let rc = scanned.1.expect("request_context 应非 None");
assert_eq!(rc.ip.as_deref(), Some("198.51.100.9"));
assert_eq!(rc.user_agent.as_deref(), Some("TestAgent/1.0"));
}
#[tokio::test]
async fn confirm_event_carries_app_context() {
let captured = std::sync::Arc::new(CapturingListener(Mutex::new(Vec::new())));
let lm = GarrisonListenerManager::new();
lm.register(std::sync::Arc::clone(&captured) as std::sync::Arc<dyn GarrisonListener>);
let svc = service().with_listener_manager(std::sync::Arc::new(lm));
let created = svc.create_session(web_context()).await.unwrap();
let view = svc
.scan(&created.qr_content, "user-1", ctx())
.await
.unwrap();
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, ctx())
.await
.unwrap();
let events = captured.0.lock().unwrap();
let confirmed = events
.iter()
.find_map(|e| match e {
GarrisonEvent::QrLoginConfirmed {
request_context, ..
} => Some(request_context.clone()),
_ => None,
})
.expect("应广播 QrLoginConfirmed");
let rc = confirmed.expect("request_context 应非 None");
assert_eq!(rc.ip.as_deref(), Some("198.51.100.9"));
}
}
#[test]
fn debug_redacts_secret_and_hmac_key() {
let secret = "test-secret-key-0123456789abcdef-0123456789abcdef";
let svc = QrLoginService::new(Arc::new(InMemoryDao::new()), secret).unwrap();
let s = format!("{svc:?}");
assert!(s.contains("[REDACTED]"), "secret 应脱敏: {s}");
assert!(!s.contains(secret), "Debug 不得包含 secret 原文: {s}");
}
#[tokio::test]
async fn scan_device_label_parses_edge_firefox_safari_and_unknown() {
let cases: &[(&str, &str)] = &[
(
"Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 Chrome/126.0 Safari/537.36 Edg/126.0",
"Edge",
),
("Mozilla/5.0 (X11; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0", "Firefox"),
("Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1", "Safari"),
("curl/8.5.0", "Unknown device"),
];
for (ua, expected) in cases {
let svc = service();
let ctx = QrLoginWebContext {
ip: None,
user_agent: Some((*ua).to_string()),
created_at_ms: 1_725_000_000_000,
};
let created = svc.create_session(ctx).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
assert_eq!(
view.web_device_label, *expected,
"UA「{ua}」应解析为 {expected}"
);
}
}
#[tokio::test]
async fn scan_device_label_without_user_agent_is_unknown() {
let svc = service();
let ctx = QrLoginWebContext {
ip: None,
user_agent: None,
created_at_ms: 1_725_000_000_000,
};
let created = svc.create_session(ctx).await.unwrap();
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
assert_eq!(view.web_device_label, "Unknown device");
}
#[tokio::test]
async fn poll_rejects_non_hex_ticket_shapes() {
let svc = service();
assert_eq!(
svc.poll("short", "also-not-hex").await.unwrap(),
QrLoginPollOutcome::Expired,
"非 64-hex 形态应直接 Expired"
);
let long_non_hex = "z".repeat(64);
assert_eq!(
svc.poll(&long_non_hex, &long_non_hex).await.unwrap(),
QrLoginPollOutcome::Expired
);
}
#[tokio::test]
async fn poll_unknown_session_returns_expired() {
let svc = service();
let hex64 = "a".repeat(64);
assert_eq!(
svc.poll(&hex64, &hex64).await.unwrap(),
QrLoginPollOutcome::Expired
);
}
#[tokio::test]
async fn poll_with_wrong_bind_token_returns_expired_in_each_state() {
let svc = service();
let created = svc.create_session(web_context()).await.unwrap();
let wrong_bind = "b".repeat(64);
assert_eq!(
svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
QrLoginPollOutcome::Expired,
"Pending 怕错票应 Expired"
);
let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
QrLoginPollOutcome::Expired
);
assert!(!view.confirm_token.is_empty());
svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
.await
.unwrap();
assert_eq!(
svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
QrLoginPollOutcome::Expired
);
}