add simulation behaviour tests

synergine2/cycle.py

 from synergine2.simulation import Subject
 from synergine2.simulation import Simulation
 from synergine2.simulation import SubjectBehaviour
+from synergine2.simulation import SimulationBehaviour
 from synergine2.simulation import SubjectMechanism
+from synergine2.simulation import SimulationMechanism
 from synergine2.simulation import Event
 from synergine2.utils import time_it
 
     def _job_simulation(self, worker_id: int, process_count: int) -> typing.Dict[int, typing.Dict[str, typing.Any]]:
         self.logger.info('Simulation computing (worker {})'.format(worker_id))
 
-        mechanisms = self.simulation.mechanisms.values()
+        behaviours = self.get_simulation_active_behaviours()
+        mechanisms = self.get_mechanisms_from_behaviours(behaviours)
         mechanisms_data = {}
         behaviours_data = {}
 
         behaviours = []
         for behaviour in subject.behaviours.values():
             if behaviour.is_skip(self.current_cycle):
-                self.logger.debug('Simulation: behaviour {} skip'.format(
+                self.logger.debug('Subject {}: behaviour {} skip'.format(
+                    str(subject.id),
                     str(type(behaviour)),
                 ))
             else:
                     if isinstance(subject_mechanism, behaviour_mechanism_class):
                         mechanisms.add(subject_mechanism)
         return list(mechanisms)
+
+    def get_simulation_active_behaviours(self) -> typing.List[SimulationBehaviour]:
+        behaviours = []
+        for behaviour in self.simulation.behaviours.values():
+            if behaviour.is_skip(self.current_cycle):
+                self.logger.debug('Simulation: behaviour {} skip'.format(
+                    str(type(behaviour)),
+                ))
+            else:
+                behaviours.append(behaviour)
+        return behaviours
+
+    def get_mechanisms_from_behaviours(
+        self,
+        behaviours: typing.List[SimulationBehaviour],
+    ) -> typing.List[SimulationMechanism]:
+        # TODO BS 20180109: Not very optimized ... could be enhanced
+        mechanisms = set()
+        for simulation_mechanism in self.simulation.mechanisms.values():
+            for simulation_behaviour in behaviours:
+                for simulation_mechanism_class in simulation_behaviour.use:
+                    if isinstance(simulation_mechanism, simulation_mechanism_class):
+                        mechanisms.add(simulation_mechanism)
+        return list(mechanisms)

tests/test_simulation.py

         do_nothing_process_manager: ProcessManager,
     ):
         shared.reset()
+        global called
+        called = 0
+
+        class MySimulationMechanism(SimulationMechanism):
+            def run(self, process_number: int = None, process_count: int = None):
+                global called
+                called += 1
+                return {'foo': 42}
 
-        pass
+        class MySimulationBehaviour1(SimulationBehaviour):
+            use = [MySimulationMechanism]
+
+            @property
+            def cycle_frequency(self):
+                return 2
+
+            def run(self, data):
+                return {'bar': data[MySimulationMechanism]['foo'] + 100}
+
+        class MySimulation(Simulation):
+            behaviours_classes = [MySimulationBehaviour1]
+
+        simulation = MySimulation(config)
+        subjects = Subjects(simulation=simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+
+        cycle_manager.current_cycle = 0
+        cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert called == 1
+
+        cycle_manager.current_cycle = 1
+        cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert called == 1
+
+        cycle_manager.current_cycle = 2
+        cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert called == 2
+
+        cycle_manager.current_cycle = 3
+        cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert called == 2
 
     def test_mechanism_not_called_if_subject_behavior_timebase_not_active_yet(
         self,
         do_nothing_process_manager: ProcessManager,
     ):
         shared.reset()
+        global called
+        called = 0
+
+        class MySubjectMechanism(SubjectMechanism):
+            def run(self):
+                global called
+                called += 1
+                return {'foo': 42}
 
-        pass
+        class MySubjectBehaviour1(SubjectBehaviour):
+            use = [MySubjectMechanism]
+
+            @property
+            def seconds_frequency(self):
+                return 1.0
+
+            def run(self, data):
+                self.last_execution_time = time.time()
+                return {'bar': data[MySubjectMechanism]['foo'] + 100}
+
+        class MySubject(Subject):
+            behaviours_classes = [MySubjectBehaviour1]
+
+        simulation = Simulation(config)
+        my_subject = MySubject(config, simulation)
+        subjects = Subjects(simulation=simulation)
+        subjects.append(my_subject)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0)):
+            cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 500000)):
+            cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 700000)):
+            cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 1, 500000)):
+            cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert called == 2
 
     def test_mechanism_not_called_if_simulation_behavior_timebase_not_active_yet(
         self,
         do_nothing_process_manager: ProcessManager,
     ):
+
         shared.reset()
+        global called
+        called = 0
+
+        class MySimulationMechanism(SimulationMechanism):
+            def run(self, process_number: int = None, process_count: int = None):
+                global called
+                called += 1
+                return {'foo': 42}
+
+        class MySimulationBehaviour1(SimulationBehaviour):
+            use = [MySimulationMechanism]
+
+            @property
+            def seconds_frequency(self):
+                return 1.0
+
+            def run(self, data):
+                self.last_execution_time = time.time()
+                return {'bar': data[MySimulationMechanism]['foo'] + 100}
+
+        class MySimulation(Simulation):
+            behaviours_classes = [MySimulationBehaviour1]
+
+        simulation = MySimulation(config)
+        subjects = Subjects(simulation=simulation)
+        simulation.subjects = subjects
 
-        pass
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 0)):
+            cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 500000)):
+            cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 700000)):
+            cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert called == 1
+
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 1, 500000)):
+            cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert called == 2
 
 
 # TODO: Test Simulation mechanism parralelisation