queryer merger test progress

src/tests/runner.rs

@@ -0,0 +1,113 @@
+use serde::Deserialize;
+use std::fs;
+
+#[derive(Debug, Deserialize)]
+struct TestSuite {
+  #[allow(dead_code)]
+  description: String,
+  database: serde_json::Value,
+  tests: Vec<TestCase>,
+}
+
+use crate::tests::types::{ExpectBlock, TestCase};
+
+use crate::validator::Validator;
+use serde_json::Value;
+
+pub fn deserialize_some<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
+where
+  D: serde::Deserializer<'de>,
+{
+  let v = Value::deserialize(deserializer)?;
+  Ok(Some(v))
+}
+
+pub fn run_test_file_at_index(path: &str, index: usize) -> Result<(), String> {
+  let content =
+    fs::read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {}", path));
+  let suite: Vec<TestSuite> = serde_json::from_str(&content)
+    .unwrap_or_else(|e| panic!("Failed to parse JSON in {}: {}", path, e));
+
+  if index >= suite.len() {
+    panic!("Index {} out of bounds for file {}", index, path);
+  }
+
+  let group = &suite[index];
+  let mut failures = Vec::<String>::new();
+
+  let db_json = group.database.clone();
+  let db_result = crate::database::Database::new(&db_json);
+  if let Err(drop) = db_result {
+    let error_messages: Vec<String> = drop
+      .errors
+      .into_iter()
+      .map(|e| format!("Error {} at path {}: {}", e.code, e.details.path, e.message))
+      .collect();
+    return Err(format!(
+      "System Setup Compilation failed:\n{}",
+      error_messages.join("\n")
+    ));
+  }
+  let db = db_result.unwrap();
+  let validator = Validator::new(std::sync::Arc::new(db));
+
+  // 4. Run Tests
+  for test in group.tests.iter() {
+    // Provide fallback for legacy expectations if `expect` block was missing despite migration script
+    let expected_success = test
+      .expect
+      .as_ref()
+      .map(|e| e.success)
+      .unwrap_or(test.valid.unwrap_or(false));
+    let _expected_errors = test
+      .expect
+      .as_ref()
+      .and_then(|e| e.errors.clone())
+      .unwrap_or(test.expect_errors.clone().unwrap_or(vec![]));
+
+    match test.action.as_str() {
+      "validate" => {
+        let result = test.run_validate(validator.db.clone());
+        if let Err(e) = result {
+          println!("TEST VALIDATE ERROR FOR '{}': {}", test.description, e);
+          failures.push(format!(
+            "[{}] Validate Test '{}' failed. Error: {}",
+            group.description, test.description, e
+          ));
+        }
+      }
+      "merge" => {
+        let result = test.run_merge(validator.db.clone());
+        if let Err(e) = result {
+          println!("TEST MERGE ERROR FOR '{}': {}", test.description, e);
+          failures.push(format!(
+            "[{}] Merge Test '{}' failed. Error: {}",
+            group.description, test.description, e
+          ));
+        }
+      }
+      "query" => {
+        let result = test.run_query(validator.db.clone());
+        if let Err(e) = result {
+          println!("TEST QUERY ERROR FOR '{}': {}", test.description, e);
+          failures.push(format!(
+            "[{}] Query Test '{}' failed. Error: {}",
+            group.description, test.description, e
+          ));
+        }
+      }
+      _ => {
+        failures.push(format!(
+          "[{}] Unknown action '{}' for test '{}'",
+          group.description, test.action, test.description
+        ));
+      }
+    }
+  }
+
+  if !failures.is_empty() {
+    return Err(failures.join("\n"));
+  }
+
+  Ok(())
+}