Refactor conformance test generator to encapsulate logic (#204)

Author: jpschorr

partiql-conformance-test-generator/Cargo.toml

@@ -23,6 +23,8 @@ edition = "2021"
 
 [dependencies]
 walkdir = "2.3"
-ion-rs = "0.6.0"
-codegen = "0.1.3"
+ion-rs = "0.14.*"
+codegen = "0.2.*"
 Inflector = "0.11.4"
+miette = "5.*"
+thiserror = "1.*"

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

@@ -1,45 +1,122 @@
-use crate::schema::{Assertion, Namespace, TestCase, TestDocument};
+use crate::schema::spec::{Assertion, Namespace, TestCase, TestDocument};
+use crate::schema::structure::{TestDir, TestEntry, TestFile, TestRoot};
+
+use crate::StringExt;
 use codegen::{Function, Module, Scope};
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub enum TestComponent {
+    Scope(TestScope),
+    Module(TestModule),
+}
+
+#[derive(Debug)]
+pub struct TestScope {
+    pub module: Module,
+}
+
+#[derive(Debug, Default)]
+pub struct TestModule {
+    pub children: HashMap<String, TestComponent>,
+}
+
+impl TestModule {
+    pub fn insert(&mut self, path: &[&String], scope: TestScope) {
+        if let Some((first, rest)) = path.split_first() {
+            if rest.is_empty() {
+                self.children
+                    .insert(first.to_string(), TestComponent::Scope(scope));
+            } else {
+                let child = self
+                    .children
+                    .entry((*first).clone())
+                    .or_insert_with(|| TestComponent::Module(TestModule::default()));
+                if let TestComponent::Module(child_mod) = child {
+                    child_mod.insert(rest, scope)
+                } else {
+                    unreachable!();
+                }
+            }
+        }
+    }
+}
 
-/// Defines a test code generation object
+/// Generates a [`TestModule`] root from a [`TestRoot`] specification.
+#[derive(Debug)]
 pub struct Generator {
-    pub test_document: TestDocument,
+    result: TestModule,
+    curr_path: Vec<String>,
 }
 
 impl Generator {
-    /// Generates a `Scope` from the `Generator`'s `test_document`
-    pub fn generate_scope(&self) -> Scope {
-        test_document_to_scope(&self.test_document)
+    pub fn new() -> Generator {
+        Self {
+            result: Default::default(),
+            curr_path: Default::default(),
+        }
+    }
+
+    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)
+        }
+
+        Ok(self.result)
+    }
+
+    fn test_entry(&mut self, entry: TestEntry) {
+        match entry {
+            TestEntry::Dir(TestDir { dir_name, contents }) => {
+                self.curr_path.push(dir_name);
+                for c in contents {
+                    self.test_entry(c);
+                }
+                self.curr_path.pop();
+            }
+            TestEntry::Doc(TestFile {
+                file_name,
+                contents,
+            }) => {
+                let mod_name = file_name.replace(".ion", "").escaped_snake_case();
+                let out_file = format!("{}.rs", &mod_name);
+                let path: Vec<_> = self
+                    .curr_path
+                    .iter()
+                    .chain(std::iter::once(&out_file))
+                    .collect();
+                let mut module = Module::new(&mod_name);
+                gen_tests(module.scope(), &contents);
+                self.result.insert(&path, TestScope { module });
+            }
+        }
     }
 }
 
