feature: Macro for fixture testing (#1226)

testing_macros:
 - Add `#[fixture]` for easier fixture testing

Author: kdy1

.github/workflows/integration.yml

@@ -28,7 +28,7 @@ jobs:
       - name: Set platform name
         run: |
           export NODE_PLATFORM_NAME=$(node -e "console.log(require('os').platform())")
-          echo "name=PLATFORM_NAME::$NODE_PLATFORM_NAME" >> $GITHUB_ENV
+          echo "PLATFORM_NAME=$NODE_PLATFORM_NAME" >> $GITHUB_ENV
         shell: bash
 
       - name: Prepare

.github/workflows/publish-node.yml

@@ -129,7 +129,7 @@ jobs:
           node-version: 12
 
       - name: Set release name
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}"" >> $GITHUB_ENV
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
 
       # Do not cache node_modules, or yarn workspace links broken
       - name: Install dependencies

.travis.yml

@@ -43,7 +43,7 @@ script:
   - true
 
 before_deploy:
-  - CARGO_TARGET_DIR=$HOME/cargo-target cargo doc --color always
+  - CARGO_TARGET_DIR=$HOME/cargo-target cargo doc --all --exclude node --color always
 
 deploy:
   local_dir: $HOME/cargo-target/doc

testing/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2018"
 license = "Apache-2.0/MIT"
 name = "testing"
 repository = "https://github.com/swc-project/swc.git"
-version = "0.10.1"
+version = "0.10.2"
 
 [dependencies]
 ansi_term = "0.12.1"
@@ -17,3 +17,4 @@ once_cell = "1"
 pretty_assertions = "0.6.1"
 regex = "1"
 swc_common = {version = "0.10.0", path = "../common", features = ["tty-emitter"]}
+testing_macros = {version = "0.1", path = "./macros"}

testing/macros/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+authors = ["강동윤 <kdy1997.dev@gmail.com>"]
+description = "General purpose testing macros"
+documentation = "https://swc.rs/rustdoc/testing_macros/"
+edition = "2018"
+license = "Apache-2.0/MIT"
+name = "testing_macros"
+repository = "https://github.com/swc-project/swc.git"
+version = "0.1.0"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+anyhow = "1"
+glob = "0.3"
+pmutil = "0.5.1"
+proc-macro2 = "1.0.24"
+quote = "1"
+regex = "1"
+relative-path = "1.3.2"
+syn = {version = "1", features = ["fold", "parsing", "full", "extra-traits"]}

testing/macros/README.md

@@ -0,0 +1,3 @@
+# testing_macros
+
+Please refer to [rustdoc](https://swc.rs/rustdoc/testing_macros)

testing/macros/src/fixture.rs

@@ -0,0 +1,174 @@
+use anyhow::{Context, Error};
+use glob::glob;
+use pmutil::q;
+use proc_macro2::{SourceFile, Span};
+use regex::Regex;
+use relative_path::RelativePath;
+use syn::{
+    parse::{Parse, ParseStream},
+    Ident, ItemFn, Lit, LitStr, Meta, NestedMeta, Token,
+};
+
+pub struct Config {
+    pattern: String,
+    exclude_patterns: Vec<Regex>,
+}
+
+impl Parse for Config {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        fn update(c: &mut Config, meta: Meta) {
+            match &meta {
+                Meta::List(list) => {
+                    if list
+                        .path
+                        .get_ident()
+                        .map(|i| i.to_string() == "exclude")
+                        .unwrap_or(false)
+                    {
+                        //
+                        macro_rules! fail {
+                            () => {{
+                                fail!("invalid input to the attribute")
+                            }};
+                            ($inner:expr) => {{
+                                panic!(
+                                    "{}\nnote: exclude() expectes one or more comma-separated \
+             regular expressions, like exclude(\".*\\\\.d\\\\.ts\") or \
+             exclude(\".*\\\\.d\\\\.ts\", \".*\\\\.tsx\")",
+                                    $inner
+                                )
+                            }};
+                        }
+
+                        if list.nested.is_empty() {
+                            fail!("empty exlclude()")
+                        }
+
+                        for token in list.nested.iter() {
+                            match token {
+                                NestedMeta::Meta(_) => fail!(),
+                                NestedMeta::Lit(lit) => {
+                                    let lit = match lit {
+                                        Lit::Str(v) => v.value(),
+                                        _ => fail!(),
+                                    };
+                                    c.exclude_patterns.push(Regex::new(&lit).unwrap_or_else(
+                                        |err| {
+                                            fail!(format!(
+                                                "failed to parse regex: {}\n{}",
+                                                lit, err
+                                            ))
+                                        },
+                                    ));
+                                }
+                            }
+                        }
+
+                        return;
+                    }
+                }
+                _ => {}
+            }
+
+            let expected = r#"#[fixture("fixture/**/*.ts", exclude("*\.d\.ts"))]"#;
+
+            unimplemented!(
+                "Exected something like {}\nGot wrong meta tag: {:?}",
+                expected,
+                meta,
+            )
+        }
+
+        let pattern: LitStr = input.parse()?;
+        let pattern = pattern.value();
+
+        let mut config = Self {
+            pattern,
+            exclude_patterns: vec![],
+        };
+
+        let comma: Option<Token![,]> = input.parse()?;
+        if comma.is_some() {
+            let meta: Meta = input.parse()?;
+            update(&mut config, meta);
+        }
+
+        Ok(config)
+    }
+}
+
+pub fn expand(test_file: &SourceFile, callee: &Ident, attr: Config) -> Result<Vec<ItemFn>, Error> {
+    let base_dir = test_file.path().parent().unwrap().to_path_buf();
+    let resolved_path = RelativePath::new(&attr.pattern).to_path(&base_dir);
+    let pattern = resolved_path.to_string_lossy();
+
+    let paths =
+        glob(&pattern).with_context(|| format!("glob failed for whole path: `{}`", pattern))?;
+    let mut test_fns = vec![];
+
+    'add: for path in paths {
+        let path = path.with_context(|| format!("glob failed for file"))?;
+        let path = path.strip_prefix(&base_dir).with_context(|| {
+            format!(
+                "Failed to strip prefix `{}` from `{}`",
+                base_dir.display(),
+                path.display()
+            )
+        })?;
+        let path_str = path.to_string_lossy();
+        // Skip excluded files
+        for pattern in &attr.exclude_patterns {
+            if pattern.is_match(&path_str) {
+                continue 'add;
+            }
+        }
+
+        let ignored = path_str.starts_with(".") || path_str.contains("/.");
+        let test_name = format!(
+            "{}_{}",
+            callee,
+            path_str
+                .replace("/", "__")
+                .replace(".", "_")
+                .replace("-", "_")
+        )
+        .replace("___", "__");
+        let test_ident = Ident::new(&test_name, Span::call_site());
+
+        let mut f = q!(
+            Vars {
+                test_ident,
+                path_str,
+                callee
+            },
+            {
+                #[test]
+                #[ignore]
+                fn test_ident() {
+                    callee(::std::path::PathBuf::from(path_str));
+                }
+            }
+        )
+        .parse::<ItemFn>();
+
+        if !ignored {
+            f.attrs.retain(|attr| {
+                match attr.path.get_ident() {
+                    Some(name) => {
+                        if name == "ignore" {
+                            return false;
+                        }
+                    }
+                    None => {}
+                }
+
+                true
+            });
+            //
+        }
+
+        test_fns.push(f);
+    }
+
+    Ok(test_fns)
+}

