jspg masking system installed

src/util.rs

@@ -183,15 +183,51 @@ pub fn run_test_file_at_index(path: &str, index: usize) -> Result<(), String> {
     if let Some(sid) = schema_id {
       let result = validator.validate(&sid, &test.data);
 
-      if !result.errors.is_empty() != !test.valid {
-        failures.push(format!(
-          "[{}] Test '{}' failed. Expected: {}, Got: {}. Errors: {:?}",
-          group.description,
-          test.description,
-          test.valid,
-          !result.errors.is_empty(), // "Got Invalid?"
-          result.errors
-        ));
+      let (got_valid, _errors) = match &result {
+        Ok(res) => (res.is_valid(), &res.errors),
+        Err(_e) => {
+          // If we encounter an execution error (e.g. Schema Not Found),
+          // we treat it as a test failure.
+          (false, &vec![])
+        }
+      };
+
+      if let Some(expected) = &test.expected {
+        // Masking Test
+        let mut data_for_mask = test.data.clone();
+        match validator.mask(&sid, &mut data_for_mask) {
+          Ok(_) => {
+            if !equals(&data_for_mask, expected) {
+              let msg = format!(
+                "Masking Test '{}' failed.\nExpected: {:?}\nGot: {:?}",
+                test.description, expected, data_for_mask
+              );
+              eprintln!("{}", msg);
+              failures.push(msg);
+            }
+          }
+          Err(e) => {
+            let msg = format!(
+              "Masking Test '{}' failed with execution error: {:?}",
+              test.description, e
+            );
+            eprintln!("{}", msg);
+            failures.push(msg);
+          }
+        }
+      } else {
+        // Standard Validation Test
+        if got_valid != test.valid {
+          let error_msg = match &result {
+            Ok(res) => format!("{:?}", res.errors),
+            Err(e) => format!("Execution Error: {:?}", e),
+          };
+
+          failures.push(format!(
+            "[{}] Test '{}' failed. Expected: {}, Got: {}. Errors: {}",
+            group.description, test.description, test.valid, got_valid, error_msg
+          ));
+        }
       }
     } else {
       failures.push(format!(
@@ -310,28 +346,47 @@ pub fn run_test_file(path: &str) -> Result<(), String> {
       // Use explicit schema_id from test, or default to unique_id
       let schema_id = test.schema_id.as_deref().unwrap_or(&unique_id).to_string();
 
-      let drop = validator.validate(&schema_id, &test.data);
+      let result = validator.validate(&schema_id, &test.data);
 
       if test.valid {
-        if !drop.errors.is_empty() {
-          let msg = format!(
-            "Test failed (expected valid): {}\nSchema: {:?}\nData: {:?}\nErrors: {:?}",
-            test.description,
-            group.schema, // We might need to find the actual schema used if schema_id is custom
-            test.data,
-            drop.errors
-          );
-          eprintln!("{}", msg);
-          failures.push(msg);
+        match result {
+          Ok(res) => {
+            if !res.is_valid() {
+              let msg = format!(
+                "Test failed (expected valid): {}\nSchema: {:?}\nData: {:?}\nErrors: {:?}",
+                test.description,
+                group.schema, // We might need to find the actual schema used if schema_id is custom
+                test.data,
+                res.errors
+              );
+              eprintln!("{}", msg);
+              failures.push(msg);
+            }
+          }
+          Err(e) => {
+            let msg = format!(
+              "Test failed (expected valid) but got execution error: {}\nSchema: {:?}\nData: {:?}\nError: {:?}",
+              test.description, group.schema, test.data, e
+            );
+            eprintln!("{}", msg);
+            failures.push(msg);
+          }
         }
       } else {
-        if drop.errors.is_empty() {
-          let msg = format!(
-            "Test failed (expected invalid): {}\nSchema: {:?}\nData: {:?}\nErrors: (Empty)",
-            test.description, group.schema, test.data
-          );
-          println!("{}", msg);
-          failures.push(msg);
+        match result {
+          Ok(res) => {
+            if res.is_valid() {
+              let msg = format!(
+                "Test failed (expected invalid): {}\nSchema: {:?}\nData: {:?}",
+                test.description, group.schema, test.data
+              );
+              eprintln!("{}", msg);
+              failures.push(msg);
+            }
+          }
+          Err(_) => {
+            // Expected invalid, got error (which implies invalid/failure), so this is PASS.
+          }
         }
       }
     }