test-context-macros 0.5.8

Macro crate for test-context
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

use quote::quote;
use syn::FnArg;

#[derive(Clone)]
pub struct ContextArg {
    /// The original pattern (left side of a `pattern: type` expression).
    pub pattern: syn::Pat,
    /// The mode in which the context was passed to the test function.
    pub mode: ContextArgMode,
}

#[derive(PartialEq, Eq, Debug, Clone, Copy)]
pub enum ContextArgMode {
    /// The argument was passed as an owned value (`ContextType`). Only valid with `skip_teardown`.
    Owned,
    /// The argument was passed as an immutable reference (`&ContextType`).
    Reference,
    /// The argument was passed as a mutable reference (`&mut ContextType`).
    MutableReference,
}

impl ContextArgMode {
    pub fn is_owned(&self) -> bool {
        match self {
            ContextArgMode::Owned => true,
            ContextArgMode::Reference => false,
            ContextArgMode::MutableReference => false,
        }
    }
}

#[derive(Clone)]
pub enum TestArg {
    Any(FnArg),
    Context(ContextArg),
}

impl TestArg {
    pub fn parse_arg_with_expected_context(arg: FnArg, expected_context_type: &syn::Type) -> Self {
        let pat_type = match arg {
            FnArg::Typed(pat_type) => pat_type,
            FnArg::Receiver(_) => return TestArg::Any(arg),
        };

        // fn example(pattern: arg_type)
        let arg_type = &*pat_type.ty;
        let pattern = &*pat_type.pat;

        // Check for mutable/immutable reference
        if let syn::Type::Reference(type_ref) = arg_type
            && types_equal(&type_ref.elem, expected_context_type)
        {
            let mode = if type_ref.mutability.is_some() {
                ContextArgMode::MutableReference
            } else {
                ContextArgMode::Reference
            };

            return TestArg::Context(ContextArg {
                pattern: pattern.to_owned(),
                mode,
            });
        }

        if types_equal(arg_type, expected_context_type) {
            return TestArg::Context(ContextArg {
                pattern: pattern.to_owned(),
                mode: ContextArgMode::Owned,
            });
        }

        TestArg::Any(FnArg::Typed(pat_type))
    }
}

fn types_equal(a: &syn::Type, b: &syn::Type) -> bool {
    if let (syn::Type::Path(a_path), syn::Type::Path(b_path)) = (a, b) {
        return a_path.path.segments.last().unwrap().ident
            == b_path.path.segments.last().unwrap().ident;
    }
    quote!(#a).to_string() == quote!(#b).to_string()
}