refactor clashing name changes

Author: christopher-wild

causal_testing/json_front/json_class.py

@@ -92,7 +92,7 @@ def _create_abstract_test_case(self, test, mutates, effects):
             treatment_variable=treatment_var,
             expected_causal_effect={
                 self.scenario.variables[variable]: effects[effect]
-                for variable, effect in test["expectedEffect"].items()
+                for variable, effect in test["expected_effect"].items()
             },
             effect_modifiers={self.scenario.variables[v] for v in test["effect_modifiers"]}
             if "effect_modifiers" in test
@@ -120,23 +120,23 @@ def run_json_tests(self, effects: dict, estimators: dict, f_flag: bool = False,
                 if test["estimate_type"] == "coefficient":
                     base_test_case = BaseTestCase(
                         treatment_variable=next(self.scenario.variables[v] for v in test["mutations"]),
-                        outcome_variable=next(self.scenario.variables[v] for v in test["expectedEffect"]),
+                        outcome_variable=next(self.scenario.variables[v] for v in test["expected_effect"]),
                         effect=test.get("effect", "direct"),
                     )
-                    assert len(test["expectedEffect"]) == 1, "Can only have one expected effect."
+                    assert len(test["expected_effect"]) == 1, "Can only have one expected effect."
                     concrete_tests = [
                         CausalTestCase(
                             base_test_case=base_test_case,
                             expected_causal_effect=next(
-                                effects[effect] for variable, effect in test["expectedEffect"].items()
+                                effects[effect] for variable, effect in test["expected_effect"].items()
                             ),
                             estimate_type="coefficient",
                             effect_modifier_configuration={
                                 self.scenario.variables[v] for v in test.get("effect_modifiers", [])
                             },
                         )
                     ]
-                    failures = self._execute_tests(concrete_tests, estimators, test, f_flag)
+                    failures = self._execute_tests(concrete_tests, test, f_flag)
                     msg = (
                             f"Executing test: {test['name']} \n"
                             + f"  {concrete_tests[0]} \n"
@@ -145,7 +145,8 @@ def run_json_tests(self, effects: dict, estimators: dict, f_flag: bool = False,
                 else:
                     abstract_test = self._create_abstract_test_case(test, mutates, effects)
                     concrete_tests, dummy = abstract_test.generate_concrete_tests(5, 0.05)
-                    failures = self._execute_tests(concrete_tests, estimators, test, f_flag)
+                    failures = self._execute_tests(concrete_tests, test, f_flag)
+
                     msg = (
                             f"Executing test: {test['name']} \n"
                             + "  abstract_test \n"
@@ -155,35 +156,35 @@ def run_json_tests(self, effects: dict, estimators: dict, f_flag: bool = False,
                             + f"  {failures}/{len(concrete_tests)} failed for {test['name']}"
                     )
                 self._append_to_file(msg, logging.INFO)
-                else:
-                    outcome_variable = next(
-                        iter(test["expected_effect"])
-                    )  # Take first key from dictionary of expected effect
-                    base_test_case = BaseTestCase(
-                        treatment_variable=self.variables["inputs"][test["treatment_variable"]],
-                        outcome_variable=self.variables["outputs"][outcome_variable],
-                    )
-
-                    causal_test_case = CausalTestCase(
-                        base_test_case=base_test_case,
-                        expected_causal_effect=effects[test["expected_effect"][outcome_variable]],
-                        control_value=test["control_value"],
-                        treatment_value=test["treatment_value"],
-                        estimate_type=test["estimate_type"],
-                    )
-                    if self._execute_test_case(causal_test_case=causal_test_case, test=test, f_flag=f_flag):
-                        result = "failed"
-                    else:
-                        result = "passed"
+            else:
+                outcome_variable = next(
+                    iter(test["expected_effect"])
+                )  # Take first key from dictionary of expected effect
+                base_test_case = BaseTestCase(
+                    treatment_variable=self.variables["inputs"][test["treatment_variable"]],
+                    outcome_variable=self.variables["outputs"][outcome_variable],
+                )
 
-                    msg = (
-                            f"Executing concrete test: {test['name']} \n"
-                            + f"treatment variable: {test['treatment_variable']} \n"
-                            + f"outcome_variable = {outcome_variable} \n"
-                            + f"control value = {test['control_value']}, treatment value = {test['treatment_value']} \n"
-                            + f"result - {result}"
-                    )
-                    self._append_to_file(msg, logging.INFO)
+                causal_test_case = CausalTestCase(
+                    base_test_case=base_test_case,
+                    expected_causal_effect=effects[test["expected_effect"][outcome_variable]],
+                    control_value=test["control_value"],
+                    treatment_value=test["treatment_value"],
+                    estimate_type=test["estimate_type"],
+                )
+                if self._execute_test_case(causal_test_case=causal_test_case, test=test, f_flag=f_flag):
+                    result = "failed"
+                else:
+                    result = "passed"
+
+                msg = (
+                        f"Executing concrete test: {test['name']} \n"
+                        + f"treatment variable: {test['treatment_variable']} \n"
+                        + f"outcome_variable = {outcome_variable} \n"
+                        + f"control value = {test['control_value']}, treatment value = {test['treatment_value']} \n"
+                        + f"result - {result}"
+                )
+                self._append_to_file(msg, logging.INFO)
 
     def _create_abstract_test_case(self, test, mutates, effects):
         assert len(test["mutations"]) == 1

causal_testing/specification/metamorphic_relation.py

@@ -141,7 +141,7 @@ def to_json_stub(self, skip=True) -> dict:
             "estimate_type": "coefficient",
             "effect": "direct",
             "mutations": [self.treatment_var],
-            "expectedEffect": {self.output_var: "SomeEffect"},
+            "expected_effect": {self.output_var: "SomeEffect"},
             "skip": skip,
         }
 
@@ -173,7 +173,7 @@ def to_json_stub(self, skip=True) -> dict:
             "estimate_type": "coefficient",
             "effect": "direct",
             "mutations": [self.treatment_var],
-            "expectedEffect": {self.output_var: "NoEffect"},
+            "expected_effect": {self.output_var: "NoEffect"},
             "skip": skip,
         }
 

tests/json_front_tests/test_json_class.py

@@ -111,7 +111,7 @@ def test_generate_coefficient_tests_from_json(self):
                     "estimator": "LinearRegressionEstimator",
                     "estimate_type": "coefficient",
                     "effect_modifiers": [],
-                    "expectedEffect": {"test_output": "NoEffect"},
+                    "expected_effect": {"test_output": "NoEffect"},
                     "skip": False,
                 }
             ]
