rust-dix 0.6.0

rust-dix: A Rust dependency injection framework inspired by Microsoft.Extensions.DependencyInjection
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
138
139
140

mod common;

use rust_dix::*;
use std::sync::Arc;

#[test]
fn wrapper_get_keyed_fallback_to_root() {
    let root = ServiceCollection::new()
        .keyed_singleton("a", |_| {
            Arc::new(common::Logger {
                prefix: "root".into(),
            })
        })
        .build()
        .unwrap();
    let child = ServiceCollection::new().build().unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let svc: Arc<common::Logger> = w.get_keyed("a").unwrap();
    assert_eq!(svc.prefix, "root");
}

#[test]
fn wrapper_get_named_child_first() {
    let root = ServiceCollection::new().build().unwrap();
    let child = ServiceCollection::new().build().unwrap();
    let root_svc = Arc::new(common::Logger {
        prefix: "root".into(),
    });
    let child_svc = Arc::new(common::Logger {
        prefix: "child".into(),
    });
    root.register_named("log", root_svc);
    child.register_named("log", child_svc.clone());
    let w = ServiceProviderWrapper::new(child.clone(), root.clone());
    let retrieved: Arc<common::Logger> = w.get_named("log").unwrap();
    assert_eq!(retrieved.prefix, "child");
}

#[test]
fn wrapper_get_named_fallback_to_root() {
    let root = ServiceCollection::new().build().unwrap();
    let child = ServiceCollection::new().build().unwrap();
    root.register_named("shared", Arc::new(common::MyService { value: 99 }));
    let w = ServiceProviderWrapper::new(child, root);
    let retrieved: Arc<common::MyService> = w.get_named("shared").unwrap();
    assert_eq!(retrieved.value, 99);
}

#[test]
fn wrapper_get_named_any_child_first() {
    let root = ServiceCollection::new().build().unwrap();
    let child = ServiceCollection::new().build().unwrap();
    root.register_named("key", Arc::new(common::MyService { value: 1 }));
    child.register_named("key", Arc::new(common::MyService { value: 2 }));
    let w = ServiceProviderWrapper::new(child, root);
    let retrieved = w.get_named_any("key").unwrap();
    let svc: Arc<common::MyService> = retrieved.downcast::<common::MyService>().unwrap();
    assert_eq!(svc.value, 2);
}

#[test]
fn wrapper_get_all_combines_both() {
    let root = ServiceCollection::new()
        .keyed_singleton("a", |_| Arc::new(common::MyService { value: 1 }))
        .build()
        .unwrap();
    let child = ServiceCollection::new()
        .keyed_singleton("b", |_| Arc::new(common::MyService { value: 2 }))
        .build()
        .unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let all: Vec<Arc<common::MyService>> = w.get_all();
    assert_eq!(all.len(), 2);
}

#[test]
fn wrapper_owned_resolution_child_first() {
    // Owned 解析：child 注册 Transient，wrapper.get_owned() 成功
    let root = ServiceCollection::new().build().unwrap();
    let child = ServiceCollection::new()
        .transient(|_| Arc::new(common::MyService { value: 42 }))
        .build()
        .unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let owned: common::MyService = w.get_owned().unwrap();
    assert_eq!(owned.value, 42);
}

#[test]
fn wrapper_owned_fallback_to_root() {
    // child 未注册，root 注册 Transient，wrapper.get_owned() 回退到 root
    let root = ServiceCollection::new()
        .transient(|_| Arc::new(common::MyService { value: 99 }))
        .build()
        .unwrap();
    let child = ServiceCollection::new().build().unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let owned: common::MyService = w.get_owned().unwrap();
    assert_eq!(owned.value, 99);
}

#[test]
fn wrapper_owned_singleton_returns_none() {
    // Singleton 服务不能被 owned，wrapper.get_owned() 返回 Err
    let root = ServiceCollection::new()
        .singleton(|_| Arc::new(common::MyService { value: 1 }))
        .build()
        .unwrap();
    let child = ServiceCollection::new().build().unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    assert!(w.get_owned::<common::MyService>().is_err());
}

#[tokio::test]
async fn wrapper_async_resolution_child_first() {
    // async 解析：child 注册 async_transient，wrapper.get_async() 成功
    let root = ServiceCollection::new().build().unwrap();
    let child = ServiceCollection::new()
        .async_transient(|_| Box::pin(async { Arc::new(common::MyService { value: 7 }) }))
        .build_async()
        .await
        .unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let svc: Arc<common::MyService> = w.get_async().await.unwrap();
    assert_eq!(svc.value, 7);
}

#[tokio::test]
async fn wrapper_async_fallback_to_root() {
    // child 未注册 async，root 注册 async_transient，wrapper.get_async() 回退到 root
    let root = ServiceCollection::new()
        .async_transient(|_| Box::pin(async { Arc::new(common::MyService { value: 11 }) }))
        .build_async()
        .await
        .unwrap();
    let child = ServiceCollection::new().build_async().await.unwrap();
    let w = ServiceProviderWrapper::new(child, root);
    let svc: Arc<common::MyService> = w.get_async().await.unwrap();
    assert_eq!(svc.value, 11);
}