traced-test 1.0.4

this crate lets us use #[traced_test] to automatically configure sane default tracing for a rust test
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

// ---------------- [ File: src/test_builder.rs ]
crate::ix!();

pub enum Test {
    Asynchronous(AsynchronousTest),
    AsynchronousShouldFail(AsynchronousTestShouldFail),
    Synchronous(SynchronousTest),
    SynchronousShouldFail(SynchronousTestShouldFail),
}

pub struct TestBuilder {
    return_type:    Option<Box<syn::Type>>,
    original_block: Option<Box<syn::Block>>,
    should_fail:    Option<ShouldFailAttr>,
    is_async:       bool,
}

impl TestBuilder {

    pub fn new() -> Self {
        Self {
            return_type:    None,
            original_block: None,
            should_fail:    None,
            is_async:       false,
        }
    }

    pub fn return_type(mut self, return_type: Option<Box<syn::Type>>) -> Self {
        self.return_type = return_type;
        self
    }

    pub fn original_block(mut self, block: &syn::Block) -> Self {
        self.original_block = Some(Box::new(block.clone()));
        self
    }

    pub fn async_test(mut self) -> Self {
        self.is_async = true;
        self
    }

    pub fn should_fail(mut self, should_fail: ShouldFailAttr) -> Self {
        self.should_fail = Some(should_fail);
        self
    }

    pub fn build(self) -> Result<Test, TracedTestError> {

        let original_block = self.original_block.ok_or(TracedTestError::MissingOriginalBlock)?;
        let return_type    = self.return_type;

        let test = match (self.is_async, self.should_fail) {
            (false, None) => {
                // Use the builder for SynchronousTest
                let synchronous_test = SynchronousTest::builder()
                    .return_type(return_type)
                    .original_block(original_block)
                    .build()?;
                Test::Synchronous(synchronous_test)
            }
            (false, Some(should_fail)) => {
                // Use the builder for SynchronousTestShouldFail
                let synchronous_test_should_fail = SynchronousTestShouldFail::builder()
                    .return_type(return_type)
                    .original_block(original_block)
                    .should_fail(should_fail)
                    .build()?;
                Test::SynchronousShouldFail(synchronous_test_should_fail)
            }
            (true, None) => {
                // Use the builder for AsynchronousTest
                let asynchronous_test = AsynchronousTest::builder()
                    .return_type(return_type)
                    .original_block(original_block)
                    .build()?;
                Test::Asynchronous(asynchronous_test)
            }
            (true, Some(should_fail)) => {
                // Use the builder for AsynchronousTestShouldFail
                let asynchronous_test_should_fail = AsynchronousTestShouldFail::builder()
                    .return_type(return_type)
                    .original_block(original_block)
                    .should_fail(should_fail)
                    .build()?;
                Test::AsynchronousShouldFail(asynchronous_test_should_fail)
            }
        };

        Ok(test)
    }
}

impl WrapBlock for Test {

    fn wrap_block(&self, generator: &TracedTestGenerator) -> TokenStream2 {
        match self {
            Test::Synchronous(test)             => test.wrap_block(generator),
            Test::SynchronousShouldFail(test)   => test.wrap_block(generator),
            Test::Asynchronous(test)            => test.wrap_block(generator),
            Test::AsynchronousShouldFail(test)  => test.wrap_block(generator),
        }
    }
}