Added or improved test coverage for causable reasoning for all causable collections.

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

Author: marvin-hansen

deep_causality/tests/extensions/causable/causable_arr_tests.rs

@@ -46,16 +46,16 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = col
-        .evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All)
-        .unwrap();
+    let res = col.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = col
-        .evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All)
-        .unwrap();
+    let res = col.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
 }
 
@@ -73,9 +73,9 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = col
-        .evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = col.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
 }
 
@@ -85,9 +85,9 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = col
-        .evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = col.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain becomes deterministically false.
@@ -107,7 +107,6 @@ fn test_explain() {
     assert!(res.is_ok());
 
     let res = col.explain();
-    dbg!(&res);
     assert!(res.is_ok());
     let actual = col.explain().unwrap();
 

deep_causality/tests/extensions/causable/causable_btree_map_tests.rs

@@ -87,16 +87,16 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All)
-        .unwrap();
+    let res = map.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map
-        .evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All)
-        .unwrap();
+    let res = map.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
 }
 
@@ -107,17 +107,17 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Probabilistic(1.0));
 
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map
-        .evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
 }
 
@@ -127,16 +127,16 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain becomes deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map
-        .evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
 }
 
@@ -150,7 +150,9 @@ fn test_explain() {
     let expected = format!(
         "\n * {single_explanation}\n\n * {single_explanation}\n\n * {single_explanation}\n"
     );
-    let actual = map.explain().unwrap();
+    let res = map.explain();
+    assert!(res.is_ok());
+    let actual = res.unwrap();
     assert_eq!(expected, actual);
 }
 

deep_causality/tests/extensions/causable/causable_map_tests.rs

@@ -103,16 +103,16 @@ fn test_evaluate_deterministic_propagation() {
 
     // Case 1: All succeed, chain should be deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All)
-        .unwrap();
+    let res = map.evaluate_deterministic_propagation(&effect_success, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 
     // Case 2: One fails, chain should be deterministically false.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map
-        .evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All)
-        .unwrap();
+    let res = map.evaluate_deterministic_propagation(&effect_fail, &AggregateLogic::All);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Deterministic(false));
 }
 
@@ -123,17 +123,17 @@ fn test_evaluate_probabilistic_propagation() {
     // Case 1: All succeed (Deterministic(true) is treated as probability 1.0).
     // The cumulative probability should be 1.0.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_probabilistic_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     assert_eq!(res_success, PropagatingEffect::Probabilistic(1.0));
 
     // Case 2: One fails (Deterministic(false) is treated as probability 0.0).
     // The chain should short-circuit and return a cumulative probability of 0.0.
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map
-        .evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_probabilistic_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_fail = res.unwrap();
     assert_eq!(res_fail, PropagatingEffect::Probabilistic(0.0));
 }
 
@@ -143,9 +143,9 @@ fn test_evaluate_mixed_propagation() {
 
     // Case 1: All succeed, chain remains deterministically true.
     let effect_success = PropagatingEffect::Numerical(0.99);
-    let res_success = map
-        .evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5)
-        .unwrap();
+    let res = map.evaluate_mixed_propagation(&effect_success, &AggregateLogic::All, 0.5);
+    assert!(res.is_ok());
+    let res_success = res.unwrap();
     // All mixed cased evaluate
     assert_eq!(res_success, PropagatingEffect::Deterministic(true));
 }
@@ -156,8 +156,8 @@ fn test_evaluate_mixed_propagation_err() {
 
     //
     let effect_fail = PropagatingEffect::Numerical(0.1);
-    let res_fail = map.evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5);
-    assert!(res_fail.is_err());
+    let res = map.evaluate_mixed_propagation(&effect_fail, &AggregateLogic::All, 0.5);
+    assert!(res.is_err());
 }
 
 #[test]
@@ -166,7 +166,9 @@ fn test_explain() {
     activate_all_causes(&map);
 
     let single_explanation = "Causaloid: 1 'tests whether data exceeds threshold of 0.55' evaluated to: PropagatingEffect::Deterministic(true)";
-    let actual = map.explain().unwrap();
+    let res = map.explain();
+    assert!(res.is_ok());
+    let actual = res.unwrap();
 
     // HashMap iteration order is not guaranteed.
     // We check that the explanation for each of the 3 causes is present.