Merge pull request #94 from ozgurakgun/cases

Adding test cases and updating the tester

.gitignore

@@ -1,6 +1,8 @@
 *.log
 coverage
 
+conjure_oxide/tests/**/*.generated.*
+
 ## Rust
 debug/
 target/

conjure_oxide/Cargo.toml

@@ -4,8 +4,11 @@ version = "0.0.1"
 edition = "2021"
 default-run = "conjure_oxide"
 
+# these are available inside build.rs
+[build-dependencies]
+walkdir = "2.4.0"
+
 [dependencies]
-assert-json-diff = "2.0.2"
 serde = { version = "1.0.192", features = ["derive"] }
 serde_json = "1.0.108"
 serde_with = "3.4.0"

conjure_oxide/build.rs

@@ -1,30 +1,55 @@
-use std::{
-    env::var,
-    fs::File,
-    fs::{read_dir, DirEntry},
-    io::Write,
-    path::Path,
-};
+use std::env::var;
+use std::fs::{read_dir, File};
+use std::io::{self, Write};
+use std::path::Path;
+use walkdir::WalkDir;
 
-fn main() {
-    let out_dir = var("OUT_DIR").unwrap();
+fn main() -> io::Result<()> {
+    let out_dir = var("OUT_DIR").map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; // wrapping in a std::io::Error to match main's error type
     let dest = Path::new(&out_dir).join("gen_tests.rs");
-    let mut f = File::create(&dest).unwrap();
+    let mut f = File::create(&dest)?;
 
     let test_dir = "tests/integration";
-    for dir in read_dir(test_dir).unwrap() {
-        write_test(&mut f, &dir.unwrap());
+
+    for subdir in WalkDir::new(test_dir) {
+        let subdir = subdir?;
+        if subdir.file_type().is_dir() {
+            let essence_files: Vec<String> = read_dir(subdir.path())?
+                .filter_map(Result::ok)
+                .filter(|entry| {
+                    entry
+                        .path()
+                        .extension()
+                        .map_or(false, |ext| ext == "essence")
+                })
+                .filter_map(|entry| {
+                    entry
+                        .path()
+                        .file_stem()
+                        .and_then(|stem| stem.to_str())
+                        .map(|s| s.to_owned())
+                })
+                .collect();
+
+            write_test(&mut f, subdir.path().display().to_string(), essence_files)?;
+        }
     }
+
+    Ok(())
 }
 
-fn write_test(file: &mut File, dir: &DirEntry) {
-    let binding = dir.path();
-    let path = binding.to_str().unwrap();
-    write!(
-        file,
-        include_str!("./tests/gen_test_template"),
-        name = path.replace("./", "").replace("/", "_"),
-        path = path
-    )
-    .unwrap();
+fn write_test(file: &mut File, path: String, essence_files: Vec<String>) -> io::Result<()> {
+    // TODO: Consider supporting multiple Essence files?
+    if essence_files.len() == 1 {
+        write!(
+            file,
+            include_str!("./tests/gen_test_template"),
+            // TODO: better sanitisation of paths to function names
+            test_name = path.replace("./", "").replace("/", "_").replace("-", "_"),
+            test_dir = path,
+            essence_file = essence_files[0]
+        )
+    } else {
+        Ok(())
+    }
 }

conjure_oxide/src/main.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fs::File, io::Read};
+use std::collections::HashMap;
 
 use conjure_oxide::ast::*;
 

conjure_oxide/tests/gen_test_template

@@ -1,4 +1,4 @@
 #[test]
-fn {name}() -> Result<(), Box<dyn Error>> {{
-    integration_test("{path}")
+fn {test_name}() -> Result<(), Box<dyn Error>> {{
+    integration_test("{test_dir}", "{essence_file}")
 }}

conjure_oxide/tests/generated_tests.rs

@@ -1,34 +1,66 @@
-use assert_json_diff::assert_json_eq;
+use std::env;
 use std::error::Error;
 use std::fs::File;
 use std::io::prelude::*;
 
 use conjure_oxide::ast::Model;
 
-fn integration_test(path: &str) -> Result<(), Box<dyn Error>> {
-    println!("Integration test for: {}", path);
+use std::path::Path;
+
+fn main() {
+    let file_path = Path::new("/path/to/your/file.txt");
+    let base_name = file_path.file_stem().and_then(|stem| stem.to_str());
+
+    match base_name {
+        Some(name) => println!("Base name: {}", name),
+        None => println!("Could not extract the base name"),
+    }
+}
+
+fn integration_test(path: &str, essence_base: &str) -> Result<(), Box<dyn Error>> {
+    // --------------------------------------------------------------------------------
+    // -- parsing the essence file
+
+    // calling conjure to convert Essence to astjson
     let mut cmd = std::process::Command::new("conjure");
     let output = cmd
         .arg("pretty")
         .arg("--output-format=astjson")
-        .arg(format!("{path}/input.essence", path = path))
+        .arg(format!("{path}/{essence_base}.essence"))
         .output()?;
+    assert!(
+        String::from_utf8(output.stderr)?.is_empty(),
+        "conjure's stderr is not empty"
+    );
     let astjson = String::from_utf8(output.stdout)?;
+
+    // "parsing" astjson as Model
     let generated_mdl = Model::from_json(&astjson)?;
 
-    let mut expected_str = String::new();
-    let mut f = File::open(format!(
-        "{path}/input.serialised.expected.json",
-        path = path
-    ))?;
-    f.read_to_string(&mut expected_str)?;
+    // serialise to file
+    let generated_json = serde_json::to_string_pretty(&generated_mdl)?;
+    File::create(format!("{path}/{essence_base}.generated.serialised.json"))?
+        .write_all(generated_json.as_bytes())?;
+
+    if std::env::var("ACCEPT").map_or(false, |v| v == "true") {
+        std::fs::copy(
+            format!("{path}/{essence_base}.generated.serialised.json"),
+            format!("{path}/{essence_base}.expected.serialised.json"),
+        )?;
+    }
+
+    // --------------------------------------------------------------------------------
+    // -- reading the expected version from the filesystem
+
+    let expected_str =
+        std::fs::read_to_string(format!("{path}/{essence_base}.expected.serialised.json"))?;
+
     let mut expected_mdl: Model = serde_json::from_str(&expected_str)?;
     expected_mdl.constraints = Vec::new(); // TODO - remove this line once we parse constraints
 
-    println!("Expected {:#?}", expected_mdl);
-    println!("\nActual {:#?}", generated_mdl);
+    // --------------------------------------------------------------------------------
+    // assert that they are the same model
 
-    // assert_json_eq!(serde_json::to_string_pretty(&generated_mdl)?, expected_str); // TODO - replace line once we parse constraints
     assert_eq!(generated_mdl, expected_mdl);
 
     Ok(())

conjure_oxide/tests/integration/basic/bool-01/bool-01.essence

@@ -0,0 +1 @@
+find x : bool

conjure_oxide/tests/integration/basic/bool-01/bool-01.expected.serialised.json

@@ -0,0 +1,13 @@
+{
+  "variables": [
+    [
+      {
+        "UserName": "x"
+      },
+      {
+        "domain": "BoolDomain"
+      }
+    ]
+  ],
+  "constraints": []
+}

conjure_oxide/tests/integration/basic/bool-02/bool-02.essence

@@ -0,0 +1 @@
+find x, y : bool

conjure_oxide/tests/integration/basic/bool-02/bool-02.expected.serialised.json

@@ -0,0 +1,21 @@
+{
+  "variables": [
+    [
+      {
+        "UserName": "y"
+      },
+      {
+        "domain": "BoolDomain"
+      }
+    ],
+    [
+      {
+        "UserName": "x"
+      },
+      {
+        "domain": "BoolDomain"
+      }
+    ]
+  ],
+  "constraints": []
+}

conjure_oxide/tests/integration/basic/bool-03/bool-03.essence

@@ -0,0 +1,2 @@
+find x, y : bool
+such that x != y

conjure_oxide/tests/integration/basic/bool-03/bool-03.expected.serialised.json

@@ -0,0 +1,21 @@
+{
+  "variables": [
+    [
+      {
+        "UserName": "x"
+      },
+      {
+        "domain": "BoolDomain"
+      }
+    ],
+    [
+      {
+        "UserName": "y"
+      },
+      {
+        "domain": "BoolDomain"
+      }
+    ]
+  ],
+  "constraints": []
+}