Refactor Conformance Test Generation for better test logic reuse and shallower test tree. (#205)

* Refactor test/module escaping
* Encapsulate Writer, add 'generated' banner, stop generating top level
* Refactor to use provided `pass_*` and `fail_*` testing functions
* Add ability to collapse generation at a given module depth

Author: jpschorr

partiql-conformance-test-generator/src/generator.rs

@@ -1,7 +1,7 @@
 use crate::schema::spec::{Assertion, Namespace, TestCase, TestDocument};
 use crate::schema::structure::{TestDir, TestEntry, TestFile, TestRoot};
 
-use crate::StringExt;
+use crate::util::Escaper;
 use codegen::{Function, Module, Scope};
 use std::collections::HashMap;
 
@@ -58,12 +58,8 @@ impl Generator {
     }
 
     pub fn generate(mut self, root: TestRoot) -> miette::Result<TestModule> {
-        let TestRoot { fail, success } = root;
-        for f in fail {
-            self.test_entry(f)
-        }
-        for s in success {
-            self.test_entry(s)
+        for entry in root.0 {
+            self.test_entry(entry)
         }
 
         Ok(self.result)
@@ -72,7 +68,7 @@ impl Generator {
     fn test_entry(&mut self, entry: TestEntry) {
         match entry {
             TestEntry::Dir(TestDir { dir_name, contents }) => {
-                self.curr_path.push(dir_name);
+                self.curr_path.push(dir_name.escape_path());
                 for c in contents {
                     self.test_entry(c);
                 }
@@ -82,7 +78,7 @@ impl Generator {
                 file_name,
                 contents,
             }) => {
-                let mod_name = file_name.replace(".ion", "").escaped_snake_case();
+                let mod_name = file_name.replace(".ion", "").escape_path();
                 let out_file = format!("{}.rs", &mod_name);
                 let path: Vec<_> = self
                     .curr_path
@@ -107,27 +103,32 @@ fn gen_tests(scope: &mut Scope, test_document: &TestDocument) {
 }
 
 fn gen_mod(scope: &mut Scope, namespace: &Namespace) {
-    let module = scope.new_module(&namespace.name);
+    let module = scope.new_module(&namespace.name.escape_module_name());
+
     for ns in &namespace.namespaces {
         gen_mod(module.scope(), ns);
     }
     for test in &namespace.test_cases {
         gen_test(module.scope(), test);
     }
 }
+
 fn gen_test(scope: &mut Scope, test_case: &TestCase) {
-    let test_fn: &mut Function = scope.new_fn(&test_case.test_name);
+    let test_fn: &mut Function = scope.new_fn(&test_case.test_name.escape_test_name());
     test_fn.attr("test");
-    test_fn.line(format!("let statement = r#\"{}\"#;", &test_case.statement));
     for assertion in &test_case.assertions {
         match assertion {
             Assertion::SyntaxSuccess => {
-                test_fn.line("let res = partiql_parser::Parser::default().parse(statement);");
-                test_fn.line(r#"assert!(res.is_ok(), "For `{}`, expected `Ok(_)`, but was `{:#?}`", statement, res);"#);
+                test_fn.line(format!(
+                    r####"crate::pass_syntax(r#"{}"#);"####,
+                    &test_case.statement
+                ));
             }
             Assertion::SyntaxFail => {
-                test_fn.line("let res = partiql_parser::Parser::default().parse(statement);");
-                test_fn.line(r#"assert!(res.is_err(), "For `{}`, expected `Err(_)`, but was `{:#?}`", statement, res);"#);
+                test_fn.line(format!(
+                    r####"crate::fail_syntax(r#"{}"#);"####,
+                    &test_case.statement
+                ));
             }
             Assertion::NotYetImplemented => {
                 // for `NotYetImplemented` assertions, add the 'ignore' annotation to the test case

partiql-conformance-test-generator/src/lib.rs

@@ -1,19 +1,14 @@
+use crate::generator::Generator;
+use crate::reader::read_schema;
+use crate::writer::{TreeDepth, Writer, WriterConfig};
+use std::path::Path;
+
 mod generator;
 mod reader;
 mod schema;
 mod util;
 mod writer;
 
-use crate::generator::Generator;
-use crate::schema::spec::{
-    Assertion, Assertions, Namespace, Namespaces, TestCase, TestCases, TestDocument,
-};
-use crate::util::StringExt;
-
-use std::path::Path;
-
-use crate::reader::read_schema;
-
 // TODO docs
 #[derive(Debug, Copy, Clone)]
 pub enum OverwriteStrategy {
@@ -49,7 +44,8 @@ impl Config {
         let scopes = Generator::new().generate(schema)?;
 
         // TODO implement OverwriteStrategy
-        writer::write_scopes(out_path, scopes)?;
+        let config = WriterConfig::new(TreeDepth::N(4));
+        Writer::new(config).write(out_path, scopes)?;
         Ok(())
     }
 }

partiql-conformance-test-generator/src/reader.rs

@@ -1,8 +1,3 @@
-use crate::schema::structure::{TestDir, TestEntry, TestFile, TestRoot};
-use crate::{
-    Assertion, Assertions, Namespace, Namespaces, StringExt, TestCase, TestCases, TestDocument,
-};
-
 use ion_rs::value::owned::Element;
 use ion_rs::value::reader::{element_reader, ElementReader};
 use ion_rs::value::{IonElement, IonSequence, IonStruct};
@@ -13,19 +8,17 @@ use std::ffi::OsStr;
 use std::fs;
 use std::fs::DirEntry;
 
-use std::ops::Add;
-use std::path::{Path, PathBuf};
+use crate::schema::spec::{
+    Assertion, Assertions, Namespace, Namespaces, TestCase, TestCases, TestDocument,
+};
+use crate::schema::structure::{TestDir, TestEntry, TestFile, TestRoot};
+use std::path::Path;
 
 pub fn read_schema(root: impl AsRef<Path>) -> miette::Result<TestRoot> {
-    let fail = read_root(&root, "fail")?;
-    let success = read_root(&root, "success")?;
-    Ok(TestRoot { fail, success })
+    read_root(&root).map(|r| TestRoot(r))
 }
 
-fn read_root(root: impl AsRef<Path>, root_type: &str) -> miette::Result<Vec<TestEntry>> {
-    let mut dir: PathBuf = PathBuf::from(root.as_ref());
-    dir.push(root_type);
-
+fn read_root(root: impl AsRef<Path>) -> miette::Result<Vec<TestEntry>> {
     let root = fs::read_dir(root)
         .into_diagnostic()?
         .filter_map(|entry| read_entry(entry.expect("entry")))
@@ -124,8 +117,7 @@ fn test_namespace(element: &Element) -> Namespace {
     let name = annot
         .first()
         .expect("expected an annotation for the namespace")
-        .escaped_snake_case()
-        .add("_namespace");
+        .to_string();
 
     let mut namespaces: Namespaces = Vec::new();
     let mut test_cases: TestCases = Vec::new();
@@ -175,8 +167,7 @@ fn test_case(element: &Element) -> TestCase {
         .expect("name")
         .as_str()
         .expect("as_str()")
-        .escaped_snake_case()
-        .add("_test");
+        .to_string();
     let statement = test_struct
         .get("statement")
         .expect("statement")

partiql-conformance-test-generator/src/schema.rs

@@ -1,10 +1,7 @@
 pub mod structure {
     use crate::schema::spec::TestDocument;
 
-    pub struct TestRoot {
-        pub fail: Vec<TestEntry>,
-        pub success: Vec<TestEntry>,
-    }
+    pub struct TestRoot(pub Vec<TestEntry>);
 
     pub enum TestEntry {
         Dir(TestDir),

partiql-conformance-test-generator/src/util.rs

@@ -1,39 +1,70 @@
 use inflector::Inflector;
 
-pub trait StringExt {
-    /// Converts a string slice into an escaped `String`
-    fn escaped_snake_case(&self) -> String;
+pub trait Escaper {
+    /// Escapes a string intended to be used in a file path
+    fn escape_path(&self) -> String;
+
+    /// Escapes a string intended to be used as the name of a test
+    fn escape_test_name(&self) -> String;
+
+    /// Escapes a string intended to be used as the name of a module
+    fn escape_module_name(&self) -> String;
 }
 
-impl StringExt for &str {
-    fn escaped_snake_case(&self) -> String {
-        // TODO: currently non-text, non-numeric tokens are ignored and whitespace is converted to
-        //  underscores. More complicated escaping can be done to preserve more tokens
-        //  (e.g. punctuation)
+impl Escaper for &str {
+    fn escape_path(&self) -> String {
         self.to_snake_case()
     }
+
+    fn escape_test_name(&self) -> String {
+        format!("r#{}", self.to_snake_case())
+    }
+    fn escape_module_name(&self) -> String {
+        format!("r#{}", self.to_snake_case())
+    }
 }
 
-impl StringExt for String {
-    fn escaped_snake_case(&self) -> String {
-        self.as_str().escaped_snake_case()
+impl Escaper for String {
+    fn escape_path(&self) -> String {
+        self.as_str().escape_path()
+    }
+
+    fn escape_test_name(&self) -> String {
+        self.as_str().escape_test_name()
+    }
+
+    fn escape_module_name(&self) -> String {
+        self.as_str().escape_module_name()
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::util::StringExt;
+    use crate::util::Escaper;
 
     #[test]
     fn escaping_letters_and_whitespace() {
-        assert_eq!("a B c \t D \n e_f_G".escaped_snake_case(), "a_b_c_d_e_f_g")
+        assert_eq!("a B c \t D \n e_f_G".escape_path(), "a_b_c_d_e_f_g");
+        assert_eq!("a B c \t D \n e_f_G".escape_test_name(), "r#a_b_c_d_e_f_g");
+        assert_eq!(
+            "a B c \t D \n e_f_G".escape_module_name(),
+            "r#a_b_c_d_e_f_g"
+        );
     }
 
     #[test]
     fn escaping_letters_numbers_other_chars() {
         assert_eq!(
-            "a B c  1 2 3 e f G !?#$%*!(".escaped_snake_case(),
+            "a B c  1 2 3 e f G !?#$%*!(".escape_path(),
             "a_b_c_1_2_3_e_f_g"
-        )
+        );
+        assert_eq!(
+            "a B c  1 2 3 e f G !?#$%*!(".escape_test_name(),
+            "r#a_b_c_1_2_3_e_f_g"
+        );
+        assert_eq!(
+            "a B c  1 2 3 e f G !?#$%*!(".escape_module_name(),
+            "r#a_b_c_1_2_3_e_f_g"
+        );
     }
 }