@@ -120,7 +120,7 @@ def test_generate_coefficient_tests_from_json(self):
         effects = {"NoEffect": NoEffect()}
         estimators = {"LinearRegressionEstimator": LinearRegressionEstimator}
 
-        self.json_class.generate_tests(effects, {}, estimators, False)
+        self.json_class.run_json_tests(effects=effects, mutates={}, estimators=estimators, f_flag=False)
 
         # Test that the final log message prints that failed tests are printed, which is expected behaviour for this scenario
         with open("temp_out.txt", "r") as reader:
@@ -149,7 +149,7 @@ def test_run_json_tests_from_json(self):
         }
         estimators = {"LinearRegressionEstimator": LinearRegressionEstimator}
 
-        self.json_class.run_json_tests(effects, estimators, False, mutates)
+        self.json_class.run_json_tests(effects=effects, estimators=estimators, f_flag=False, mutates=mutates)
 
         # Test that the final log message prints that failed tests are printed, which is expected behaviour for this scenario
         with open("temp_out.txt", "r") as reader:
@@ -165,7 +165,7 @@ def test_generate_tests_from_json_no_dist(self):
                     "estimator": "LinearRegressionEstimator",
                     "estimate_type": "ate",
                     "effect_modifiers": [],
-                    "expectedEffect": {"test_output": "NoEffect"},
+                    "expected_effect": {"test_output": "NoEffect"},
                     "skip": False,
                 }
             ]
@@ -178,7 +178,7 @@ def test_generate_tests_from_json_no_dist(self):
         }
         estimators = {"LinearRegressionEstimator": LinearRegressionEstimator}
 
-        self.json_class.generate_tests(effects, mutates, estimators, False)
+        self.json_class.run_json_tests(effects=effects, mutates=mutates, estimators=estimators, f_flag=False)
 
         # Test that the final log message prints that failed tests are printed, which is expected behaviour for this scenario
         with open("temp_out.txt", "r") as reader:

tests/specification_tests/test_metamorphic_relations.py

@@ -115,7 +115,7 @@ def test_should_not_cause_json_stub(self):
                 "effect": "direct",
                 "estimate_type": "coefficient",
                 "estimator": "LinearRegressionEstimator",
-                "expectedEffect": {"Z": "NoEffect"},
+                "expected_effect": {"Z": "NoEffect"},
                 "mutations": ["X1"],
                 "name": "X1 _||_ Z",
                 "skip": True,
@@ -138,7 +138,7 @@ def test_should_cause_json_stub(self):
                 "effect": "direct",
                 "estimate_type": "coefficient",
                 "estimator": "LinearRegressionEstimator",
-                "expectedEffect": {"Z": "SomeEffect"},
+                "expected_effect": {"Z": "SomeEffect"},
                 "mutations": ["X1"],
                 "name": "X1 --> Z",
                 "skip": True,