use rskit_errors::AppResult;
use crate::Container;
pub trait Resolve<T>
where
T: Send + Sync + 'static,
{
fn resolve(&self) -> AppResult<std::sync::Arc<T>>;
}
impl<T> Resolve<T> for Container
where
T: Send + Sync + 'static,
{
fn resolve(&self) -> AppResult<std::sync::Arc<T>> {
Container::resolve::<T>(self)
}
}
pub fn provide<T, F>(container: &Container, factory: F)
where
T: Send + Sync + 'static,
F: Fn() -> AppResult<std::sync::Arc<T>> + Send + Sync + 'static,
{
container.register_singleton(factory);
}
pub fn provide_singleton<T>(container: &Container, value: std::sync::Arc<T>)
where
T: Send + Sync + 'static,
{
container.register(value);
}
pub fn provide_transient<T, F>(container: &Container, factory: F)
where
T: Send + Sync + 'static,
F: Fn() -> AppResult<std::sync::Arc<T>> + Send + Sync + 'static,
{
container.register_factory(factory);
}
pub fn resolve<T>(container: &Container) -> AppResult<std::sync::Arc<T>>
where
T: Send + Sync + 'static,
{
container.resolve::<T>()
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use super::{Resolve, provide, provide_singleton, provide_transient, resolve};
use crate::Container;
#[derive(Debug)]
struct Service {
value: usize,
}
#[test]
fn provide_registers_lazy_singleton() {
let container = Container::new();
let counter = Arc::new(AtomicUsize::new(0));
let captured = Arc::clone(&counter);
provide(&container, move || {
let value = captured.fetch_add(1, Ordering::SeqCst);
Ok(Arc::new(Service { value }))
});
let first = resolve::<Service>(&container).expect("first resolve should succeed");
let second = resolve::<Service>(&container).expect("second resolve should succeed");
assert!(Arc::ptr_eq(&first, &second));
assert_eq!(counter.load(Ordering::SeqCst), 1);
}
#[test]
fn provide_singleton_registers_existing_value() {
let container = Container::new();
let service = Arc::new(Service { value: 42 });
provide_singleton(&container, Arc::clone(&service));
let resolved = resolve::<Service>(&container).expect("service should resolve");
assert!(Arc::ptr_eq(&service, &resolved));
}
#[test]
fn provide_transient_registers_factory() {
let container = Container::new();
let counter = Arc::new(AtomicUsize::new(0));
let captured = Arc::clone(&counter);
provide_transient(&container, move || {
let value = captured.fetch_add(1, Ordering::SeqCst);
Ok(Arc::new(Service { value }))
});
let first = resolve::<Service>(&container).expect("first resolve should succeed");
let second = resolve::<Service>(&container).expect("second resolve should succeed");
assert_ne!(first.value, second.value);
assert!(!Arc::ptr_eq(&first, &second));
}
#[test]
fn resolve_traits_delegate_to_container() {
let container = Container::new();
provide_singleton(&container, Arc::new(Service { value: 7 }));
let via_trait = <Container as Resolve<Service>>::resolve(&container)
.expect("trait resolve should succeed");
assert_eq!(via_trait.value, 7);
let via_function = resolve::<Service>(&container).expect("function resolve should succeed");
assert_eq!(via_function.value, 7);
}
}