he_di 0.2.1

Dependency Inversion / Dependency Injection / Inversion of control container 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

#![allow(non_snake_case)]

extern crate he_di;
#[macro_use] extern crate he_di_derive;

use he_di::ContainerBuilder;
use he_di::Error as DIError;

trait Foo : ::std::fmt::Debug {
    fn foo(&self) -> String;
}

#[derive(Component, Debug)]
#[interface(Foo)]
struct FooImpl {
    value: String,
    #[inject]
    bar: Box<Bar>,
}

impl Foo for FooImpl {
    fn foo(&self) -> String {
        format!("FooImpl > foo > value = {} ; bar = {}", self.value, self.bar.bar())
    }
}

trait Bar : ::std::fmt::Debug {
    fn bar(&self) -> String;
}

#[derive(Component, Debug)]
#[interface(Bar)]
struct BarImpl {
    bar_value: String,
}

impl Bar for BarImpl {
    fn bar(&self) -> String {
        format!("BarImpl > bar > bar_value = {}", self.bar_value)
    }
}

#[test]
fn resolving_component_without_parameters_should_err() {
    let mut builder = ContainerBuilder::new();
    builder
        .register::<FooImpl>()
        .as_type::<Foo>();
    let mut container = builder.build().unwrap();
    
    let foo = container
        .resolve::<Foo>();

    assert!(foo.is_err());
    if let Err(DIError::ResolveError(err)) = foo {
        assert_eq!(err, "unable to find parameter with name or type for property value");
    } else {
        panic!("unexpected state > foo should be Err");
    }
}

#[test]
fn resolving_component_dependency_without_parameters_should_err() {
    let mut builder = ContainerBuilder::new();
    builder
        .register::<FooImpl>()
        .as_type::<Foo>()
        .with_named_parameter("value", "world is foo".to_string());

    builder
        .register::<BarImpl>()
        .as_type::<Bar>();
    let mut container = builder.build().unwrap();
    
    let foo = container
        .resolve::<Foo>();

    assert!(foo.is_err());
    if let Err(DIError::ResolveError(err)) = foo {
        assert_eq!(err, "unable to resolve component for dependency bar");
    } else {
        panic!("unexpected state > foo should be Err");
    }
}

#[test]
fn resolving_component_dependency_with_parameters_dont_err() {
    let mut builder = ContainerBuilder::new();
    builder
        .register::<FooImpl>()
        .as_type::<Foo>()
        .with_named_parameter("value", "world is foo".to_string());

    builder
        .register::<BarImpl>()
        .as_type::<Bar>();
    let mut container = builder.build().unwrap();
    
    let foo = container
        .with_named_parameter::<Bar, String>("bar_value", "world is bar".to_string())
        .resolve::<Foo>();
    assert_eq!(foo.unwrap().foo(), "FooImpl > foo > value = world is foo ; bar = BarImpl > bar > bar_value = world is bar");
}