sealed_test_derive 1.1.0

A procmacro attribute to run your test in an isolated environment
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

use syn::{
    bracketed, parenthesized,
    parse::{Parse, ParseStream},
    Expr, LitStr, Token,
};

pub struct SealedTestAttributes {
    pub files: Vec<String>,
    pub env: Vec<EnvVar>,
    pub before: Option<Expr>,
    pub after: Option<Expr>,
}

pub struct EnvVar {
    pub name: String,
    pub value: String,
}

impl Parse for EnvVar {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let content;
        parenthesized!(content in input);
        let name = content.parse::<LitStr>()?.value();
        let _ = content.parse::<Token!(,)>()?;
        let value = content.parse::<LitStr>()?.value();
        Ok(Self { name, value })
    }
}

impl Parse for SealedTestAttributes {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut attributes = SealedTestAttributes {
            files: vec![],
            env: vec![],
            before: None,
            after: None,
        };

        while let Ok(ident) = input.parse::<syn::Ident>() {
            input.parse::<Token!(=)>()?;

            match ident.to_string().as_str() {
                "files" => attributes.files = Self::parse_files(input)?,
                "env" => attributes.env = Self::parse_env(input)?,
                "before" => attributes.before = Some(input.parse::<Expr>()?),
                "after" => attributes.after = Some(input.parse::<Expr>()?),
                other => panic!(
                    "unexpected attribute {}, use 'files', 'env', 'setup' or 'teardown'",
                    other
                ),
            }

            if input.peek(Token!(,)) {
                input.parse::<Token!(,)>()?;
            }
        }

        Ok(attributes)
    }
}

impl SealedTestAttributes {
    fn parse_files(input: ParseStream) -> syn::Result<Vec<String>> {
        let content;
        bracketed!(content in input);

        let mut files = vec![];

        while let Ok(file) = content.parse::<LitStr>() {
            files.push(file.value());
            if !content.is_empty() {
                content.parse::<Token!(,)>()?;
            }
        }

        Ok(files)
    }

    fn parse_env(input: ParseStream) -> syn::Result<Vec<EnvVar>> {
        let content;
        bracketed!(content in input);

        let mut env_vars = vec![];

        while let Ok(env_var) = content.parse::<EnvVar>() {
            env_vars.push(env_var);
            if !content.is_empty() {
                content.parse::<Token!(,)>()?;
            }
        }

        Ok(env_vars)
    }
}