Add tests for OutputEvaluator

Author: peanutfun

climada/test/test_util_calibrate.py

@@ -7,10 +7,11 @@
 import numpy.testing as npt
 from scipy.optimize import NonlinearConstraint
 from sklearn.metrics import mean_squared_error
+from matplotlib.axes import Axes
 
 from climada.entity import ImpactFuncSet, ImpactFunc
 
-from climada.util.calibrate import Input, ScipyMinimizeOptimizer, BayesianOptimizer
+from climada.util.calibrate import Input, ScipyMinimizeOptimizer, BayesianOptimizer, OutputEvaluator
 
 from climada.util.calibrate.test.test_base import hazard, exposure
 
@@ -201,3 +202,17 @@ def test_multiple_constrained(self):
             (p_allowed["intensity_1"] < p_allowed["intensity_2"]).to_numpy(),
             np.full_like(p_allowed["intensity_1"].to_numpy(), True),
         )
+
+    def test_plots(self):
+        """Check if executing the default plots works"""
+        self.input.bounds = {"slope": (-1, 3)}
+        optimizer = BayesianOptimizer(self.input)
+        output = optimizer.run(init_points=10, n_iter=20, random_state=1)
+
+        output_eval = OutputEvaluator(self.input, output)
+        output_eval.impf_set.plot()
+        output_eval.plot_at_event()
+        output_eval.plot_at_region()
+        ax = output_eval.plot_impf_variability()
+        self.assertIsInstance(ax, Axes)
+        output_eval.plot_event_region_heatmap()

climada/util/calibrate/test/test_base.py

@@ -1,7 +1,7 @@
 """Tests for calibration module"""
 
 import unittest
-from unittest.mock import create_autospec
+from unittest.mock import patch, create_autospec, MagicMock
 
 import numpy as np
 import numpy.testing as npt
@@ -10,9 +10,10 @@
 
 from climada.entity import Exposures, ImpactFunc, ImpactFuncSet
 from climada.hazard import Hazard, Centroids
+from climada.engine import ImpactCalc
 
-from climada.util.calibrate import Input
-from climada.util.calibrate.base import Optimizer
+from climada.util.calibrate import Input, OutputEvaluator
+from climada.util.calibrate.base import Optimizer, Output
 
 
 class ConcreteOptimizer(Optimizer):
@@ -138,14 +139,11 @@ def test_align_impact(self):
         )
         pd.testing.assert_frame_equal(data_aligned, data_aligned_test)
         impact_df_aligned_test = pd.DataFrame(
-                data={"col1": [0, 0, 0], "col2": [0, 1, 0], "col3": [0, 0, 0]},
-                index=[0, 1, 2],
-                dtype="float",
-            )
-        pd.testing.assert_frame_equal(
-            impact_df_aligned,
-            impact_df_aligned_test
+            data={"col1": [0, 0, 0], "col2": [0, 1, 0], "col3": [0, 0, 0]},
+            index=[0, 1, 2],
+            dtype="float",
         )
+        pd.testing.assert_frame_equal(impact_df_aligned, impact_df_aligned_test)
 
         # Check fillna
         data_aligned, impact_df_aligned = input.impact_to_aligned_df(None, fillna=0)
@@ -189,8 +187,46 @@ def setUp(self):
         self.optimizer = ConcreteOptimizer(self.input)
 
 
+class TestOutputEvaluator(unittest.TestCase):
+    """Test the output evaluator"""
+
+    def setUp(self):
+        """Create Input and Output"""
+        self.input = Input(
+            hazard=hazard(),
+            exposure=exposure(),
+            data=pd.DataFrame(),
+            impact_func_creator=MagicMock(),
+            # Should not be called
+            impact_to_dataframe=lambda _: None,
+            cost_func=lambda _: None,
+        )
+        self.output = Output(params={"p1": 1, "p2": 2.0}, target=0.0)
+
+    @patch("climada.util.calibrate.base.ImpactCalc", autospec=True)
+    def test_init(self, mock):
+        """Test initialization"""
+        self.input.exposure.value_unit = "my_unit"
+        self.input.impact_func_creator.return_value = "impact_func"
+        impact_calc_mock = MagicMock(ImpactCalc)
+        mock.return_value = impact_calc_mock
+        impact_calc_mock.impact = MagicMock()
+        impact_calc_mock.impact.return_value = "impact"
+
+        out_eval = OutputEvaluator(self.input, self.output)
+        self.assertEqual(out_eval.impf_set, "impact_func")
+        self.assertEqual(out_eval.impact, "impact")
+        self.assertEqual(out_eval._impact_label, "Impact [my_unit]")
+
+        self.input.impact_func_creator.assert_called_with(p1=1, p2=2.0)
+        mock.assert_called_with(
+            self.input.exposure, "impact_func", self.input.hazard
+        )
+
+
 # Execute Tests
 if __name__ == "__main__":
     TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInputPostInit)
     TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestOptimizer))
+    TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestOutputEvaluator))
     unittest.TextTestRunner(verbosity=2).run(TESTS)