-/// Converts a `TestDocument` into a `Scope`
-fn test_document_to_scope(test_document: &TestDocument) -> Scope {
-    let mut scope = Scope::new();
+fn gen_tests(scope: &mut Scope, test_document: &TestDocument) {
     for namespace in &test_document.namespaces {
-        scope.push_module(namespace_to_module(namespace));
+        gen_mod(scope, namespace);
     }
     for test in &test_document.test_cases {
-        scope.push_fn(test_case_to_function(test));
+        gen_test(scope, test);
     }
-    scope
 }
 
-/// Converts a `Namespace` into a `Module`
-fn namespace_to_module(namespace: &Namespace) -> Module {
-    let mut module = Module::new(&*namespace.name);
+fn gen_mod(scope: &mut Scope, namespace: &Namespace) {
+    let module = scope.new_module(&namespace.name);
     for ns in &namespace.namespaces {
-        module.push_module(namespace_to_module(ns));
+        gen_mod(module.scope(), ns);
     }
     for test in &namespace.test_cases {
-        module.push_fn(test_case_to_function(test));
+        gen_test(module.scope(), test);
     }
-    module
 }
-
-/// Converts a test case into a testing `Function`
-fn test_case_to_function(test_case: &TestCase) -> Function {
-    let mut test_fn: Function = Function::new(&test_case.test_name);
+fn gen_test(scope: &mut Scope, test_case: &TestCase) {
+    let test_fn: &mut Function = scope.new_fn(&test_case.test_name);
     test_fn.attr("test");
     test_fn.line(format!("let statement = r#\"{}\"#;", &test_case.statement));
     for assertion in &test_case.assertions {
@@ -59,7 +136,6 @@ fn test_case_to_function(test_case: &TestCase) -> Function {
             }
         }
     }
-    test_fn
 }
 
 #[cfg(test)]

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

@@ -1,174 +1,57 @@
-pub mod generator;
+mod generator;
+mod reader;
 mod schema;
-pub mod util;
+mod util;
+mod writer;
 
-use crate::schema::{
+use crate::generator::Generator;
+use crate::schema::spec::{
     Assertion, Assertions, Namespace, Namespaces, TestCase, TestCases, TestDocument,
 };
 use crate::util::StringExt;
-use ion_rs::value::owned::OwnedElement;
-use ion_rs::value::{Element, Sequence, Struct, SymbolToken};
-use ion_rs::IonType;
-use std::collections::HashSet;
-use std::ops::Add;
 
-// TODO: move these test data parsing functions to own file
-/// Converts a vector of Ion data into a `TestDocument`, which can be composed of `Namespace`s
-/// and `TestCase`s. `Namespace`s must be provided as IonLists while `TestCase`s must be provided
-/// as IonStructs. Other Ion types will result in a panic.
-///
-/// When encountering a duplicate namespace/test case, a namespace/test case will be added with
-/// '_0' suffixed to the end of the name.
-pub fn ion_data_to_test_document(all_ion_data: Vec<OwnedElement>) -> TestDocument {
-    let mut namespaces = Vec::new();
-    let mut test_cases = Vec::new();
+use std::path::Path;
 
-    let mut encountered_ns_names: HashSet<String> = HashSet::new();
-    let mut encountered_tc_names: HashSet<String> = HashSet::new();
+use crate::reader::read_schema;
 
-    for elem in all_ion_data {
-        match elem.ion_type() {
-            IonType::List => {
-                // namespace in document
-                let mut ns = test_namespace(&elem);
-                if encountered_ns_names.contains(&ns.name) {
-                    ns.name.push_str("_0")
-                }
-                encountered_ns_names.insert(ns.name.clone());
-                namespaces.push(ns)
-            }
-            IonType::Struct => {
-                // test case in document
-                let mut tc = test_case(&elem);
-                if encountered_tc_names.contains(&tc.test_name) {
-                    tc.test_name.push_str("_0")
-                }
-                encountered_tc_names.insert(tc.test_name.clone());
-                test_cases.push(tc)
-            }
-            _ => panic!("Document parsing requires an IonList or IonStruct"),
-        }
-    }
-    TestDocument {
-        namespaces,
-        test_cases,
-    }
+// TODO docs
+#[derive(Debug, Copy, Clone)]
+pub enum OverwriteStrategy {
+    Overwrite,
+    Backup,
 }
 
-/// Parses the given `OwnedElement` to a `Namespace`. Requires an annotation to provided that will
-/// be used to create the name. '_namespace' will be suffixed to the first annotation provided.
-/// The namespace can contain sub-namespaces and test cases represented by IonLists and IonStructs
-/// respectively. When provided with something other than an IonList or IonStruct, this function
-/// will panic.
-pub fn test_namespace(element: &OwnedElement) -> Namespace {
-    let annot: Vec<_> = element
-        .annotations()
-        .map(|a| a.text().expect("annotation text"))
-        .collect();
-    let name = annot
-        .first()
-        .expect("expected an annotation for the namespace")
-        .escaped_snake_case()
-        .add("_namespace");
-
-    let mut namespaces: Namespaces = Vec::new();
-    let mut test_cases: TestCases = Vec::new();
-
-    let mut encountered_ns_names: HashSet<String> = HashSet::new();
-    let mut encountered_tc_names: HashSet<String> = HashSet::new();
+/// Configuration for the generation of conformance tests.
+#[derive(Debug, Copy, Clone)]
+pub struct Config {
+    pub overwrite: OverwriteStrategy,
+}
 
-    for ns_or_test in element.as_sequence().expect("namespace is list").iter() {
-        match ns_or_test.ion_type() {
-            // namespace within the namespace
-            IonType::List => {
-                let mut ns = test_namespace(ns_or_test);
-                if encountered_ns_names.contains(&ns.name) {
-                    ns.name.push_str("_0")
-                }
-                encountered_ns_names.insert(ns.name.clone());
-                namespaces.push(ns)
-            }
-            // test case within the namespace
-            IonType::Struct => {
-                let mut tc = test_case(ns_or_test);
-                if encountered_tc_names.contains(&tc.test_name) {
-                    tc.test_name.push_str("_0")
-                }
-                encountered_tc_names.insert(tc.test_name.clone());
-                test_cases.push(tc)
-            }
-            _ => panic!("Namespace parsing requires an IonList or IonStruct"),
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            overwrite: OverwriteStrategy::Overwrite,
         }
     }
-    Namespace {
-        name,
-        namespaces,
-        test_cases,
-    }
 }
 
-/// Parses the given IonStruct to a `TestCase`. The IonStruct requires two string fields with the
-/// 'name' and 'statement' in addition to an 'assert' field containing one or more `Assertions`.
-///
-/// For test assertions that are not supported (e.g. StaticAnalysisFail), the assertion of
-/// `NotYetImplemented` will be used.
-fn test_case(element: &OwnedElement) -> TestCase {
-    let test_struct = element.as_struct().expect("struct");
-    let test_name = test_struct
-        .get("name")
-        .expect("name")
-        .as_str()
-        .expect("as_str()")
-        .escaped_snake_case()
-        .add("_test");
-    let statement = test_struct
-        .get("statement")
-        .expect("statement")
-        .as_str()
-        .expect("as_str()")
-        .to_string();
-
-    let assert_field = test_struct.get("assert").expect("assert field missing");
-    let assertions_vec: Vec<_> = match assert_field.ion_type() {
-        IonType::Struct => vec![assert_field],
-        IonType::List => assert_field
-            .as_sequence()
-            .expect("as_sequence")
-            .iter()
-            .collect(),
-        _ => panic!("Invalid IonType for the test case assertions"),
-    };
-    let assertions = assertions(&assertions_vec);
-    TestCase {
-        test_name,
-        statement,
-        assertions,
+impl Config {
+    pub fn new() -> Config {
+        Config::default()
     }
-}
 
-/// Converts the vector of Ion values into `Assertions`. Checks that a result field is provided
-/// in the vector and has the symbol 'SyntaxSuccess' or 'SyntaxFail', which correspond to
-/// `Assertion::SyntaxSuccess` and `Assertion::SyntaxFail` respectively. Other assertion symbols
-/// will default to `Assertion::NotYetImplemented`
-fn assertions(assertions: &Vec<&OwnedElement>) -> Assertions {
-    let mut test_case_assertions: Assertions = Vec::new();
-    for assertion in assertions {
-        let assertion_struct = assertion.as_struct().expect("as_struct()");
-        let parse_result = assertion_struct.get("result");
-        match parse_result {
-            Some(r) => {
-                let r_as_str = r.as_str().expect("as_str()");
-                let assertion = match r_as_str {
-                    "SyntaxSuccess" => Assertion::SyntaxSuccess,
-                    "SyntaxFail" => Assertion::SyntaxFail,
-                    _ => Assertion::NotYetImplemented,
-                };
-                test_case_assertions.push(assertion);
-            }
-            None => (),
-        }
+    pub fn process_dir(
+        &self,
+        test_data: impl AsRef<Path>,
+        out_path: impl AsRef<Path>,
+    ) -> miette::Result<()> {
+        let schema = read_schema(test_data)?;
+        let scopes = Generator::new().generate(schema)?;
+
+        // TODO implement OverwriteStrategy
+        writer::write_scopes(out_path, scopes)?;
+        Ok(())
     }
-    test_case_assertions
 }
 
 #[cfg(test)]