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

use crate::{attr_map::NestedAttrMap, ConnectorTestArgs};
use darling::{FromMeta, ToTokens};
use proc_macro::TokenStream;
use quote::quote;
use std::collections::hash_map::Entry;
use syn::{parse_macro_input, parse_quote, AttributeArgs, Item, ItemMod, Meta, NestedMeta};

/// What does this do?
/// Test attributes (like `schema(handler)`, `only`, ...) can be defined on the test (`connector_test`) or on the module.
/// Setting them on the module allows to define defaults that apply to all `connector_test`s in the module.
/// Individual tests can still set their attributes, which will take precedence and overwrite the defaults.
/// This macro merges the attributes of the module and writes them to the test function.
/// Example: If the following test suite definition is given:
/// ```ignore
/// #[test_suite(schema(handler), exclude(SqlServer))]
/// mod test_mod {
///     #[connector_test]
///     async fn test_a() { ... }
///
///     #[connector_test(suite = "other_tests", schema(other_handler), only(Postgres)]
///     async fn test_b() { ... }
/// }
/// ```
/// Will be rewritten to:
/// ```ignore
/// mod test_mod {
///     #[connector_test(suite = "test_mod", schema(handler), exclude(SqlServer))]
///     async fn test_a() { ... }
///
///     #[connector_test(suite = "other_tests", schema(other_handler), only(Postgres)]
///     async fn test_b() { ... }
/// }
/// ```
/// As can be seen with the example, there are some rules regarding `only` and `exclude`, but the gist is that
/// only one connector definition can be present, and since test_b already defines a connector tag rule, this one
/// takes precedence. Same with the `suite` and `schema` attributes - they overwrite the defaults of the mod.
/// A notable expansion is that the name of the test mod is added as `suite = <name>` to the tests.
pub fn test_suite_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
    // Validate input by simply parsing it, which will point out invalid fields and connector names etc.
    let attributes_meta: syn::AttributeArgs = parse_macro_input!(attr as AttributeArgs);
    let args = ConnectorTestArgs::from_list(&attributes_meta);
    let args = match args {
        Ok(args) => args,
        Err(err) => return err.write_errors().into(),
    };

    if let Err(err) = args.validate(true) {
        return err.write_errors().into();
    };
    // end validation

    let mut test_module = parse_macro_input!(input as ItemMod);
    let module_name = test_module.ident.to_string();
    let mut module_attrs = NestedAttrMap::from(&attributes_meta);

    let suite_meta: Meta = parse_quote! { suite = #module_name };
    let suite_nested_meta = NestedMeta::from(suite_meta);

    if let Entry::Vacant(entry) = module_attrs.entry("suite".to_owned()) {
        entry.insert(suite_nested_meta);
    };

    if let Some((_, ref mut items)) = test_module.content {
        add_module_imports(items);

        for item in items {
            if let syn::Item::Fn(ref mut f) = item {
                // Check if the function is marked as `connector_test` or `relation_link_test`.
                if let Some(ref mut attr) = f.attrs.iter_mut().find(|attr| match attr.path.get_ident() {
                    Some(ident) => &ident.to_string() == "connector_test" || &ident.to_string() == "relation_link_test",
                    None => false,
                }) {
                    let meta = attr.parse_meta().expect("Invalid attribute meta.");
                    let fn_attrs = match meta {
                        // `connector_test` attribute has no futher attributes.
                        Meta::Path(_) => NestedAttrMap::default(),

                        // `connector_test` attribute has a list of attributes.
                        Meta::List(l) => NestedAttrMap::from(&l.nested.clone().into_iter().collect::<Vec<_>>()),

                        // Not supported
                        Meta::NameValue(_) => unimplemented!("Unexpected NameValue list for function attribute."),
                    };

                    let final_attrs = fn_attrs.merge(&module_attrs);

                    // Replace attr.tokens
                    attr.tokens = quote! { (#final_attrs) };
                }
            }
        }
    }

    test_module.into_token_stream().into()
}

fn add_module_imports(items: &mut Vec<Item>) {
    items.reverse();
    items.push(Item::Use(parse_quote! { use super::*; }));
    items.reverse();
}