#![cfg(feature = "backend-kit")]
use crate::backend::{AuthBackend, BackendEmbedded};
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use trait_kit::core::{AsyncAutoBuilder, ModuleMeta};
use trait_kit::kit::AsyncKit;
#[derive(Debug, thiserror::Error)]
pub enum BackendKitError {
#[error("backend build failed: {0}")]
BuildFailed(String),
}
pub struct BackendModule;
impl ModuleMeta for BackendModule {
const NAME: &'static str = "backend-embedded";
fn dependencies() -> &'static [(&'static str, std::any::TypeId)] {
&[]
}
}
impl AsyncAutoBuilder for BackendModule {
type Capability = Arc<dyn AuthBackend>;
type Error = BackendKitError;
fn build<'a>(
_kit: &'a AsyncKit,
) -> Pin<Box<dyn Future<Output = Result<Self::Capability, Self::Error>> + Send + 'a>> {
Box::pin(async move {
let backend = BackendEmbedded::new();
Ok(Arc::new(backend) as Arc<dyn AuthBackend>)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use trait_kit::kit::AsyncKit;
#[tokio::test]
async fn test_kit_builds_backend_module() {
let mut kit = AsyncKit::new();
kit.register::<BackendModule>()
.expect("register BackendModule failed");
let kit = kit.build().await.expect("kit build failed");
let backend: Arc<dyn AuthBackend> = kit
.require::<BackendModule>()
.expect("require BackendModule failed");
let _ = backend;
}
#[test]
fn test_backend_module_name() {
assert_eq!(BackendModule::NAME, "backend-embedded");
}
#[test]
fn test_backend_module_no_dependencies() {
assert!(BackendModule::dependencies().is_empty());
}
#[tokio::test]
async fn test_duplicate_registration_fails() {
let mut kit = AsyncKit::new();
kit.register::<BackendModule>().unwrap();
let result = kit.register::<BackendModule>();
assert!(result.is_err(), "重复注册应返回错误");
}
#[tokio::test]
async fn test_require_unbuilt_module_fails() {
let kit = AsyncKit::new();
let built = kit.build().await.expect("empty build should succeed");
let result: Result<Arc<dyn AuthBackend>, _> = built.require::<BackendModule>();
assert!(result.is_err(), "require 未构建模块应返回错误");
}
#[test]
fn test_backend_kit_error_display() {
let err = BackendKitError::BuildFailed("test reason".to_string());
assert_eq!(err.to_string(), "backend build failed: test reason");
}
#[tokio::test]
async fn test_built_backend_is_dyn_auth_backend() {
let mut kit = AsyncKit::new();
kit.register::<BackendModule>().expect("register failed");
let kit = kit.build().await.expect("build failed");
let backend: Arc<dyn AuthBackend> = kit.require::<BackendModule>().expect("require failed");
let _ = backend.check_login("any-token").await;
}
}