injectorpp 0.5.1

Injectorpp is a powerful tool designed to facilitate the writing of unit tests without the need to introduce traits solely for testing purposes. It streamlines the testing process by providing a seamless and efficient way to abstract dependencies, ensuring that your code remains clean and maintainable.
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

use injectorpp::interface::injector::*;
use std::{fmt::Display, path::Path};

fn foo() {
    println!("foo");
}

async fn simple_async_func_u32_add_one(x: u32) -> u32 {
    x + 1
}

pub fn return_string() -> String {
    "Hello, world!".to_string()
}

fn complex_generic_multiple_types_func<A: Display, B: Display, C: Display>(
    _a: A,
    _b: B,
    _c: C,
) -> String {
    "Original value".to_string()
}

#[test]
#[should_panic(
    expected = "Signature mismatch: will_return_boolean requires a function returning bool"
)]
fn test_will_return_boolean_mismatched_type_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called(injectorpp::func!(fn (return_string)() -> String))
        .will_return_boolean(true);
}

#[test]
#[should_panic(expected = "Signature mismatch")]
fn test_will_execute_when_function_signature_mismatch_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called(injectorpp::func!(fn (Path::exists)(&Path) -> bool))
        .will_execute(injectorpp::fake!(
            func_type: fn(_path: &str) -> bool,
            returns: true
        ));
}

#[test]
#[should_panic(expected = "Signature mismatch")]
fn test_will_execute_when_generic_function_multiple_types_signature_mismatch_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called(injectorpp::func!(
            fn (complex_generic_multiple_types_func)(&'static str, bool, i32) -> String
        ))
        .will_execute(injectorpp::fake!(
            func_type: fn(a: &str, b: bool) -> String,
            when: a == "abc" && b,
            returns: "Fake value".to_string(),
            times: 1
        ));
}

#[test]
#[should_panic(expected = "Pointer must not be null")]
fn test_will_execute_null_pointer_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called(injectorpp::func!(fn (foo)()))
        .will_execute((
            unsafe {
                FuncPtr::new(std::ptr::null(), {
                    let f: fn() = foo;
                    std::any::type_name_of_val(&f)
                })
            },
            CallCountVerifier::Dummy,
        ));
}

#[tokio::test]
#[should_panic(expected = "Pointer must not be null")]
async fn test_will_return_async_null_pointer_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called_async(injectorpp::async_func!(
            simple_async_func_u32_add_one(u32::default()),
            u32
        ))
        .will_return_async(unsafe { FuncPtr::new(std::ptr::null(), std::any::type_name::<u32>()) });
}

#[tokio::test]
#[should_panic(expected = "Signature mismatch")]
async fn test_will_return_async_mismatched_type_should_panic() {
    let mut injector = InjectorPP::new();
    injector
        .when_called_async(injectorpp::async_func!(
            simple_async_func_u32_add_one(u32::default()),
            u32
        ))
        .will_return_async(injectorpp::async_return!("Test Value".to_string(), String));
}