stano-di 0.2.0

Lightweight dependency injection container with lazy singleton resolution, cycle detection, and async-safe validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use stano_di::application_context::ApplicationContext;
use stano_di::container::Container;
use stano_di::environment::Environment;
use stano_di_macros::{component, service};
use std::collections::HashMap;
use std::sync::Arc;

struct TestEnvironment(HashMap<String, String>);

impl Environment for TestEnvironment {
    fn get(&self, key: &str) -> Option<String> {
        self.0.get(key).cloned()
    }
}

#[component]
pub trait Greeter: Send + Sync {
    fn greet(&self) -> String;
}

#[service(dyn Greeter)]
pub struct EnglishGreeter;

impl Greeter for EnglishGreeter {
    fn greet(&self) -> String {
        "hello".to_string()
    }
}

#[test]
fn test_component_and_service_macros_register_and_resolve_via_container() {
    let mut container = Container::new();
    container.register_component::<EnglishGreeter>();
    let greeter = container.get_trait::<dyn Greeter>();
    assert_eq!(greeter.greet(), "hello");
}

#[test]
fn test_component_and_service_macros_register_and_resolve_via_application_context() {
    let mut ctx = ApplicationContext::new(Arc::new(TestEnvironment(HashMap::new())));
    ctx.register_component::<EnglishGreeter>();
    let greeter = ctx.get_trait::<dyn Greeter>();
    assert_eq!(greeter.greet(), "hello");
}

// A concrete (non-trait) dependency that a `#[service]` struct can hold via an
// `Arc<T>` field.
#[service]
pub struct Logger;

impl Clone for Logger {
    fn clone(&self) -> Self {
        Logger
    }
}

impl Logger {
    fn log(&self, msg: &str) -> String {
        format!("[log] {msg}")
    }
}

// `#[service(dyn Trait)]` with a real `Arc<T>` dependency field, exercising the
// macro's concrete-field dependency-resolution codegen (not just unit structs).
#[service(dyn Greeter)]
pub struct LoggingGreeter {
    logger: Arc<Logger>,
}

impl Greeter for LoggingGreeter {
    fn greet(&self) -> String {
        self.logger.log("hello")
    }
}

#[test]
fn test_service_with_arc_dependency_field_resolves_via_container() {
    let mut container = Container::new();
    container.register_component::<Logger>();
    container.register_component::<LoggingGreeter>();
    let greeter = container.get_trait::<dyn Greeter>();
    assert_eq!(greeter.greet(), "[log] hello");
}

// Bare `#[service]` (no trait arg) registers as its own concrete type, exercising
// the non-trait registration branch of the macro's codegen.
#[service]
pub struct PlainWidget;

impl Clone for PlainWidget {
    fn clone(&self) -> Self {
        PlainWidget
    }
}

impl PlainWidget {
    fn value(&self) -> i32 {
        42
    }
}

#[test]
fn test_bare_service_without_trait_registers_as_concrete_type() {
    let mut container = Container::new();
    container.register_component::<PlainWidget>();
    let widget = container.get::<PlainWidget>();
    assert_eq!(widget.value(), 42);
}

// Bare `#[service]` with an `Arc<T>` dependency field, combining both branches.
#[service]
pub struct Combo {
    logger: Arc<Logger>,
}

impl Clone for Combo {
    fn clone(&self) -> Self {
        Combo {
            logger: self.logger.clone(),
        }
    }
}

impl Combo {
    fn describe(&self) -> String {
        self.logger.log("combo")
    }
}

#[test]
fn test_bare_service_with_arc_dependency_field() {
    let mut container = Container::new();
    container.register_component::<Logger>();
    container.register_component::<Combo>();
    let combo = container.get::<Combo>();
    assert_eq!(combo.describe(), "[log] combo");
}