Test/81 definition of testcases

koswat/calculations/outside_slope_reinforcement/cofferdam/cofferdam_input_profile.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+from dataclasses import dataclass
+import math
 
 from koswat.calculations.protocols import ReinforcementProfileProtocol
 from koswat.dike.profile.koswat_input_profile_base import KoswatInputProfileBase
 
 
+@dataclass
 class CofferDamInputProfile(KoswatInputProfileBase, ReinforcementProfileProtocol):
-    length_coffer_dam: float
+    length_coffer_dam: float = math.nan

koswat/calculations/standard_reinforcement/piping_wall/piping_wall_input_profile.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+from dataclasses import dataclass
+import math
 
 from koswat.calculations.protocols import ReinforcementInputProfileProtocol
 from koswat.dike.profile.koswat_input_profile_base import KoswatInputProfileBase
 
 
+@dataclass
 class PipingWallInputProfile(KoswatInputProfileBase, ReinforcementInputProfileProtocol):
-    length_piping_wall: float
+    length_piping_wall: float = math.nan

koswat/calculations/standard_reinforcement/soil/soil_input_profile.py

@@ -1,6 +1,7 @@
+from dataclasses import dataclass
 from koswat.calculations.protocols import ReinforcementInputProfileProtocol
 from koswat.dike.profile.koswat_input_profile_base import KoswatInputProfileBase
 
-
+@dataclass
 class SoilInputProfile(KoswatInputProfileBase, ReinforcementInputProfileProtocol):
     pass

koswat/calculations/standard_reinforcement/stability_wall/stability_wall_input_profile.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+from dataclasses import dataclass
+import math
 
 from koswat.calculations.protocols import ReinforcementProfileProtocol
 from koswat.dike.profile.koswat_input_profile_base import KoswatInputProfileBase
 
 
+@dataclass
 class StabilityWallInputProfile(KoswatInputProfileBase, ReinforcementProfileProtocol):
-    length_stability_wall: float
+    length_stability_wall: float = math.nan

koswat/configuration/settings/koswat_scenario.py

@@ -1,27 +1,20 @@
 from __future__ import annotations
+from dataclasses import dataclass
 
 import math
 
 from koswat.configuration.koswat_config_protocol import KoswatConfigProtocol
 
 
+@dataclass
 class KoswatScenario(KoswatConfigProtocol):
