Fix tests

synergine2/share.py

             key_formatter = get_key
 
         def fget(self_):
-            return self.get(key)
+            return self.get(key_formatter(self_))
 
         def fset(self_, value_):
             try:

synergine2/simulation.py

         else:
             self.intentions = IntentionManager()
 
-        # TODO: Revoir le mechanisme de collection: utilité, usage avec les process, etc
-        # for collection in self.collections:
-        #     self.simulation.collections[collection].append(self)
-
     @property
     def id(self) -> int:
-        return self._id
+        try:
+            return self._id
+        except AttributeError:
+            pass
 
     def change_id(self, id_: int) -> None:
         self._id = id_
 
         subject_classes[self._id] = id(type(self))
 
+        for collection in self.collections:
+            self.simulation.collections.setdefault(collection, []).append(self.id)
+
     def __str__(self):
         return self.__repr__()
 
         self._auto_expose = True
         super().__init__(*args, **kwargs)
 
+        if self.auto_expose:
+            for subject in self:
+                subject.expose()
+
     @property
     def auto_expose(self) -> bool:
         return self._auto_expose
         if self.auto_expose:
             p_object.expose()
 
+    def extend(self, iterable):
+        for item in iterable:
+            self.append(item)
+
 
 class Simulation(BaseObject):
     accepted_subject_class = Subjects
     subject_behaviours_index = shared.create('subject_behaviours_index', {})
     subject_mechanisms_index = shared.create('subject_mechanisms_index', {})
     subject_classes = shared.create('subject_classes', {})
+    collections = shared.create('collections', {})
 
     def __init__(
         self,
         config: Config,
     ):
         self.config = config
-        self.collections = collections.defaultdict(list)
         self._subjects = None  # type: Subjects
 
         # Should contain all usable class of Behaviors, Mechanisms, SubjectBehaviourSelectors,
                 simulation=self,
             )
 
-    def add_to_index(self, class_: type) -> None:
+    def add_to_index(self, *classes: type) -> None:
         assert not self._index_locked
-        self._index[id(class_)] = class_
+        for class_ in classes:
+            self._index[id(class_)] = class_
 
     @property
     def index(self) -> typing.Dict[int, type]:

synergine2_xyz/xyz.py

 from math import sqrt
 
 from synergine2.exceptions import SynergineException
+from synergine2.share import shared
 from synergine2.simulation import Subject
 
 """
 
 
 class XYZSubjectMixin(object, metaclass=XYZSubjectMixinMetaClass):
+    position = shared.create(['{id}', 'counter'], (0, 0, 0))
+
     def __init__(self, *args, **kwargs):
         """
         :param position: tuple with (x, y, z)
         """
-        self._position = kwargs.pop('position')
-        self.previous_direction = None
-        super().__init__(*args, **kwargs)
+        position = None
+        try:
+            position = kwargs.pop('position')
+        except KeyError:
+            pass
 
-    @property
-    def position(self):
-        return self._position
+        self.previous_direction = None  # TODO: shared
+        super().__init__(*args, **kwargs)
 
-    @position.setter
-    def position(self, value):
-        self._position = value
+        if position:
+            self.position = position
 
 
 class ProximityMixin(object):
             # TODO: Optimiser en calculant directement les positions alentours et
             # en regardant si elles sont occupés dans subjects.xyz par un subject
             # etant dans fell_collection
-            for subject in simulation.collections.get(feel_collection, []):
-                if subject == exclude_subject:
+            for subject_id in simulation.collections.get(feel_collection, []):
+                subject = simulation.get_or_create_subject(subject_id)
+                if subject.id == exclude_subject.id:
                     continue
 
                 if self.have_to_check_position_is_possible() and not simulation.is_possible_position(subject.position):
                         self.direction_round_decimals,
                     )
                     subjects.append({
-                        'subject': subject,
+                        'subject_id': subject.id,
                         'direction': direction,
                         'distance': distance,
                     })

tests/test_xyz.py

 # coding: utf-8
 # -*- coding: utf-8 -*-
 from synergine2.config import Config
+from synergine2.share import shared
 from synergine2.simulation import Subject
 from synergine2_xyz.mechanism import ProximitySubjectMechanism
 from synergine2_xyz.simulation import XYZSimulation
 
 class TestXYZ(BaseTest):
     def test_proximity_mechanism_with_one(self):
+        shared.reset()
         simulation = XYZSimulation(Config())
+        simulation.add_to_index(
+            MyProximityMechanism,
+            MySubject,
+        )
+
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subject = MySubject(Config(), simulation, position=(5, 0, 0))
 
             [subject, other_subject],
             simulation=simulation,
         )
+        simulation.subjects.auto_expose = False
 
         proximity_mechanism = MyProximityMechanism(
             config=Config(),
             subject=other_subject,
         )
         assert [{
-            'subject': other_subject,
+            'subject_id': other_subject.id,
             'direction': 90.0,
             'distance': 5.0,
         }] == proximity_mechanism.run()
 
     def test_proximity_mechanism_excluding(self):
+        shared.reset()
         simulation = XYZSimulation(Config())
+        simulation.add_to_index(
+            MyProximityMechanism,
+            MySubject,
+        )
+
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subject = MySubject(Config(), simulation, position=(11, 0, 0))
 
             [subject, other_subject],
             simulation=simulation,
         )
+        simulation.subjects.auto_expose = False
 
         proximity_mechanism = MyProximityMechanism(
             config=Config(),
         assert [] == proximity_mechanism.run()
 
     def test_proximity_mechanism_with_multiple(self):
+        shared.reset()
         simulation = XYZSimulation(Config())
+        simulation.add_to_index(
+            MyProximityMechanism,
+            MySubject,
+        )
+
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subjects = []
 
 
         simulation.subjects = XYZSubjects([subject], simulation=simulation)
         simulation.subjects.extend(other_subjects)
+        simulation.subjects.auto_expose = False
 
         proximity_mechanism = MyProximityMechanism(
             config=Config(),
         assert [
             {
                 'direction': 0,
-                'subject': other_subjects[0],
+                'subject_id': other_subjects[0].id,
                 'distance': 0.0,
             },
             {
                 'direction': 135.0,
-                'subject': other_subjects[1],
+                'subject_id': other_subjects[1].id,
                 'distance': 1.41
             },
             {
                 'direction': 135.0,
-                'subject': other_subjects[2],
+                'subject_id': other_subjects[2].id,
                 'distance': 2.83
             },
         ] == data