Increased test coverage

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality/src/traits/causable/causable_reasoning.rs

@@ -66,7 +66,7 @@ where
                 _ => {
                     // Any other effect type is a contract violation for this function.
                     return Err(CausalityError(format!(
-                        "evaluate_deterministic_chain encountered a non-deterministic effect: {effect:?}. Only Deterministic effects are allowed."
+                        "evaluate_deterministic_propagation encountered a non-deterministic effect: {effect:?}. Only Deterministic effects are allowed."
                     )));
                 }
             }

deep_causality/src/utils_test/test_utils.rs

@@ -27,13 +27,6 @@ pub fn get_test_inf_vec() -> Vec<Inference> {
     Vec::from_iter([i1, i2])
 }
 
-pub fn get_test_causality_false_vec() -> BaseCausaloidVec {
-    let q1 = get_test_causaloid_deterministic_false();
-    let q2 = get_test_causaloid_deterministic_false();
-    let q3 = get_test_causaloid_deterministic_false();
-    Vec::from_iter([q1, q2, q3])
-}
-
 pub fn get_test_causality_vec() -> BaseCausaloidVec {
     let q1 = get_test_causaloid();
     let q2 = get_test_causaloid();

deep_causality/tests/types/causal_types/causaloid/causaloid_tests.rs

@@ -14,7 +14,9 @@ fn unpack_evidence(evidence: &Evidence) -> Result<NumericalValue, CausalityError
     if let Evidence::Numerical(val) = evidence {
         Ok(*val)
     } else {
-        Err(CausalityError("Expected Numerical evidence.".into()))
+        Err(CausalityError(format!(
+            "Expected Numerical evidence, got: {evidence:?}"
+        )))
     }
 }
 

deep_causality/tests/types/csm_types/csm_tests.rs

