add test for simulation events

synergine2/cycle.py

                     str(mechanism_data),
                 ))
 
-            mechanisms_data[type(mechanism)] = mechanism_data
+            mechanisms_data[mechanism.__class__.__name__] = mechanism_data
 
         behaviours = self.simulation.behaviours.values()
         self.logger.info('{} behaviours to compute'.format(str(len(behaviours))))
                 ))
 
             if behaviour_data:
-                behaviours_data[type(behaviour)] = behaviour_data
+                behaviours_data[id(behaviour.__class__)] = behaviour_data
 
         return behaviours_data
 
         results_by_processes = self.process_manager.make_them_work(JOB_TYPE_SIMULATION)
 
         for process_result in results_by_processes:
-            for behaviour_class, behaviour_result in process_result.items():
+            for behaviour_class_id, behaviour_result in process_result.items():
+                behaviour_class = self.simulation.index[behaviour_class_id]
                 results[behaviour_class] = behaviour_class.merge_data(
                     behaviour_result,
                     results.get(behaviour_class),
 
         # Make events
         for behaviour_class, behaviour_data in results.items():
-            behaviour_events = self.simulation.behaviours[behaviour_class].action(behaviour_data)
+            behaviour_events = self.simulation.behaviours[behaviour_class.__name__].action(behaviour_data)
             self.logger.info('{} behaviour generate {} events'.format(
                 str(behaviour_class),
                 str(len(behaviour_events)),

synergine2/simulation.py

     def repr_debug(self) -> str:
         return self.__class__.__name__
 
-    def run(self, process_id: int=None, process_count: int=None):
+    def run(self, process_number: int=None, process_count: int=None):
         raise NotImplementedError()
 
 

tests/test_cycle.py

 from synergine2.log import SynergineLogger
 from synergine2.share import shared
 from synergine2.simulation import Simulation
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import SimulationMechanism
 from synergine2.simulation import Event
 from synergine2.simulation import Subject
 from synergine2.simulation import Subjects
     pass
 
 
+class MySimulationMechanism(SimulationMechanism):
+    def run(self, process_number: int = None, process_count: int = None):
+        return process_number + 1000
+
+
+class MySimulationBehaviour(SimulationBehaviour):
+    use = [MySimulationMechanism]
+
+    @classmethod
+    def merge_data(cls, new_data, start_data=None):
+        start_data = start_data or 0
+        return start_data + new_data
+
+    def run(self, data):
+        return data['MySimulationMechanism'] * 2
+
+    def action(self, data) -> [Event]:
+        return [MyEvent(data)]
+
+
+class MySimulation(Simulation):
+    behaviours_classes = [MySimulationBehaviour]
+
+
 class TestCycle(BaseTest):
     def test_subjects_cycle(self):
         shared.reset()
 
     def test_new_subject(self):
         shared.reset()
-        subject_ids = shared.get('subject_ids')
         config = Config({'core': {'use_x_cores': 1}})
         logger = SynergineLogger(name='test')
 
         event_values = [e.value for e in events]
         assert all([s.id * 2 in event_values for s in subjects])
 
+    def test_simulation_events(self):
+        shared.reset()
+        config = Config({'core': {'use_x_cores': 2}})
+        logger = SynergineLogger(name='test')
+
+        simulation = MySimulation(config)
+
+        # Prepare simulation class index
+        simulation.add_to_index(MySimulationBehaviour, MySimulationMechanism)
+
+        subjects = MySubjects(simulation=simulation)
+        simulation.subjects = subjects
+
+        cycle_manager = CycleManager(
+            config=config,
+            logger=logger,
+            simulation=simulation,
+        )
+
+        events = cycle_manager.next()
+        cycle_manager.stop()
+
+        assert 1 == len(events)
+        assert events[0].value == 4002