Shifts test to pytest

Author: spjuhel

climada/trajectories/test/test_impact_calc_strat.py

@@ -20,65 +20,78 @@
 
 """
 
-import unittest
 from unittest.mock import MagicMock, patch
 
+import pytest
+
 from climada.engine import Impact
 from climada.entity import ImpactFuncSet
 from climada.entity.exposures import Exposures
 from climada.hazard import Hazard
 from climada.trajectories import Snapshot
-from climada.trajectories.impact_calc_strat import ImpactCalcComputation
-
-
-class TestImpactCalcComputation(unittest.TestCase):
-    def setUp(self):
-        self.mock_snapshot0 = MagicMock(spec=Snapshot)
-        self.mock_snapshot0.exposure = MagicMock(spec=Exposures)
-        self.mock_snapshot0.hazard = MagicMock(spec=Hazard)
-        self.mock_snapshot0.impfset = MagicMock(spec=ImpactFuncSet)
-        self.mock_snapshot1 = MagicMock(spec=Snapshot)
-        self.mock_snapshot1.exposure = MagicMock(spec=Exposures)
-        self.mock_snapshot1.hazard = MagicMock(spec=Hazard)
-        self.mock_snapshot1.impfset = MagicMock(spec=ImpactFuncSet)
-
-        self.impact_calc_computation = ImpactCalcComputation()
-
-    @patch.object(ImpactCalcComputation, "compute_impacts_pre_transfer")
-    def test_compute_impacts(self, mock_calculate_impacts_for_snapshots):
-        mock_impacts = MagicMock(spec=Impact)
-        mock_calculate_impacts_for_snapshots.return_value = mock_impacts
-
-        result = self.impact_calc_computation.compute_impacts(
-            exp=self.mock_snapshot0.exposure,
-            haz=self.mock_snapshot0.hazard,
-            vul=self.mock_snapshot0.impfset,
-        )
+from climada.trajectories.impact_calc_strat import (
+    ImpactCalcComputation,
+    ImpactComputationStrategy,
+)
+
+# --- Fixtures ---
+
+
+@pytest.fixture
+def mock_snapshot():
+    """Provides a snapshot with mocked exposure, hazard, and impact functions."""
+    snap = MagicMock(spec=Snapshot)
+    snap.exposure = MagicMock(spec=Exposures)
+    snap.hazard = MagicMock(spec=Hazard)
+    snap.impfset = MagicMock(spec=ImpactFuncSet)
+    return snap
 
-        self.assertEqual(result, mock_impacts)
-        mock_calculate_impacts_for_snapshots.assert_called_once_with(
-            self.mock_snapshot0.exposure,
-            self.mock_snapshot0.hazard,
-            self.mock_snapshot0.impfset,
-        )
 
-    def test_calculate_impacts_for_snapshots(self):
-        mock_imp_E0H0 = MagicMock(spec=Impact)
+@pytest.fixture
+def strategy():
+    """Provides an instance of the ImpactCalcComputation strategy."""
+    return ImpactCalcComputation()
 
-        with patch(
-            "climada.trajectories.impact_calc_strat.ImpactCalc"
-        ) as mock_impact_calc:
-            mock_impact_calc.return_value.impact.side_effect = [mock_imp_E0H0]
 
-            result = self.impact_calc_computation.compute_impacts_pre_transfer(
-                exp=self.mock_snapshot0.exposure,
-                haz=self.mock_snapshot0.hazard,
-                vul=self.mock_snapshot0.impfset,
-            )
+# --- Tests ---
+def test_interface_compliance(strategy):
+    """Ensure the class correctly inherits from the Abstract Base Class."""
+    assert isinstance(strategy, ImpactComputationStrategy)
+    assert isinstance(strategy, ImpactCalcComputation)
+
+
+def test_compute_impacts(strategy, mock_snapshot):
+    """Test that compute_impacts calls the pre-transfer method correctly."""
+    mock_impacts = MagicMock(spec=Impact)
+
+    # We patch the ImpactCalc within trajectories
+    with patch("climada.trajectories.impact_calc_strat.ImpactCalc") as mock_ImpactCalc:
+        mock_ImpactCalc.return_value.impact.return_value = mock_impacts
+        result = strategy.compute_impacts(
+            exp=mock_snapshot.exposure,
+            haz=mock_snapshot.hazard,
+            vul=mock_snapshot.impfset,
+        )
+        mock_ImpactCalc.assert_called_once_with(
+            exposures=mock_snapshot.exposure,
+            impfset=mock_snapshot.impfset,
+            hazard=mock_snapshot.hazard,
+        )
+        mock_ImpactCalc.return_value.impact.assert_called_once()
+        assert result == mock_impacts
+
 
-            self.assertEqual(result, mock_imp_E0H0)
+def test_cannot_instantiate_abstract_base_class():
+    """Ensure ImpactComputationStrategy cannot be instantiated directly."""
+    with pytest.raises(TypeError, match="Can't instantiate abstract class"):
+        ImpactComputationStrategy()  # type: ignore
 
 
-if __name__ == "__main__":
-    TESTS = unittest.TestLoader().loadTestsFromTestCase(TestImpactCalcComputation)
-    unittest.TextTestRunner(verbosity=2).run(TESTS)
+@pytest.mark.parametrize("invalid_input", [None, 123, "string"])
+def test_compute_impacts_type_errors(strategy, invalid_input):
+    """
+    Smoke test: Ensure that if ImpactCalc raises errors due to bad input,
+    the strategy correctly propagates them.
+    """
+    with pytest.raises(AttributeError):
+        strategy.compute_impacts(invalid_input, invalid_input, invalid_input)