Fixes isses missed due to "invisible" tests (#291)

* apply fixes for previously missed test cases

Author: Snapex2409

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## latest
 
+- Applied fixes for previously missed test cases due to #290 [#291](https://github.com/precice/micro-manager/pull/291)
 - Fixed non-visible CI test cases on PR interface [#290](https://github.com/precice/micro-manager/pull/290)
 - Moved Simulation Class ownership and loading to Model Manager [#286](https://github.com/precice/micro-manager/pull/286)
 - Added simulation container for more encapsulation [#284](https://github.com/precice/micro-manager/pull/284)

micro_manager/micro_manager.py

@@ -1116,7 +1116,7 @@ def _solve_micro_simulations_with_model_adaptivity(
             sim = self._sim_container[lid]
             res = -1
             if sim is not None:
-                res = self._model_adaptivity_controller.get_sim_class_resolution(sim)
+                res = self._model_manager.get_idx_of_sim(sim)
             output[lid]["model_resolution"] = res
         return output
 

micro_manager/snapshot/snapshot.py

@@ -87,7 +87,7 @@ def solve(self) -> None:
         micro_problem_cls = create_simulation_class(
             self._logger,
             self._micro_problem,
-            self._config.micro_file_name(),
+            self._config.micro_file_names()[0],
             1,
             None,
         )
@@ -261,7 +261,7 @@ def initialize(self) -> None:
         for i in range(self._local_number_of_sims):
             self._global_ids_of_local_sims.append(sim_id)
             sim_id += 1
-        self._micro_problem = load_backend_class(self._config.micro_file_name())
+        self._micro_problem = load_backend_class(self._config.micro_file_names()[0])
 
         self._micro_sims_have_output = False
         if hasattr(self._micro_problem, "output") and callable(

tests/unit/snapshot-config.json

@@ -1,5 +1,5 @@
 {
-    "micro_file_name": "test_snapshot_computation",
+    "micro_file_names": ["test_snapshot_computation"],
     "output_directory": "output",
     "coupling_params": {
         "parameter_file_name": "hdf_files/test_parameter.hdf5",

tests/unit/test_adaptivity_parallel.py

@@ -2,6 +2,7 @@
 from unittest.mock import MagicMock
 
 import numpy as np
+from micro_manager.simulation_container import SimulationContainer
 from mpi4py import MPI
 
 from micro_manager.tools.p2p import get_ranks_of_sims
@@ -60,17 +61,20 @@ def test_update_inactive_sims_global_adaptivity(self):
         self._configurator.adaptivity_similarity_measure = MagicMock(return_value="L1")
 
         sim_cls = create_simulation_class(
-            MagicMock(),
-            MicroSimulation,
-            __file__,
-            1,
-            None,
+            MagicMock(), MicroSimulation, __file__, 1, None, "test_micro_manager"
         )
 
-        adaptivity_controller = GlobalAdaptivityCalculator(
-            self._configurator,
+        container = SimulationContainer()
+        container.initialize(
             5,
+            len(global_ids),
             global_ids,
+            [np.zeros(3) for _ in range(len(global_ids))],
+        )
+
+        adaptivity_controller = GlobalAdaptivityCalculator(
+            self._configurator,
+            sim_container=container,
             participant=MagicMock(),
             base_logger=MagicMock(),
             rank=self._rank,
@@ -93,11 +97,10 @@ def check_for_activation(i, active):
 
         adaptivity_controller._check_for_activation = check_for_activation
 
-        dummy_micro_sims = []
-        for i in global_ids:
-            dummy_micro_sims.append(sim_cls(i))
+        for lid, gid in enumerate(container.local_gids):
+            container[lid] = sim_cls(gid)
 
-        adaptivity_controller._update_inactive_sims(dummy_micro_sims)
+        adaptivity_controller._update_inactive_sims()
 
         self.assertTrue(
             np.array_equal(expected_is_sim_active, adaptivity_controller._is_sim_active)
@@ -110,9 +113,9 @@ def check_for_activation(i, active):
         )
 
         if self._rank == 0:
-            self.assertTrue(np.array_equal([3, 3, 3], dummy_micro_sims[0].get_state()))
+            self.assertTrue(np.array_equal([3, 3, 3], container[0].get_state()))
         elif self._rank == 1:
-            self.assertTrue(np.array_equal([2, 2, 2], dummy_micro_sims[1].get_state()))
+            self.assertTrue(np.array_equal([2, 2, 2], container[1].get_state()))
 
     def test_update_all_active_sims_global_adaptivity(self):
         """
@@ -150,10 +153,17 @@ def test_update_all_active_sims_global_adaptivity(self):
             None,
         )
 
-        adaptivity_controller = GlobalAdaptivityCalculator(
-            self._configurator,
+        container = SimulationContainer()
+        container.initialize(
             5,
+            len(global_ids),
             global_ids,
+            [np.zeros(3) for _ in range(len(global_ids))],
+        )
+
+        adaptivity_controller = GlobalAdaptivityCalculator(
+            self._configurator,
+            sim_container=container,
             participant=MagicMock(),
             base_logger=MagicMock(),
             rank=self._rank,
@@ -164,13 +174,11 @@ def test_update_all_active_sims_global_adaptivity(self):
 
         adaptivity_controller._adaptivity_data_names = ["data1", "data2"]
 
-        dummy_micro_sims = []
-        for i in global_ids:
-            dummy_micro_sims.append(sim_cls(i))
+        for lid, gid in enumerate(container.local_gids):
+            container[lid] = sim_cls(gid)
 
         adaptivity_controller.compute_adaptivity(
             0.1,
-            dummy_micro_sims,
             data_for_adaptivity,
         )
 
@@ -212,10 +220,17 @@ def test_communicate_micro_output(self):
             None,
         )
 
-        adaptivity_controller = GlobalAdaptivityCalculator(
-            self._configurator,
+        container = SimulationContainer()
+        container.initialize(
             5,
+            len(global_ids),
             global_ids,
+            [np.zeros(3) for _ in range(len(global_ids))],
+        )
+
+        adaptivity_controller = GlobalAdaptivityCalculator(
+            self._configurator,
+            sim_container=container,
             participant=MagicMock(),
             base_logger=MagicMock(),
             rank=self._rank,
@@ -250,26 +265,6 @@ def test_get_ranks_of_sims(self):
             global_ids = [3, 4]
             expected_ranks_of_sims = [0, 0, 0, 1, 1]
 
-        sim_cls = create_simulation_class(
-            MagicMock(),
-            MicroSimulation,
-            __file__,
-            1,
-            None,
-        )
-
-        adaptivity_controller = GlobalAdaptivityCalculator(
-            self._configurator,
-            5,
-            global_ids,
-            participant=MagicMock(),
-            base_logger=MagicMock(),
-            rank=self._rank,
-            comm=self._comm,
-            micro_problem_cls=sim_cls,
-            model_manager=ModelManager(),
-        )
-
         actual_ranks_of_sims = get_ranks_of_sims(global_ids, self._rank, self._comm, 5)
 
         self.assertTrue(np.array_equal(expected_ranks_of_sims, actual_ranks_of_sims))

tests/unit/test_load_balancing.py

@@ -277,7 +277,7 @@ def test_redistribute_active_sims_two_ranks(self):
         load_balancer.balance()
 
         actual_global_ids = []  #
-        for lid in container.local_gids:
+        for lid, gid in enumerate(container.local_gids):
             sim = container[lid]
             actual_global_ids.append(sim.get_global_id())
         self.assertListEqual(actual_global_ids, expected_global_ids)
@@ -457,7 +457,7 @@ def test_redistribute_active_sims_four_ranks(self):
         load_balancer.balance()
 
         actual_global_ids = []
-        for lid in container.local_gids:
+        for lid, gid in enumerate(container.local_gids):
             sim = container[lid]
             actual_global_ids.append(sim.get_global_id())
         self.assertListEqual(actual_global_ids, expected_global_ids)

tests/unit/test_micro_manager.py

@@ -140,7 +140,7 @@ def test_config(self):
         self.assertEqual(
             config.precice_config_file_name().split("/")[-1], "dummy-config.xml"
         )
-        self.assertEqual(config.micro_file_name(), "test_micro_manager")
+        self.assertListEqual(config.micro_file_names(), ["test_micro_manager"])
         self.assertEqual(config.macro_mesh_name(), "Macro-Mesh")
         self.assertEqual(config.micro_output_n(), 10)
         self.assertListEqual(config.read_data_names(), self.fake_read_data_names)

tests/unit/test_model_adaptivity.py

@@ -39,6 +39,15 @@ def destroy(self):
 class DummyModelManager:
     def __init__(self):
         self.created_instances = []
+        self.num_models = 2
+        self.models = [
+            DummyModelClass("fine"),
+            DummyModelClass("coarse"),
+        ]
+        self.name_to_idx = {
+            "fine": 0,
+            "coarse": 1,
+        }
 
     def get_instance(self, gid, target_class, *, late_init=False):
         self.created_instances.append(
@@ -50,15 +59,24 @@ def get_instance(self, gid, target_class, *, late_init=False):
         )
         return DummySimulation(target_class.name, gid, late_init=late_init)
 
+    def get_idx_of_sim(self, sim):
+        if sim.name not in self.name_to_idx:
+            raise KeyError("unknown sim type")
+        return self.name_to_idx[sim.name]
+
+    def get_cls_by_idx(self, idx):
+        return self.models[idx]
+
+    def get_cls_by_name(self, name):
+        if name not in self.name_to_idx:
+            raise KeyError("unknown model name")
+        return self.models[self.name_to_idx[name]]
+
 
 class TestModelAdaptivity(TestCase):
     def _make_controller(self, container, switching_func):
         controller = ModelAdaptivity.__new__(ModelAdaptivity)
         controller._switching_func = switching_func
-        controller._model_classes = [
-            DummyModelClass("fine"),
-            DummyModelClass("coarse"),
-        ]
         controller._sim_container = container
         controller._model_manager = DummyModelManager()
         controller._comm = MPI.COMM_SELF
@@ -150,13 +168,14 @@ def switching_function(resolution, location, t, input, prev_output):
         manager._mesh_vertex_coords = np.array([[0.0, 0.0, 0.0]])
         manager._t = 1.0
         manager._sim_container = container
+        manager._model_manager = controller._model_manager
 
         solve_calls = []
 
         def solve_variant(micro_sims_input, dt, computed_outputs):
             solve_calls.append(
                 {
-                    "sim_name": manager._micro_sims[0].name,
+                    "sim_name": manager._sim_container[0].name,
                     "computed_outputs": computed_outputs.copy(),
                 }
             )
@@ -201,6 +220,7 @@ def test_manager_loop_exits_on_invalid_switch_request(self):
         manager._mesh_vertex_coords = np.array([[0.0, 0.0, 0.0]])
         manager._t = 1.0
         manager._sim_container = container
+        manager._model_manager = controller._model_manager
 
         solve_calls = []
 

tests/unit/test_snapshot_computation.py

@@ -150,7 +150,7 @@ def test_config(self):
         self.assertEqual(
             config.parameter_file_name().split("/")[-1], "test_parameter.hdf5"
         )
-        self.assertEqual(config.micro_file_name(), "test_snapshot_computation")
+        self.assertListEqual(config.micro_file_names(), ["test_snapshot_computation"])
         self.assertListEqual(config.read_data_names(), self.fake_read_data_names)
         self.assertListEqual(config.write_data_names(), self.fake_write_data_names)
         self.assertEqual(config.postprocessing_file_name(), "snapshot_post_processing")