fluxdi 1.2.2

FluxDI - Semi-Automatic Dependency Injector
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
141
142
143
144
145
146
147
148
149
150

use super::*;

#[test]
fn service_not_provided_error() {
    let err = Error::service_not_provided("MyType");
    assert!(err.kind == ErrorKind::ServiceNotProvided);
    assert!(err.message.contains("MyType"));
    assert!(err.message.contains("Module::configure"));
}

#[test]
fn service_not_provided_for_override_error() {
    let err = Error::service_not_provided_for_override("MyType");
    assert!(err.kind == ErrorKind::ServiceNotProvided);
    assert!(err.message.contains("override"));
    assert!(err.message.contains("provide"));
}

#[test]
fn service_not_provided_named_error() {
    let err = Error::service_not_provided_named("MyType", "primary");
    assert!(err.kind == ErrorKind::ServiceNotProvided);
    assert!(err.message.contains("MyType"));
    assert!(err.message.contains("primary"));
    assert!(err.message.contains("provide_named"));
}

#[test]
fn type_mismatch_error() {
    let err = Error::type_mismatch("OtherType");
    assert!(err.kind == ErrorKind::TypeMismatch);
    assert!(err.message.contains("OtherType"));
}

#[test]
fn provider_already_registered_error() {
    let err = Error::provider_already_registered("Foo", "transient");
    assert!(err.kind == ErrorKind::ProviderAlreadyRegistered);
    assert!(err.message.contains("Foo"));
    assert!(err.message.contains("transient"));
    assert!(err.message.contains("override_provider"));
}

#[test]
fn provider_already_registered_named_error() {
    let err = Error::provider_already_registered_named("Foo", "primary", "root");
    assert!(err.kind == ErrorKind::ProviderAlreadyRegistered);
    assert!(err.message.contains("Foo"));
    assert!(err.message.contains("primary"));
    assert!(err.message.contains("root"));
}

#[test]
fn circular_dependency_error() {
    let chain = ["A", "B", "A"];
    let err = Error::circular_dependency(&chain);
    assert!(err.kind == ErrorKind::CircularDependency);
    assert!(err.message.contains("A -> B -> A"));
    assert!(err.message.contains("Break the cycle"));
}

#[test]
fn async_factory_requires_async_resolve_error() {
    let err = Error::async_factory_requires_async_resolve("AsyncType");
    assert!(err.kind == ErrorKind::AsyncFactoryRequiresAsyncResolve);
    assert!(err.message.contains("AsyncType"));
    assert!(err.message.contains("try_resolve_async"));
}

#[test]
fn resource_limit_exceeded_error() {
    let err = Error::resource_limit_exceeded("DbPool", "max_concurrent_creations=1");
    assert!(err.kind == ErrorKind::ResourceLimitExceeded);
    assert!(err.message.contains("DbPool"));
    assert!(err.message.contains("max_concurrent_creations=1"));
}

#[test]
fn module_lifecycle_failed_error() {
    let err = Error::module_lifecycle_failed("WebModule", "on_start", "bind failed");
    assert!(err.kind == ErrorKind::ModuleLifecycleFailed);
    assert!(err.message.contains("WebModule"));
    assert!(err.message.contains("on_start"));
    assert!(err.message.contains("bind failed"));
}

#[test]
fn graph_validation_failed_error() {
    let err = Error::graph_validation_failed("missing Foo");
    assert!(err.kind == ErrorKind::GraphValidationFailed);
    assert!(err.message.contains("missing Foo"));
    assert!(err.message.contains("dependency_graph"));
}

#[test]
fn display_trait() {
    let err = Error::service_not_provided("X");
    let s = format!("{}", err);
    #[cfg(feature = "debug")]
    assert!(s.contains("ServiceNotProvided"));
    assert!(s.contains("X"));
}

#[test]
fn error_kind_equality() {
    let err1 = Error::type_mismatch("A");
    let err2 = Error::type_mismatch("B");
    assert!(err1.kind == err2.kind);
    assert_ne!(err1.message, err2.message);
}

#[test]
fn shutdown_aggregate_error() {
    let e1 = Error::module_lifecycle_failed("A", "on_stop", "detail1");
    let e2 = Error::module_lifecycle_failed("B", "on_stop", "detail2");
    let err = Error::shutdown_aggregate(vec![e1, e2]);
    assert_eq!(err.kind, ErrorKind::ModuleLifecycleFailed);
    assert!(err.message.contains("2 module(s) reported errors"));
    assert!(err.message.contains("detail1"));
    assert!(err.message.contains("detail2"));
}

#[test]
fn shutdown_aggregate_single_error_returns_unchanged() {
    let e = Error::module_lifecycle_failed("A", "on_stop", "detail");
    let err = Error::shutdown_aggregate(vec![e]);
    assert_eq!(err.kind, ErrorKind::ModuleLifecycleFailed);
    assert!(err.message.contains("A"));
    assert!(err.message.contains("detail"));
}

#[test]
fn bootstrap_aggregate_error() {
    let e1 = Error::module_lifecycle_failed("A", "on_start", "detail1");
    let e2 = Error::module_lifecycle_failed("B", "on_start", "detail2");
    let err = Error::bootstrap_aggregate(vec![e1, e2]);
    assert_eq!(err.kind, ErrorKind::ModuleLifecycleFailed);
    assert!(err.message.contains("2 module(s) reported errors"));
    assert!(err.message.contains("detail1"));
    assert!(err.message.contains("detail2"));
}

#[test]
fn bootstrap_aggregate_single_error_returns_unchanged() {
    let e = Error::module_lifecycle_failed("A", "on_start", "detail");
    let err = Error::bootstrap_aggregate(vec![e]);
    assert_eq!(err.kind, ErrorKind::ModuleLifecycleFailed);
    assert!(err.message.contains("A"));
    assert!(err.message.contains("detail"));
}