add some tests

synergine2/cycle.py

         self.logger.info('Subjects computing: {} subjects to compute'.format(str(len(subjects))))
 
         for subject in subjects:
-            mechanisms = subject.mechanisms.values()
+            subject_behaviours = self.get_active_subject_behaviors(subject)
+            if not subject_behaviours:
+                break
 
+            mechanisms = self.get_mechanisms_from_behaviors(subject_behaviours, subject)
             if mechanisms:
                 self.logger.info('Subject {}: {} mechanisms'.format(
                     str(subject.id),
                         str(mechanisms_data),
                     ))
 
-            subject_behaviours = subject.behaviours
-            if not subject_behaviours:
-                break
-
             self.logger.info('Subject {}: have {} behaviours'.format(
                 str(subject.id),
                 str(len(subject_behaviours)),
             ))
 
-            for behaviour_key, behaviour in list(subject_behaviours.items()):
+            for behaviour in subject_behaviours:
+                behaviour_key = type(behaviour)
+
                 self.logger.info('Subject {}: run {} behaviour'.format(
                     str(subject.id),
                     str(type(behaviour)),
 
     def stop(self) -> None:
         self.process_manager.terminate()
+
+    def get_active_subject_behaviors(
+        self,
+        subject: Subject,
+    ) -> typing.List[SubjectBehaviour]:
+        behaviours = []
+        for behaviour in subject.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_behaviors(
+        self,
+        subject_behaviours: typing.List[SubjectBehaviour],
+        subject: Subject,
+    ) -> typing.List[SubjectMechanism]:
+        # TODO BS 20180109: Not very optimized ... could be enhanced
+        mechanisms = set()
+        for subject_mechanism in subject.mechanisms.values():
+            for subject_behaviour in subject_behaviours:
+                for behaviour_mechanism_class in subject_behaviour.use:
+                    if isinstance(subject_mechanism, behaviour_mechanism_class):
+                        mechanisms.add(subject_mechanism)
+        return list(mechanisms)

synergine2/simulation.py

         super().remove(value)
         # Remove from start_collections
         for collection_name in value.collections:
-            self.simulation.collections[collection_name].remove(value)
+            self.simulation.collections[collection_name].remove(value.id)
         # Add to removed listing
         if self.track_changes:
             self.removes.append(value)
         """
         cycle_frequency = self.cycle_frequency
         if cycle_frequency is not None:
-            return not bool(cycle_number % cycle_frequency)
+            return 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 float(time.time() - self.last_execution_time) <= seconds_frequency
 
         return False
 

tests/test_simulation.py

             process_manager=do_nothing_process_manager,
         )
 
-        # Cycle 0: behaviour NOT executed
+        # Cycle 0: behaviour IS 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 1: behaviour IS NOT 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)]
+        assert not results_by_subjects
 
     def test_subject_behaviour_seconds_frequency(
         self,
         # 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)]
+            assert not data
 
         # 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)]
+            assert not data
 
-        # Less second after: NOT executed
+        # Less second after: IS 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,
             process_manager=do_nothing_process_manager,
         )
 
-        # Cycle 0: behaviour NOT executed
+        # Cycle 0: behaviour IS executed
         cycle_manager.current_cycle = 0
         data = cycle_manager._job_simulation(worker_id=0, process_count=1)
-        assert not data
+        assert data
 
-        # Cycle 1: behaviour executed
+        # Cycle 1: behaviour IS NOT executed
         cycle_manager.current_cycle = 1
         data = cycle_manager._job_simulation(worker_id=0, process_count=1)
-        assert data
+        assert not data
 
     def test_simulation_behaviour_seconds_frequency(
         self,
         cycle_manager._job_simulation(worker_id=0, process_count=1)
         assert called == 0
 
-    def test_mechanism_not_called_if_subject_behavior_timebase_not_active_yet(self):
+    def test_mechanism_not_called_if_subject_behavior_cycled_not_active_yet(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+        called = 0
+        global called
+
+        class MySubjectMechanism(SubjectMechanism):
+            def run(self):
+                global called
+                called += 1
+                return {'foo': 42}
+
+        class MySubjectBehaviour1(SubjectBehaviour):
+            use = [MySubjectMechanism]
+
+            @property
+            def cycle_frequency(self):
+                return 2
+
+            def run(self, data):
+                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,
+        )
+
+        cycle_manager.current_cycle = 0
+        cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert called == 1
+
+        cycle_manager.current_cycle = 1
+        cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert called == 1
+
+        cycle_manager.current_cycle = 2
+        cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert called == 2
+
+        cycle_manager.current_cycle = 3
+        cycle_manager._job_subjects(worker_id=0, process_count=1)
+        assert called == 2
+
+    def test_mechanism_not_called_if_simulation_behavior_cycled_not_active_yet(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
         shared.reset()
 
         pass
 
-    def test_mechanism_not_called_if_simulation_behavior_timebase_not_active_yet(self):
+    def test_mechanism_not_called_if_subject_behavior_timebase_not_active_yet(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
+        shared.reset()
+
+        pass
+
+    def test_mechanism_not_called_if_simulation_behavior_timebase_not_active_yet(
+        self,
+        do_nothing_process_manager: ProcessManager,
+    ):
         shared.reset()
 
         pass