@@ -331,8 +331,9 @@ fn eval_single_state_success_fires_action() {
 fn eval_single_state_success_inactive_no_action() {
     let id = 42;
     let version = 1;
-    let data = Evidence::Numerical(0.88f64);
-    let causaloid = test_utils::get_test_causaloid(); // Returns Deterministic(false) for data > 0.5
+    // Use data that makes the state inactive (0.23 < 0.55 threshold)
+    let data = Evidence::Numerical(0.23f64);
+    let causaloid = test_utils::get_test_causaloid(); // Returns Deterministic(false)
 
     let cs = CausalState::new(id, version, data, causaloid);
     // Use an action that would fail to prove it's not being called.
@@ -341,10 +342,11 @@ fn eval_single_state_success_inactive_no_action() {
     let csm = CSM::new(state_action);
 
     // Data that makes the state inactive
-    let eval_data = test_utils::get_test_single_data(0.88f64);
+    let eval_data = test_utils::get_test_single_data(0.23f64);
     // Use the correct ID
     let res = csm.eval_single_state(id, eval_data);
-    assert!(res.is_err());
+    // Should be Ok because the state is inactive, so the failing action is never fired.
+    assert!(res.is_ok());
 }
 
 // Test for the case where the state does not exist.
@@ -366,3 +368,157 @@ fn eval_single_state_error_not_found() {
     assert!(res.is_err());
     assert!(res.unwrap_err().0.contains("State 99 does not exist"));
 }
+
+// This test covers the case where the state evaluation itself fails.
+// It adds coverage for the branch you identified.
+#[test]
+fn eval_single_state_error_eval_fails() {
+    let id = 42;
+    let version = 1;
+    let data = Evidence::Numerical(0.23f64);
+    // This causaloid's causal_fn always returns an error.
+    let causaloid = get_test_error_causaloid();
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    let ca = get_test_action(); // Action won't be reached
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let eval_data = test_utils::get_test_single_data(0.23f64);
+    // Use the correct ID to ensure we get past the 'not found' check.
+    let res = csm.eval_single_state(id, eval_data);
+
+    // The result should be an error because state.eval_with_data failed.
+    assert!(res.is_err());
+    let err_msg = res.unwrap_err().0;
+    assert!(err_msg.contains(&format!("CSM[eval]: Error evaluating state {id}")));
+}
+
+// This test covers the case where the action fails to fire.
+#[test]
+fn eval_single_state_error_action_fails() {
+    let id = 42;
+    let version = 1;
+    // Use data that makes the state active (0.60 > 0.55 threshold in test_causaloid)
+    let data = Evidence::Numerical(0.60f64);
+    let causaloid = test_utils::get_test_causaloid(); // Returns Deterministic(true)
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    // Use an action that is designed to fail.
+    let ca = get_test_error_action();
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    // Data that will make the state active
+    let eval_data = test_utils::get_test_single_data(0.60f64);
+    // Use the correct ID
+    let res = csm.eval_single_state(id, eval_data);
+
+    assert!(res.is_err());
+    let err_msg = res.unwrap_err().0;
+    assert!(err_msg.contains(&format!(
+        "CSM[eval]: Failed to fire action for state {id}"
+    )));
+}
+
+// I've renamed the original test to be more descriptive.
+// It correctly tests the success path where a state is inactive.
+#[test]
+fn eval_all_states_success_inactive_state() {
+    let id = 42;
+    let version = 1;
+    // Data that makes the state inactive (0.23 < 0.55 threshold)
+    let data = test_utils::get_test_single_data(0.23f64);
+    let causaloid = test_utils::get_test_causaloid();
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    let ca = get_test_action();
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let res = csm.eval_all_states();
+    assert!(res.is_ok())
+}
+
+// New test for the success path where a state is active and the action fires.
+#[test]
+fn eval_all_states_success_active_state_fires_action() {
+    let id = 42;
+    let version = 1;
+    // Data that makes the state active (0.6 > 0.55 threshold)
+    let data = Evidence::Numerical(0.60f64);
+    let causaloid = test_utils::get_test_causaloid(); // Returns Deterministic(true)
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    let ca = get_test_action(); // Succeeds
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let res = csm.eval_all_states();
+    assert!(res.is_ok());
+}
+
+// New test for the first error branch: state evaluation fails.
+#[test]
+fn eval_all_states_error_eval_fails() {
+    let id = 42;
+    let version = 1;
+    let data = Evidence::Numerical(0.23f64);
+    // This causaloid's causal_fn always returns an error.
+    let causaloid = get_test_error_causaloid();
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    let ca = get_test_action(); // Action won't be reached
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let res = csm.eval_all_states();
+
+    assert!(res.is_err());
+    let err_msg = res.unwrap_err().0;
+    assert!(err_msg.contains(&format!("CSM[eval]: Error evaluating state {id}")));
+}
+
+// New test for the second error branch: action firing fails.
+#[test]
+fn eval_all_states_error_action_fails() {
+    let id = 42;
+    let version = 1;
+    // Use data that makes the state active (0.60 > 0.55 threshold)
+    let data = Evidence::Numerical(0.60f64);
+    let causaloid = test_utils::get_test_causaloid(); // Returns Deterministic(true)
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    // Use an action that is designed to fail.
+    let ca = get_test_error_action();
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let res = csm.eval_all_states();
+
+    assert!(res.is_err());
+    let err_msg = res.unwrap_err().0;
+    assert!(err_msg.contains(&format!(
+        "CSM[eval]: Failed to fire action for state {id}"
+    )));
+}
+
+// New test for the third error branch: non-deterministic effect.
+#[test]
+fn eval_all_states_error_non_deterministic() {
+    let id = 42;
+    let version = 1;
+    let data = Evidence::Numerical(0.23f64);
+    let causaloid = get_test_probabilistic_causaloid();
+
+    let cs = CausalState::new(id, version, data, causaloid);
+    let ca = get_test_action();
+    let state_action = &[(&cs, &ca)];
+    let csm = CSM::new(state_action);
+
+    let res = csm.eval_all_states();
+    assert!(res.is_err());
+    let err_msg = res.unwrap_err().0;
+    assert!(err_msg.contains("Invalid non-deterministic effect"));
+    assert!(err_msg.contains(&format!("for state {id}")));
+}