yadir 0.3.2

Yet Another Dependency Injection Registry 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
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
151
152

//! # yadir
//!
//! `yadir` is yet another simple dependency injection registry for Rust.

pub mod core;
pub mod macros;

#[cfg(feature = "derive")]
extern crate yadir_derive;

#[cfg(feature = "derive")]
pub use yadir_derive::DIBuilder;

#[cfg(test)]
mod tests {
    use crate::core::contracts::DIBuilder;
    use crate::core::primitives::{DIManager, DIObj, Lifetime};
    use crate::{deps, let_deps};
    use async_trait::async_trait;
    use claim::assert_some;
    use dyn_clone::{clone_trait_object, DynClone};
    use uuid::Uuid;
    use yadir_derive::DIBuilder;

    clone_trait_object!(Printer);
    clone_trait_object!(Writer);

    trait Printer: Sync + Send + DynClone {
        fn print(&self) -> String;
    }

    trait Writer: Sync + Send + DynClone {
        fn write(&self) -> String;
    }

    #[derive(Clone, DIBuilder)]
    #[build_as(Box<dyn Printer>)]
    struct Bar;

    impl Printer for Bar {
        fn print(&self) -> String {
            "bar".to_string()
        }
    }

    #[derive(Clone, DIBuilder)]
    #[build_as(Box<dyn Writer>)]
    struct Baz;

    impl Writer for Baz {
        fn write(&self) -> String {
            "baz".to_string()
        }
    }

    #[derive(Clone, DIBuilder)]
    #[build_method("new")]
    struct Foo {
        id: Uuid,
        #[deps]
        printer: Box<dyn Printer>,
        #[deps]
        writer: Box<dyn Writer>,
    }

    impl Foo {
        fn new(printer: Box<dyn Printer>, writer: Box<dyn Writer>) -> Self {
            let id = Uuid::new_v4();
            Self {
                id,
                printer,
                writer,
            }
        }

        fn print(&self) -> String {
            format!("foo {} {}", self.printer.print(), self.writer.write())
        }

        fn id(&self) -> Uuid {
            self.id
        }
    }

    #[tokio::test]
    async fn test_di_manager_for_deps_transient_lifetimes() {
        let mut manager = DIManager::default();

        manager
            .register::<Bar>(Some(Lifetime::Transient))
            .await
            .register::<Baz>(Some(Lifetime::Transient))
            .await
            .register::<Foo>(Some(Lifetime::Transient))
            .await;

        let foo1 = manager.resolve::<Foo>().await;
        assert_some!(foo1.clone());

        let foo1 = foo1.unwrap().extract();
        assert_eq!(foo1.print(), "foo bar baz");

        let foo2 = manager.resolve::<Foo>().await;
        assert_some!(foo2.clone());

        let foo2 = foo2.unwrap().extract();
        assert_eq!(foo2.print(), "foo bar baz");

        assert_ne!(foo1.id(), foo2.id());
    }

    #[tokio::test]
    async fn test_di_manager_for_deps_singleton_lifetimes() {
        let mut manager = DIManager::default();

        manager
            .register::<Bar>(Some(Lifetime::Transient))
            .await
            .register::<Baz>(Some(Lifetime::Transient))
            .await
            .register::<Foo>(Some(Lifetime::Singleton))
            .await;

        let foo1 = manager.resolve::<Foo>().await;
        assert_some!(foo1.clone());

        let foo1 = foo1.unwrap().extract();
        assert_eq!(foo1.print(), "foo bar baz");

        let foo2 = manager.resolve::<Foo>().await;
        assert_some!(foo2.clone());

        let foo2 = foo2.unwrap().extract();
        assert_eq!(foo2.print(), "foo bar baz");

        assert_eq!(foo1.id(), foo2.id());
    }

    #[tokio::test]
    async fn test_di_manager_for_not_resolving_unregistered_deps() {
        let mut manager = DIManager::default();

        manager
            .register::<Baz>(Some(Lifetime::Transient))
            .await
            .register::<Bar>(Some(Lifetime::Transient))
            .await;

        let foo = manager.resolve::<Foo>().await;
        assert!(foo.is_none());
    }
}