inject 0.1.3

Experimental IOC library for Rust
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

use ::inject::{container, get, Container, InjectError, Provider};
use std::sync::Arc;

use rstest::*;

mod fixtures;
use fixtures::*;

#[rstest]
fn test_get_without_provider_installed_errors() {
    let expected = Err(InjectError::MissingProvider);
    let container = Container::default();

    let provided = container.get::<Data>();

    assert_eq!(provided, expected)
}

#[rstest(data(2))]
fn test_get_with_provider_installed_returns_implementation(
    data: Data,
    data_provider: impl Provider + 'static,
) {
    let mut container = Container::new();
    container.install(data_provider);

    let provided = container.get::<Data>().unwrap();

    assert_eq!(provided, data)
}

#[rstest]
fn test_get_installed_trait_object(test_trait_provider: TestTraitProvider) {
    let mut container = Container::new();
    container.install(test_trait_provider);
    let provided = container.get::<Arc<dyn TestTrait>>().unwrap();

    assert_eq!(provided.hello(), "Hello")
}

#[rstest]
fn test_closure_as_provider(data: Data) {
    let expected = data;
    let mut container = Container::new();
    container.install(move |_: &_| Ok(data));
    let provided = container.get::<Data>().unwrap();

    assert_eq!(provided, expected)
}

#[rstest]
fn test_get_macro_gives_default_without_provider_and_default_available(data: Data) {
    let expected = data;
    let container = Container::new();
    let provided = get!(&container, Data).unwrap();

    assert_eq!(expected, provided)
}

#[rstest]
fn test_get_macro_resolves_default_in_nested_provider_when_provider_missing(
    depends_on_data: DependsOnData,
) {
    let expected = depends_on_data;
    let container = container![];
    let provided: DependsOnData = get!(&container, DependsOnData).unwrap();

    assert_eq!(expected, provided)
}

#[rstest]
fn test_get_macro_resolves_nested_provider(data_provider: impl Provider + 'static) {
    let expected = DependsOnData {
        data: Data::new(2),
        b: 0,
    };
    let container = container![data_provider];
    let provided = get!(&container, DependsOnData).unwrap();

    assert_eq!(expected, provided)
}

#[rstest]
fn test_get_macro_resolves_nested_provider_with_nested_provider(
    data_provider: impl Provider + 'static,
    depends_on_data_provider: impl Provider + 'static,
) {
    let expected = GenericData::new(DependsOnData::new(Data::new(2), 0));

    let container = container![data_provider, depends_on_data_provider];

    let provided = get!(&container, GenericData<DependsOnData>).unwrap();

    assert_eq!(expected, provided)
}

#[rstest]
fn test_get_macro_resolves_dyn_provider(test_trait_provider: impl Provider + 'static) {
    let container = container![test_trait_provider];

    let provided = get!(&container, DependsOnDyn).unwrap();

    assert_eq!(provided.test_trait.hello(), "Hello")
}

#[rstest]
fn test_get_macro_resolves_reference(data: Data) {
    let container = container![ref Box::new(data)];

    let provided = get!(&container, &Data).unwrap();

    assert_eq!(provided, &data)
}