testing/macros/src/lib.rs

@@ -0,0 +1,71 @@
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::ToTokens;
+use syn::ItemFn;
+
+mod fixture;
+
+/// Create tests from files.
+///
+/// # Why
+///
+/// If you create test dynamically, running a specific test become very
+/// cumbersome.
+///
+/// For example, if you use `test` crate with nightly, you can't use `cargo test
+/// foo` to run tests with name containing `foo`. Instead, you have to implement
+/// your own ignoring logic
+///
+///
+/// # Usage
+///
+/// If you want to load all typescript files from `pass`
+///
+/// ```rust,ignore
+/// 
+/// #[fixture("pass/**/*.{ts,tsx}")]
+/// fn pass(file: PathBuf) {
+///     // test by reading file
+/// }
+/// ```
+///
+/// # Return value
+///
+/// The function is allowed to return `Result` on error. If it's the case
+///
+///
+/// ## Ignoreing a test
+///
+/// If the path to the file contains a component starts with `.` (dot), it will
+/// be ignore. This convention is widely used in many projects (including other
+/// languages), as a file or a directory starting with `.` means hidden file in
+/// unix system.
+///
+/// Note that they are added as a test `#[ignore]`, so you can use
+/// `cargo test -- --ignored` or `cargo test -- --include-ignored` to run those
+/// tests.
+///
+///
+/// # Roadmap
+///
+/// - Support async function
+#[proc_macro_attribute]
+pub fn fixture(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let item: ItemFn = syn::parse(item).expect("failed to parse input as a function item");
+    let config: self::fixture::Config =
+        syn::parse(attr).expect("failed to parse input passed to #[fixture]");
+
+    let file = Span::call_site().source_file();
+
+    let cases = self::fixture::expand(&file, &item.sig.ident, config).unwrap();
+
+    let mut output = proc_macro2::TokenStream::new();
+
+    for case in cases {
+        case.to_tokens(&mut output);
+    }
+
+    item.to_tokens(&mut output);
+
+    output.into()
+}

testing/macros/tests/ignore/.ignored/innocent.ts

@@ -0,0 +1 @@
+

testing/macros/tests/ignore/a.ts

@@ -0,0 +1,15 @@
+use std::path::PathBuf;
+use testing_macros::fixture;
+
+#[fixture("simple/*.ts")]
+fn simple(_path: PathBuf) {}
+
+#[fixture("ignore/**/*.ts")]
+fn ignored(_path: PathBuf) {}
+
+#[fixture("simple/**/*.ts")]
+#[fixture("simple/**/*.tsx")]
+fn multiple(_path: PathBuf) {}
+
+#[fixture("simple/**/*", exclude(".*\\.tsx", ".*.d\\.ts"))]
+fn exlucde(_path: PathBuf) {}

testing/macros/tests/ignore/b.ts

@@ -18,6 +18,7 @@ use swc_common::{
     sync::Lrc,
     FilePathMapping, SourceMap,
 };
+pub use testing_macros::fixture;
 
 #[macro_use]
 mod macros;