-    scenario_name: str
-    scenario_section: str
-    d_h: float
-    d_s: float
-    d_p: float
-    kruin_breedte: float
-    buiten_talud: float
-
-    def __init__(self) -> None:
-        self.scenario_name = ""
-        self.scenario_section = ""
-        self.d_h = math.nan
-        self.d_s = math.nan
-        self.d_p = math.nan
-        self.kruin_breedte = math.nan
-        self.buiten_talud = math.nan
+    scenario_name: str = ""
+    scenario_section: str = ""
+    d_h: float = math.nan
+    d_s: float = math.nan
+    d_p: float = math.nan
+    kruin_breedte: float = math.nan
+    buiten_talud: float = math.nan
 
     def is_valid(self) -> bool:
         return (

koswat/cost_report/io/csv/summary_matrix_csv_fom_builder.py

@@ -80,6 +80,10 @@ def location_as_row(
             _location_as_row.extend(_m_values)
             return _location_as_row
 
+        if not any(available_locations):
+            logging.warning("No locations specified for the report.")
+            return [[]]
+
         # Initiate locations matrix.
         # Note: Not the most efficient way, but I want to keep the reports with only
         # the locations that support one (or more) profile reinforcements.

koswat/dike/profile/koswat_input_profile_base.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
+from dataclasses import dataclass
+import math
 
 from koswat.dike.koswat_input_profile_protocol import KoswatInputProfileProtocol
 
 
+@dataclass
 class KoswatInputProfileBase(KoswatInputProfileProtocol):
-    dike_section: str
-    buiten_maaiveld: float
-    buiten_talud: float
-    buiten_berm_hoogte: float
-    buiten_berm_breedte: float
-    kruin_hoogte: float
-    kruin_breedte: float
-    binnen_talud: float
-    binnen_berm_hoogte: float
-    binnen_berm_breedte: float
-    binnen_maaiveld: float
+    dike_section: str = ""
+    buiten_maaiveld: float = math.nan
+    buiten_talud: float = math.nan
+    buiten_berm_hoogte: float = math.nan
+    buiten_berm_breedte: float = math.nan
+    kruin_hoogte: float = math.nan
+    kruin_breedte: float = math.nan
+    binnen_talud: float = math.nan
+    binnen_berm_hoogte: float = math.nan
+    binnen_berm_breedte: float = math.nan
+    binnen_maaiveld: float = math.nan

koswat/dike/surroundings/wrapper/surroundings_wrapper.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from shapely.geometry import Point
 
 from koswat.dike.surroundings.buildings_polderside.koswat_buildings_polderside import (
@@ -60,7 +58,7 @@ def __init__(self) -> None:
         self.roads_class_unknown_dikeside = None
 
     @property
-    def locations(self) -> List[PointSurroundings]:
+    def locations(self) -> list[PointSurroundings]:
         """
         Each location represents 1 meter in a real scale map.
 
@@ -71,7 +69,7 @@ def locations(self) -> List[PointSurroundings]:
             return []
         return self.buldings_polderside.points
 
-    def get_locations_after_distance(self, distance: float) -> List[Point]:
+    def get_locations_after_distance(self, distance: float) -> list[Point]:
         """
         Gets all locations which are safe from buildings in a radius of `distance`.
 
@@ -87,4 +85,7 @@ def is_at_safe_distance(point_surroundings: PointSurroundings) -> bool:
                 return True
             return distance < point_surroundings.distance_to_buildings[0]
 
+        if not self.buldings_polderside:
+            return []
+
         return list(filter(is_at_safe_distance, self.buldings_polderside.points))

pyproject.toml

@@ -37,6 +37,7 @@ pytest = "^7.2.1"
 pytest-cov = "^3.0.0"
 coverage = "^6.4.4"
 teamcity-messages = "^1.32"
+opencv-python = "^4.8.1.78"
 
 [tool.poetry.group.dev.dependencies]
 black = "^22.8.0"

tests/acceptance_scenarios/acceptance_test_scenario_cases.py

@@ -0,0 +1,44 @@
+from tests.acceptance_scenarios.acceptance_test_scenario_dataclasses import (
+    AcceptanceTestScenarioCombinations,
+)
+from tests.acceptance_scenarios.koswat_input_profile_base_cases import (
+    AcceptanceTestInputProfileCases,
+)
+from tests.acceptance_scenarios.koswat_scenario_test_cases import (
+    Dijk1ScenarioCases,
+    ScenarioCases,
+)
+from tests.acceptance_scenarios.layers_cases import LayersCases
+
+acceptance_test_combinations = [
+    AcceptanceTestScenarioCombinations(
+        profile_case=AcceptanceTestInputProfileCases.profile_dijk1,
+        layers_cases=[LayersCases.with_acceptance_criteria],
+        scenario_cases=[
+            Dijk1ScenarioCases.s1a_dh,
+            Dijk1ScenarioCases.s1b_ds,
+            Dijk1ScenarioCases.s1c_dp,
+            Dijk1ScenarioCases.s1d_dhds,
+            Dijk1ScenarioCases.s1e_dhdp,
+            Dijk1ScenarioCases.s1f_dsdp,
+            Dijk1ScenarioCases.s1g_dhdsdp,
+            Dijk1ScenarioCases.s2a_dh,
+            Dijk1ScenarioCases.s2b_ds,
+            Dijk1ScenarioCases.s2c_dp,
+            Dijk1ScenarioCases.s2d_dhds,
+            Dijk1ScenarioCases.s2e_dhdp,
+            Dijk1ScenarioCases.s2f_dsdp,
+            Dijk1ScenarioCases.s2g_dhdsdp,
+        ],
+    ),
+    AcceptanceTestScenarioCombinations(
+        profile_case=AcceptanceTestInputProfileCases.profile_dijk2,
+        layers_cases=[LayersCases.with_acceptance_criteria],
+        scenario_cases=[ScenarioCases.default],
+    ),
+    AcceptanceTestScenarioCombinations(
+        profile_case=AcceptanceTestInputProfileCases.profile_dijk3,
+        layers_cases=[LayersCases.with_acceptance_criteria],
+        scenario_cases=[ScenarioCases.default],
+    ),
+]

tests/acceptance_scenarios/acceptance_test_scenario_dataclasses.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+from koswat.configuration.settings.koswat_scenario import KoswatScenario
+from koswat.dike.koswat_profile_protocol import KoswatProfileProtocol
+from koswat.dike.profile.koswat_input_profile_base import KoswatInputProfileBase
+from itertools import product
+from koswat.dike.profile.koswat_profile import KoswatProfileBase
+
+from koswat.dike.profile.koswat_profile_builder import KoswatProfileBuilder
+from tests import test_data
+
+
+@dataclass
+class LayersTestCase:
+    layers_dict: dict
+    case_name: str
+
+
+@dataclass
+class AcceptanceTestScenario:
+    profile_case: KoswatProfileProtocol
+    scenario_case: KoswatScenario
+    layer_case: LayersTestCase
+
+    @property
+    def case_name(self) -> str:
+        return "case_{}_{}_{}".format(
+            self.profile_case.input_data.dike_section,
+            self.scenario_case.scenario_name,
+            self.layer_case.case_name,
+        )
+
+    @property
+    def reference_data_dir(self) -> Path:
+        return test_data.joinpath("acceptance_reference_data", self.case_name)
+
+
+@dataclass
+class AcceptanceTestScenarioCombinations:
+    profile_case: KoswatInputProfileBase
+    layers_cases: list[LayersTestCase]
+    scenario_cases: list[KoswatScenario]
+
+    def get_test_cases(self) -> list[pytest.param]:
+        def to_pytest_case(
+            test_scenario: tuple[KoswatInputProfileBase, LayersTestCase, KoswatScenario]
+        ) -> pytest.param:
+            _profile_case, _layer_case, _scenario_case = test_scenario
+            _input_profile_case = KoswatProfileBuilder.with_data(
+                dict(
+                    input_profile_data=_profile_case,
+                    layers_data=_layer_case.layers_dict,
+                    profile_type=KoswatProfileBase,
+                )
+            ).build()
+            _test_case = AcceptanceTestScenario(
+                profile_case=_input_profile_case,
+                layer_case=_layer_case,
+                scenario_case=_scenario_case,
+            )
+            return pytest.param(_test_case, id=_test_case.case_name)
+
+        _cases = [
+            [self.profile_case],
+            self.layers_cases,
+            self.scenario_cases,
+        ]
+        return list(map(to_pytest_case, product(*_cases)))
+
+    @staticmethod
+    def get_all_cases(
+        list_combinations: list[AcceptanceTestScenarioCombinations],
+    ) -> list[pytest.param]:
+        # Gets all cases available.
+        # Python trick by using the `sum` operator to flatten lists.
+        return sum(map(lambda x: x.get_test_cases(), list_combinations), [])

tests/acceptance_scenarios/cases_protocol.py

@@ -0,0 +1,6 @@
+from typing import Protocol
+import pytest
+
+
+class CasesProtocol(Protocol):
+    cases: list[pytest.param]

tests/acceptance_scenarios/initial_characteristic_points_cases.py

@@ -0,0 +1,30 @@
+import pytest
+from tests.acceptance_scenarios.cases_protocol import CasesProtocol
+from shapely.geometry.point import Point
+
+
+class InitialPointsLookup(CasesProtocol):
+    default = [
+        Point(-18.0, 0.0),
+        Point(-18.0, 0.0),
+        Point(-18.0, 0.0),
+        Point(0.0, 6.0),
+        Point(5.0, 6.0),
+        Point(23.0, 0.0),
+        Point(23.0, 0.0),
+        Point(23.0, 0.0),
+    ]
+    calc_profile_scenario_2 = [
+        Point(-24, 0),
+        Point(-24, 0),
+        Point(-24, 0),
+        Point(2, 6.5),
+        Point(7, 6.5),
+        Point(28.60, 2.6),
+        Point(82.60, 2.6),
+        Point(97, 0),
+    ]
+    cases = [
+        pytest.param(default, id="Default initial profile."),
+        pytest.param(calc_profile_scenario_2, id="Scenario 2 calculated profile."),
+    ]