[yaml runner] sort module imports, allow bypassing test file generation using '*' in skip.yml

Author: swallez

yaml_test_runner/src/generator.rs

@@ -25,7 +25,6 @@ use regex::Regex;
 use semver::Version;
 use serde::Deserialize;
 use std::{
-    borrow::Borrow,
     collections::{BTreeMap, HashSet},
     fs,
     fs::{File, OpenOptions},
@@ -170,16 +169,11 @@ impl<'a> YamlTests<'a> {
 
     /// Whether the test should be skipped
     fn skip_test(&self, name: &str) -> bool {
-        if self.skip.tests.contains_key(self.path.as_str()) {
-            let tests = self.skip.tests.get(self.path.as_str());
-
-            return match tests {
-                Some(t) => t.contains(name.to_string().borrow()),
-                None => true,
-            };
+        if let Some(tests) = self.skip.tests.get(&self.path) {
+            tests.iter().any(|n| n == name || n == "*")
+        } else {
+            false
         }
-
-        false
     }
 
     fn fn_impls(
@@ -490,13 +484,13 @@ pub fn generate_tests_from_yaml(
         }
     }
 
-    write_mod_files(&generated_dir)?;
+    write_mod_files(&generated_dir, true)?;
 
     Ok(())
 }
 
 /// Writes a mod.rs file in each generated directory
-fn write_mod_files(generated_dir: &PathBuf) -> Result<(), failure::Error> {
+fn write_mod_files(generated_dir: &PathBuf, toplevel: bool) -> Result<(), failure::Error> {
     if !generated_dir.exists() {
         fs::create_dir(generated_dir)?;
     }
@@ -505,30 +499,34 @@ fn write_mod_files(generated_dir: &PathBuf) -> Result<(), failure::Error> {
     let mut mods = vec![];
     for path in paths {
         if let Ok(entry) = path {
-            let file_type = entry.file_type().unwrap();
             let path = entry.path();
             let name = path.file_stem().unwrap().to_string_lossy();
 
-            let is_tests_common_dir =
-                name.as_ref() == "common" && path.parent().unwrap().file_name().unwrap() == "tests";
-
-            if name.as_ref() != "mod" {
-                if is_tests_common_dir {
-                    mods.push("#[macro_use]".to_string());
-                }
-
+            if name != "mod" {
                 mods.push(format!(
                     "pub mod {};",
                     path.file_stem().unwrap().to_string_lossy()
                 ));
             }
 
-            if file_type.is_dir() && !is_tests_common_dir {
-                write_mod_files(&entry.path())?;
+            if path.is_dir() && !(toplevel && name == "common") {
+                write_mod_files(&entry.path(), false)?;
             }
         }
     }
 
+    // Make sure we have a stable output
+    mods.sort();
+
+    if toplevel {
+        // The "common" module must appear first so that its macros are parsed before the
+        // compiler visits other modules, otherwise we'll have "macro not found" errors.
+        mods.retain(|name| name != "pub mod common;");
+        mods.insert(0, "#[macro_use]".into());
+        mods.insert(1, "pub mod common;".into());
+        mods.insert(2, "".into());
+    }
+
     let mut path = generated_dir.clone();
     path.push("mod.rs");
     let mut file = File::create(&path)?;
@@ -562,6 +560,14 @@ fn write_test_file(
     relative_path: &Path,
     generated_dir: &PathBuf,
 ) -> Result<(), failure::Error> {
+    if test.skip_test("*") {
+        info!(
+            r#"skipping all tests in {} because it's included in skip.yml"#,
+            test.path,
+        );
+        return Ok(());
+    }
+
     let mut path = test_file_path(relative_path)?;
     path = generated_dir.join(path);
     path.set_extension("rs");

yaml_test_runner/src/step/do.rs

@@ -291,7 +291,7 @@ impl ApiCall {
         // arguments for the API call
         for (k, v) in hash.iter() {
             match k.as_str().unwrap() {
-                "body" => body = Self::generate_body(endpoint, v),
+                "body" => body = Self::generate_body(endpoint, v)?,
                 "ignore" => {
                     ignore = match v.as_i64() {
                         Some(i) => Some(i as u16),
@@ -853,9 +853,9 @@ impl ApiCall {
     /// When reading a body from the YAML test, it'll be converted to a Yaml variant,
     /// usually a Hash. To get the JSON representation back requires converting
     /// back to JSON
-    fn generate_body(endpoint: &ApiEndpoint, v: &Yaml) -> Option<Tokens> {
+    fn generate_body(endpoint: &ApiEndpoint, v: &Yaml) -> Result<Option<Tokens>, failure::Error> {
         match v {
-            Yaml::Null => None,
+            Yaml::Null => Ok(None),
             Yaml::String(s) => {
                 let json = {
                     let json = replace_set(s);
@@ -884,10 +884,10 @@ impl ApiCall {
                             quote! { JsonBody::from(json!(#ident)) }
                         })
                         .collect();
-                    Some(quote!(.body(vec![#(#values),*])))
+                    Ok(Some(quote!(.body(vec![#(#values),*]))))
                 } else {
                     let ident = syn::Ident::from(json);
-                    Some(quote!(.body(json!{#ident})))
+                    Ok(Some(quote!(.body(json!{#ident}))))
                 }
             }
             _ => {
@@ -898,7 +898,7 @@ impl ApiCall {
                 }
 
                 if endpoint.supports_nd_body() {
-                    let values: Vec<serde_json::Value> = serde_yaml::from_str(&s).unwrap();
+                    let values: Vec<serde_json::Value> = serde_yaml::from_str(&s)?;
                     let json: Vec<Tokens> = values
                         .iter()
                         .map(|value| {
@@ -915,15 +915,15 @@ impl ApiCall {
                             }
                         })
                         .collect();
-                    Some(quote!(.body(vec![ #(#json),* ])))
+                    Ok(Some(quote!(.body(vec![ #(#json),* ]))))
                 } else {
-                    let value: serde_json::Value = serde_yaml::from_str(&s).unwrap();
-                    let mut json = serde_json::to_string_pretty(&value).unwrap();
+                    let value: serde_json::Value = serde_yaml::from_str(&s)?;
+                    let mut json = serde_json::to_string_pretty(&value)?;
                     json = replace_set(json);
                     json = replace_i64(json);
                     let ident = syn::Ident::from(json);
 
-                    Some(quote!(.body(json!{#ident})))
+                    Ok(Some(quote!(.body(json!{#ident}))))
                 }
             }
         }