Enhance behavior cyclyng and time base + tests. Related to Issue #17

synergine2/cycle.py

             ))
 
         for behaviour in behaviours:
-            behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
-            if self.logger.is_debug:
-                self.logger.debug('{} behaviour produce data: {}'.format(
-                    type(behaviour).__name__,
-                    behaviour_data,
+            if behaviour.is_skip(self.current_cycle):
+                behaviour_data = False
+                self.logger.debug('Simulation: behaviour {} skip'.format(
+                    str(type(behaviour)),
                 ))
+            else:
+                # TODO: Behaviours dependencies
+                behaviour_data = behaviour.run(mechanisms_data)
+                if self.logger.is_debug:
+                    self.logger.debug('{} behaviour produce data: {}'.format(
+                        type(behaviour).__name__,
+                        behaviour_data,
+                    ))
 
             if behaviour_data:
                 behaviours_data[behaviour.__class__] = behaviour_data
                 if behaviour.is_terminated():
                     del subject.behaviours[behaviour_key]
 
-                # We identify behaviour data with it's class to be able to intersect it after subprocess data collect
+                # We identify behaviour data with it's class to be able to intersect
+                # it after subprocess data collect
                 if behaviour.is_skip(self.current_cycle):
                     behaviour_data = False
                     self.logger.debug('Subject {}: behaviour {} skip'.format(
                 else:
                     with time_it() as elapsed_time:
                         behaviour.last_execution_time = time.time()
-                        behaviour_data = behaviour.run(mechanisms_data)  # TODO: Behaviours dependencies
+                        # TODO: Behaviours dependencies
+                        behaviour_data = behaviour.run(mechanisms_data)
                         if self.logger.is_debug:
-                            self.logger.debug('Subject {}: behaviour {} produce data: {} in {}s'.format(
-                                str(type(behaviour)),
-                                str(subject.id),
-                                str(behaviour_data),
-                                elapsed_time.get_time(),
-                            ))
+                            self.logger.debug(
+                                'Subject {}: behaviour {} produce '
+                                'data: {} in {}s'.format(
+                                    str(type(behaviour)),
+                                    str(subject.id),
+                                    str(behaviour_data),
+                                    elapsed_time.get_time(),
+                                )
+                            )
 
                 if behaviour_data:
                     behaviours_data[behaviour.__class__] = behaviour_data

synergine2/simulation.py

 
 class Simulation(BaseObject):
     accepted_subject_class = Subjects
-    behaviours_classes = []
+    behaviours_classes = []  # type: typing.List[typing.Type[SimulationBehaviour]]
 
     subject_classes = shared.create('subject_classes', {})
     collections = shared.create('collections', {})
         self.simulation = simulation
         self.subject = subject
 
-    def run(self):
+    def run(self) -> dict:
         raise NotImplementedError()
 
 
 
 
 class Behaviour(BaseObject):
+    def __init__(self):
+        self.last_execution_time = 0
+
+    @property
+    def cycle_frequency(self) -> typing.Optional[float]:
+        return None
+
+    @property
+    def seconds_frequency(self) -> typing.Optional[float]:
+        """
+        If this behaviour is time based, return here the waiting time between two
+        executions. IMPORTANT: your behaviour have to update it's
+        self.last_execution_time attribute when executed (in `run` method)!
+        :return: float number of period in seconds
+        """
+        return None
+
     def run(self, data):
         raise NotImplementedError()
 
+    def is_skip(self, cycle_number: int) -> bool:
+        """
+        :return: True if behaviour have to be skip this time
+        """
+        cycle_frequency = self.cycle_frequency
+        if cycle_frequency is not None:
+            return not bool(cycle_number % cycle_frequency)
+
+        seconds_frequency = self.seconds_frequency
+        if seconds_frequency is not None:
+            return time.time() - self.last_execution_time <= seconds_frequency
+
+        return False
+
 
 class SubjectBehaviour(Behaviour):
     use = []  # type: typing.List[typing.Type[SubjectMechanism]]
             simulation: Simulation,
             subject: Subject,
     ):
+        super().__init__()
         self.config = config
         self.simulation = simulation
         self.subject = subject
-        self.last_execution_time = 0
-
-    @property
-    def cycle_frequency(self) -> typing.Optional[float]:
-        return None
-
-    @property
-    def seconds_frequency(self) -> typing.Optional[float]:
-        return None
 
     def is_terminated(self) -> bool:
         """
         """
         return False
 
-    def is_skip(self, cycle_number: int) -> bool:
-        """
-        :return: True if behaviour have to be skip this time
-        """
-        if self.cycle_frequency is not None:
-            return not bool(cycle_number % self.cycle_frequency)
-
-        if self.seconds_frequency is not None:
-            return time.time() - self.last_execution_time <= self.seconds_frequency
-
-        return False
-
-    def run(self, data):
+    def run(self, data) -> object:
         """
         Method called in subprocess.
         If return equivalent to False, behaviour produce nothing.
 
 
 class SimulationBehaviour(Behaviour):
-    frequency = 1
-    use = []
+    use = []  # type: typing.List[typing.Type[SimulationMechanism]]
 
     def __init__(
             self,
             config: Config,
             simulation: Simulation,
     ):
+        super().__init__()
         self.config = config
         self.simulation = simulation
 

tests/test_simulation.py

+import datetime
+import time
+
+from synergine2.config import Config
+from synergine2.cycle import CycleManager
+from synergine2.log import SynergineLogger
+from synergine2.processing import ProcessManager
+from synergine2.share import shared
+from synergine2.simulation import Simulation
+from synergine2.simulation import Subjects
+from synergine2.simulation import SubjectBehaviour
+from synergine2.simulation import SubjectMechanism
+from synergine2.simulation import Subject
+from synergine2.simulation import SimulationMechanism
+from synergine2.simulation import SimulationBehaviour
 from tests import BaseTest
 
+from freezegun import freeze_time
+
+config = Config()
+logger = SynergineLogger('test')
+
+
+class MySubjectMechanism(SubjectMechanism):
+    def run(self):
+        return {'foo': 42}
+
+
+class MySimulationMechanism(SimulationMechanism):
+    def run(self, process_number: int=None, process_count: int=None):
+        return {'foo': 42}
+
+
+class MySubjectBehaviour(SubjectBehaviour):
+    use = [MySubjectMechanism]
+
+    def run(self, data):
+        return {'bar': data[MySubjectMechanism]['foo'] + 100}
+
+
+class MySimulationBehaviour(SimulationBehaviour):
+    use = [MySimulationMechanism]
+
+    def run(self, data):
+        return {'bar': data[MySimulationMechanism]['foo'] + 100}
+
+
+class MySimulation(Simulation):
+    behaviours_classes = [MySimulationBehaviour]
+
 
 class TestBehaviours(BaseTest):
-    def test_behaviour_produce_data(self):
+    def test_subject_behaviour_produce_data(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MySubject(Subject):
+            behaviours_classes = [MySubjectBehaviour]
+
+        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,
+        )
+        results_by_subjects = cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert results_by_subjects
+        assert id(my_subject) in results_by_subjects
+        assert MySubjectBehaviour in results_by_subjects[id(my_subject)]
+        assert 'bar' in results_by_subjects[id(my_subject)][MySubjectBehaviour]
+        assert 142 == results_by_subjects[id(my_subject)][MySubjectBehaviour]['bar']
+
+    def test_simulation_behaviour_produce_data(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+        simulation = MySimulation(config)
+        subjects = Subjects(simulation=simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+        data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert data
+        assert MySimulationBehaviour in data
+        assert 'bar' in data[MySimulationBehaviour]
+        assert 142 == data[MySimulationBehaviour]['bar']
+
+    def test_subject_behaviour_cycle_frequency(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MyCycledSubjectBehaviour(MySubjectBehaviour):
+            @property
+            def cycle_frequency(self):
+                return 2
+
+        class MySubject(Subject):
+            behaviours_classes = [MyCycledSubjectBehaviour]
+
+        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,
+        )
+
+        # Cycle 0: behaviour NOT executed
+        cycle_manager.current_cycle = 0
+        results_by_subjects = cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert results_by_subjects
+        assert id(my_subject) in results_by_subjects
+        assert not results_by_subjects[id(my_subject)]
+
+        # Cycle 1: behaviour executed
+        cycle_manager.current_cycle = 1
+        results_by_subjects = cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert results_by_subjects
+        assert id(my_subject) in results_by_subjects
+        assert results_by_subjects[id(my_subject)]
+
+    def test_subject_behaviour_seconds_frequency(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MyTimedSubjectBehaviour(MySubjectBehaviour):
+            @property
+            def seconds_frequency(self):
+                return 1.0
+
+            def run(self, data):
+                self.last_execution_time = time.time()
+                return super().run(data)
+
+        class MySubject(Subject):
+            behaviours_classes = [MyTimedSubjectBehaviour]
+
+        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,
+        )
+
+        # Thirst time, behaviour IS executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0)):
+            data = cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert data
+            assert id(my_subject) in data
+            assert data[id(my_subject)]
+
+        # Less second after: NOT executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 500000)):
+            data = cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert data
+            assert id(my_subject) in data
+            assert not data[id(my_subject)]
+
+        # Less second after: NOT executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 700000)):
+            data = cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert data
+            assert id(my_subject) in data
+            assert not data[id(my_subject)]
+
+        # Less second after: NOT executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 1, 500000)):
+            data = cycle_manager._job_subjects(worker_id=0, process_count=1)
+            assert data
+            assert id(my_subject) in data
+            assert data[id(my_subject)]
+
+    def test_simulation_behaviour_cycle_frequency(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MyCycledSimulationBehaviour(MySimulationBehaviour):
+            @property
+            def cycle_frequency(self):
+                return 2
+
+        class MyCycledSimulation(Simulation):
+            behaviours_classes = [MyCycledSimulationBehaviour]
+
+        simulation = MyCycledSimulation(config)
+        subjects = Subjects(simulation=simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+
+        # Cycle 0: behaviour NOT executed
+        cycle_manager.current_cycle = 0
+        data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert not data
+
+        # Cycle 1: behaviour executed
+        cycle_manager.current_cycle = 1
+        data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+        assert data
+
+    def test_simulation_behaviour_seconds_frequency(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MyTimedSimulationBehaviour(MySimulationBehaviour):
+            @property
+            def seconds_frequency(self):
+                return 1.0
+
+            def run(self, data):
+                self.last_execution_time = time.time()
+                return super().run(data)
+
+        class MyTimedSimulation(Simulation):
+            behaviours_classes = [MyTimedSimulationBehaviour]
+
+        simulation = MyTimedSimulation(config)
+        subjects = Subjects(simulation=simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config,
+            logger,
+            simulation=simulation,
+            process_manager=do_nothing_process_manager,
+        )
+
+        # Thirst time, behaviour IS executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0)):
+            data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert data
+
+        # Less second after: NOT executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 500000)):
+            data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert not data
+
+        # Less second after: NOT executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 0, 700000)):
+            data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert not data
+
+        # More second after: IS executed
+        with freeze_time(datetime.datetime(2000, 12, 1, 0, 0, 1, 500000)):
+            data = cycle_manager._job_simulation(worker_id=0, process_count=1)
+            assert data
+
+    def test_subject_behavior_not_called_if_no_more_subjects(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        class MySubject(Subject):
+            behaviours_classes = [MySubjectBehaviour]
+
+        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,
+        )
+        results_by_subjects = cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert results_by_subjects
+        assert id(my_subject) in results_by_subjects
+        assert results_by_subjects[id(my_subject)]
+
+        # If we remove subject, no more data generated
+        subjects.remove(my_subject)
+        results_by_subjects = cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert not results_by_subjects
+
+
+class TestMechanisms(BaseTest):
+    def test_mechanism_called_once_for_multiple_subject_behaviors(self):
+        shared.reset()
+
         pass
 
-    def test_behaviour_timebase(self):
+    def test_mechanism_called_once_for_multiple_simulation_behaviors(self):
+        shared.reset()
+
         pass
 
-    def test_behavior_not_called_if_no_more_subjects(self):
+    def test_mechanism_not_called_if_no_subject_behavior(self):
+        shared.reset()
+
         pass
 
+    def test_mechanism_not_called_if_no_simulation_behavior(self):
+        shared.reset()
 
-class TestMechanisms(BaseTest):
-    def test_mechanism_called_once_for_multiple_behaviors(self):
         pass
 
-    def test_mechanism_not_called_if_no_behavior(self):
+    def test_mechanism_not_called_if_subject_behavior_timebase_not_active_yet(self):
+        shared.reset()
+
         pass
 
-    def test_mechanism_not_called_if_behavior_timebase_not_active_yet(self):
+    def test_mechanism_not_called_if_simulation_behavior_timebase_not_active_yet(self):
+        shared.reset()
+
         pass
+
+
+# TODO: Test Simulation mechanism parralelisation
+# TODO: Test behaviour actions generation