minfac 0.1.5

Lightweight Inversion Of Control
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

use minfac::{self, AllRegistered, BuildError, Registered, ServiceCollection};

#[test]
fn handle_cyclic_references() {
    let mut col = ServiceCollection::new();
    col.with::<Registered<i64>>().register(|_| 0i16);
    col.with::<Registered<i16>>().register(|_| 0i32);
    col.with::<Registered<i32>>().register(|_| 0i64);

    let err = col.build().expect_err("Expected to return error");
    let msg = match err {
        BuildError::CyclicDependency { description, .. } => description,
        _ => panic!("Expected BuildError::CyclicDependency"),
    };
    assert!(msg.contains("i32 -> i16"));
    assert!(msg.contains("i16 -> i64"));
    assert!(msg.contains("i64 -> i32"));
}

#[test]
fn one_of_multiple_dependencies_asks_for_dependent_should_trigger_cyclic_dependency() {
    let mut col = ServiceCollection::new();
    col.register(|| 0i32);
    col.with::<Registered<i64>>().register(|_| 1i32);
    col.register(|| 2i32);

    col.with::<AllRegistered<i32>>().register(|_| 42i64);
    let error = col.build().expect_err("Expected to return error");
    let msg = if let BuildError::CyclicDependency { description, .. } = error {
        description
    } else {
        panic!("Expected error");
    };

    assert!(msg.contains("-> minfac::service_provider::ServiceIterator<i32"));
    assert!(msg.contains("-> i64"));
}

#[test]
fn service_a_depends_on_other_which_has_reference_to_typeof_a_but_a_is_not_last_registered() {
    let mut col = ServiceCollection::new();
    col.with::<Registered<i32>>().register(|_| 0i64);
    col.with::<Registered<i64>>().register(|_| 1i32);
    col.register(|| 2i32);

    col.build()
        .expect("Expecting constellation to be resolvable");
}

#[test]
fn only_second_depend() {
    let mut col = ServiceCollection::new();
    col.with::<(Registered<u8>, Registered<i32>)>()
        .register(|_| 0i64);
    col.with::<(Registered<u8>, Registered<i64>)>()
        .register(|_| 1i32);
    col.register(|| 42u8);
    col.build()
        .expect_err("Expecting constellation not to be resolvable");
}

#[test]
fn depend_on_itself() {
    let mut col = ServiceCollection::new();
    col.register_with((|Registered(x): Registered<i32>| x) as fn(_) -> _);
    match col.build() {
        Err(BuildError::CyclicDependency { description, .. }) => {
            assert_eq!("i32 -> i32", description);
        }
        e => panic!("Unexpected result {e:?}"),
    }
}