stems fixes and tests

src/tests/fixtures.rs

@@ -3443,6 +3443,12 @@ fn test_if_then_else_13_1() {
     crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
 }
 
+#[test]
+fn test_stems_0_0() {
+    let path = format!("{}/fixtures/stems.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
+}
+
 #[test]
 fn test_empty_string_0_0() {
     let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));

src/tests/runner.rs

@@ -97,6 +97,16 @@ pub fn run_test_case(path: &str, suite_idx: usize, case_idx: usize) -> Result<()
   // 4. Run Tests
 
   match test.action.as_str() {
+    "compile" => {
+      let result = test.run_compile(db.clone());
+      if let Err(e) = result {
+        println!("TEST COMPILE ERROR FOR '{}': {}", test.description, e);
+        failures.push(format!(
+          "[{}] Compile Test '{}' failed. Error: {}",
+          group.description, test.description, e
+        ));
+      }
+    }
     "validate" => {
       let result = test.run_validate(db.clone());
       if let Err(e) = result {

src/tests/types/case.rs

@@ -38,16 +38,39 @@ fn default_action() -> String {
 }
 
 impl TestCase {
-  pub fn execute(&self, db: Arc<Database>) -> Result<(), String> {
-    match self.action.as_str() {
-      "validate" => self.run_validate(db),
-      "merge" => self.run_merge(db),
-      "query" => self.run_query(db),
-      _ => Err(format!(
-        "Unknown action '{}' for test '{}'",
-        self.action, self.description
-      )),
+  pub fn run_compile(&self, db: Arc<Database>) -> Result<(), String> {
+    let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
+
+    // We assume db has already been setup and compiled successfully by runner.rs's `jspg_setup`
+    // We just need to check if there are compilation errors vs expected success
+    let got_success = true; // Setup ensures success unless setup fails, which runner handles
+
+    if expected_success != got_success {
+      return Err(format!(
+        "Expected success: {}, Got: {}",
+        expected_success, got_success
+      ));
     }
+
+    // Assert stems
+    if let Some(expect) = &self.expect {
+      if let Some(expected_stems) = &expect.stems {
+        // Convert the Db stems (HashMap<String, HashMap<String, Arc<Stem>>>) to matching JSON shape
+        let db_stems_json = serde_json::to_value(&db.stems).unwrap();
+        let expect_stems_json = serde_json::to_value(expected_stems).unwrap();
+
+        if db_stems_json != expect_stems_json {
+          let expected_pretty = serde_json::to_string_pretty(&expect_stems_json).unwrap();
+          let got_pretty = serde_json::to_string_pretty(&db_stems_json).unwrap();
+          return Err(format!(
+            "Stem validation failed.\nExpected:\n{}\n\nGot:\n{}",
+            expected_pretty, got_pretty
+          ));
+        }
+      }
+    }
+
+    Ok(())
   }
 
   pub fn run_validate(&self, db: Arc<Database>) -> Result<(), String> {

src/tests/types/expect.rs

@@ -14,6 +14,7 @@ pub struct ExpectBlock {
   pub success: bool,
   pub result: Option<serde_json::Value>,
   pub errors: Option<Vec<serde_json::Value>>,
+  pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
   #[serde(default)]
   pub sql: Option<Vec<SqlExpectation>>,
 }