MAINT: remove uuid

src/caoscrawler/identifiable_adapters.py

@@ -397,7 +397,9 @@ startswith: bool, optional
 
     @staticmethod
     def referencing_entity_has_appropriate_type(parents, register_identifiable):
-        """
+        """ returns true if one of the parents is listed by the 'is_referenced_by' property
+
+        This function also returns True if 'is_referenced_by' contains the wildcard '*'.
         """
         if register_identifiable.get_property("is_referenced_by") is None:
             return False

src/caoscrawler/sync_graph.py

@@ -123,7 +123,6 @@ class SyncGraph():
         self.unchecked = list(self.nodes)
 
         # initialize reference mappings
-        # TODO only use python IDs for maps
         (
             self.forward_references,
             self.backward_references,
@@ -192,9 +191,9 @@ class SyncGraph():
         """
 
         return any([id(ent) not in self._missing and id(ent) not in self._existing
-                    for ent in self.forward_id_references[node.uuid]]
+                    for ent in self.forward_id_references[id(node)]]
                    + [id(ent) not in self._missing and id(ent) not in self._existing
-                      for ent in self.backward_id_referenced_by[node.uuid]])
+                      for ent in self.backward_id_referenced_by[id(node)]])
 
     def unchecked_contains_circular_dependency(self):
         """
@@ -209,7 +208,7 @@ class SyncGraph():
         closed = False
         while not closed:
             added_to_circle = False
-            for referenced in self.forward_references[circle[-1].uuid]:
+            for referenced in self.forward_references[id(circle[-1])]:
                 if referenced in self.unchecked:
                     if referenced in circle:
                         closed = True
@@ -270,7 +269,7 @@ class SyncGraph():
         if identifiable is None:
             self.identifiableAdapter.check_identifying_props(node)
             identifiable = self.identifiableAdapter.get_identifiable(
-                node, self.backward_id_referenced_by[node.uuid])
+                node, self.backward_id_referenced_by[id(node)])
         node.identifiable = identifiable
         equivalent_se = self.get_equivalent(node)
         if equivalent_se is not None and equivalent_se is not node:
@@ -287,8 +286,8 @@ class SyncGraph():
                 raise RuntimeError(f"Records must have a parent.\n{ent}")
 
     def _get_nodes_whose_identity_relies_on(self, node: SyncNode):
-        return (self.backward_id_references[node.uuid].union(
-                self.forward_id_referenced_by[node.uuid]))
+        return (self.backward_id_references[id(node)].union(
+                self.forward_id_referenced_by[id(node)]))
 
     @staticmethod
     def _create_flat_list(ent_list: List[db.Entity], flat: Optional[List[db.Entity]] = None):
@@ -345,12 +344,12 @@ class SyncGraph():
 
         # initialize with empty lists/dict
         for node in flat:
-            forward_references[node.uuid] = set()
-            backward_references[node.uuid] = set()
-            forward_id_references[node.uuid] = set()
-            backward_id_references[node.uuid] = set()
-            forward_id_referenced_by[node.uuid] = set()
-            backward_id_referenced_by[node.uuid] = set()
+            forward_references[id(node)] = set()
+            backward_references[id(node)] = set()
+            forward_id_references[id(node)] = set()
+            backward_id_references[id(node)] = set()
+            forward_id_referenced_by[id(node)] = set()
+            backward_id_referenced_by[id(node)] = set()
         for node in flat:
             for p in node.properties:
                 val = p.value
@@ -358,19 +357,19 @@ class SyncGraph():
                     val = [val]
                 for v in val:
                     if isinstance(v, SyncNode):
-                        forward_references[node.uuid].add(v)
-                        backward_references[v.uuid].add(node)
+                        forward_references[id(node)].add(v)
+                        backward_references[id(v)].add(node)
                         if (node.registered_identifiable is not None
                                 and len([el.name
                                          for el in node.registered_identifiable.properties if
                                          el.name == p.name]) > 0):
-                            forward_id_references[node.uuid].add(v)
-                            backward_id_references[v.uuid].add(node)
+                            forward_id_references[id(node)].add(v)
+                            backward_id_references[id(v)].add(node)
                         if (v.registered_identifiable is not None and
                                 IdentifiableAdapter.referencing_entity_has_appropriate_type(
                                 node.parents, v.registered_identifiable)):
-                            forward_id_referenced_by[node.uuid].add(v)
-                            backward_id_referenced_by[v.uuid].add(node)
+                            forward_id_referenced_by[id(node)].add(v)
+                            backward_id_referenced_by[id(v)].add(node)
 
         return (forward_references, backward_references, forward_id_references,
                 backward_id_references, forward_id_referenced_by, backward_id_referenced_by,
@@ -432,36 +431,36 @@ class SyncGraph():
         target.update(source)
 
         # update reference mappings
-        for node in self.forward_references.pop(source.uuid):
-            self.forward_references[target.uuid].add(node)
-            self.backward_references[node.uuid].remove(source)
-            self.backward_references[node.uuid].add(target)
-        for node in self.backward_references.pop(source.uuid):
+        for node in self.forward_references.pop(id(source)):
+            self.forward_references[id(target)].add(node)
+            self.backward_references[id(node)].remove(source)
+            self.backward_references[id(node)].add(target)
+        for node in self.backward_references.pop(id(source)):
             # replace actual reference property values
             _set_each_scalar_value(node,
                                    condition=lambda val: val is source,
                                    value=lambda val: target)
-            self.backward_references[target.uuid].add(node)
-            self.forward_references[node.uuid].remove(source)
-            self.forward_references[node.uuid].add(target)
-
-        for node in self.forward_id_references.pop(source.uuid):
-            self.forward_id_references[target.uuid].add(node)
-            self.backward_id_references[node.uuid].remove(source)
-            self.backward_id_references[node.uuid].add(target)
-        for node in self.backward_id_references.pop(source.uuid):
-            self.backward_id_references[target.uuid].add(node)
-            self.forward_id_references[node.uuid].remove(source)
-            self.forward_id_references[node.uuid].add(target)
-
-        for node in self.forward_id_referenced_by.pop(source.uuid):
-            self.forward_id_referenced_by[target.uuid].add(node)
-            self.backward_id_referenced_by[node.uuid].remove(source)
-            self.backward_id_referenced_by[node.uuid].add(target)
-        for node in self.backward_id_referenced_by.pop(source.uuid):
-            self.backward_id_referenced_by[target.uuid].add(node)
-            self.forward_id_referenced_by[node.uuid].remove(source)
-            self.forward_id_referenced_by[node.uuid].add(target)
+            self.backward_references[id(target)].add(node)
+            self.forward_references[id(node)].remove(source)
+            self.forward_references[id(node)].add(target)
+
+        for node in self.forward_id_references.pop(id(source)):
+            self.forward_id_references[id(target)].add(node)
+            self.backward_id_references[id(node)].remove(source)
+            self.backward_id_references[id(node)].add(target)
+        for node in self.backward_id_references.pop(id(source)):
+            self.backward_id_references[id(target)].add(node)
+            self.forward_id_references[id(node)].remove(source)
+            self.forward_id_references[id(node)].add(target)
+
+        for node in self.forward_id_referenced_by.pop(id(source)):
+            self.forward_id_referenced_by[id(target)].add(node)
+            self.backward_id_referenced_by[id(node)].remove(source)
+            self.backward_id_referenced_by[id(node)].add(target)
+        for node in self.backward_id_referenced_by.pop(id(source)):
+            self.backward_id_referenced_by[id(target)].add(node)
+            self.forward_id_referenced_by[id(node)].remove(source)
+            self.forward_id_referenced_by[id(node)].add(target)
 
         # remove unneeded SyncNode
         self.nodes.remove(source)
@@ -479,7 +478,6 @@ class SyncGraph():
                 or (id(target) in self._existing and id(source) in self._missing)):
             raise RuntimeError("Trying to merge missing and existing")
 
-
         if id(source) in self._missing and id(target) not in self._missing:
             self._mark_missing(target)
         if id(source) in self._existing and id(target) not in self._existing:
@@ -505,7 +503,7 @@ class SyncGraph():
         """ create initial set of SemanticEntities from provided Entity list"""
         entities = self._create_flat_list(entities)
         self._sanity_check(entities)
-        se_lookup: Dict[str, SyncNode] = {}  # lookup: UUID -> SyncNode
+        se_lookup: Dict[str, SyncNode] = {}  # lookup: python id -> SyncNode
         for el in entities:
             self.nodes.append(SyncNode(
                 el,

unittests/test_crawler.py

@@ -743,7 +743,7 @@ def test_split_into_inserts_and_updates_mult_backref(crawler_mocked_for_backref_
 
     identifiable = crawler.identifiableAdapter.get_identifiable(
         st.nodes[0],
-        st.backward_id_referenced_by[st.nodes[0].uuid])
+        st.backward_id_referenced_by[id(st.nodes[0])])
     assert len(identifiable.backrefs) == 2
 
     # check the split...
@@ -767,7 +767,7 @@ def test_split_into_inserts_and_updates_diff_backref(crawler_mocked_for_backref_
     st = SyncGraph(entlist, crawler.identifiableAdapter)
     identifiable = crawler.identifiableAdapter.get_identifiable(
         st.nodes[0],
-        st.backward_id_referenced_by[st.nodes[0].uuid])
+        st.backward_id_referenced_by[id(st.nodes[0])])
 
     assert len(identifiable.backrefs) == 2
 

unittests/test_sync_graph.py

@@ -86,37 +86,37 @@ def test_create_reference_mapping():
      backward_id_references, forward_id_referenced_by,
      backward_id_referenced_by) = SyncGraph._create_reference_mapping(ses)
     # test initialization
-    assert ses[0].uuid in forward_references
-    assert ses[1].uuid in forward_references
-    assert ses[0].uuid in backward_references
-    assert ses[1].uuid in backward_references
-    assert ses[0].uuid in forward_id_references
-    assert ses[1].uuid in forward_id_references
-    assert ses[0].uuid in backward_id_references
-    assert ses[1].uuid in backward_id_references
-    assert ses[0].uuid in forward_id_referenced_by
-    assert ses[1].uuid in forward_id_referenced_by
-    assert ses[0].uuid in backward_id_referenced_by
-    assert ses[1].uuid in backward_id_referenced_by
+    assert id(ses[0]) in forward_references
+    assert id(ses[1]) in forward_references
+    assert id(ses[0]) in backward_references
+    assert id(ses[1]) in backward_references
+    assert id(ses[0]) in forward_id_references
+    assert id(ses[1]) in forward_id_references
+    assert id(ses[0]) in backward_id_references
+    assert id(ses[1]) in backward_id_references
+    assert id(ses[0]) in forward_id_referenced_by
+    assert id(ses[1]) in forward_id_referenced_by
+    assert id(ses[0]) in backward_id_referenced_by
+    assert id(ses[1]) in backward_id_referenced_by
 
     # a has no ref
-    assert len(forward_references[ses[0].uuid]) == 0
-    assert backward_references[ses[0].uuid] == set([ses[1]])
+    assert len(forward_references[id(ses[0])]) == 0
+    assert backward_references[id(ses[0])] == set([ses[1]])
     # b does
-    assert forward_references[ses[1].uuid] == set([ses[0]])
-    assert backward_references[ses[1].uuid] == set()
+    assert forward_references[id(ses[1])] == set([ses[0]])
+    assert backward_references[id(ses[1])] == set()
     # a has no identifying reference
-    assert forward_id_references[ses[0].uuid] == set()
-    assert backward_references[ses[0].uuid] == set([ses[1]])
+    assert forward_id_references[id(ses[0])] == set()
+    assert backward_references[id(ses[0])] == set([ses[1]])
     # b has an identifying reference
-    assert forward_id_references[ses[1].uuid] == set([ses[0]])
-    assert backward_references[ses[1].uuid] == set()
+    assert forward_id_references[id(ses[1])] == set([ses[0]])
+    assert backward_references[id(ses[1])] == set()
     # a has an identifying back reference
-    assert forward_id_referenced_by[ses[0].uuid] == set()
-    assert backward_id_referenced_by[ses[0].uuid] == set([ses[1]])
+    assert forward_id_referenced_by[id(ses[0])] == set()
+    assert backward_id_referenced_by[id(ses[0])] == set([ses[1]])
     # b does not
-    assert forward_id_referenced_by[ses[1].uuid] == set([ses[0]])
-    assert backward_id_referenced_by[ses[1].uuid] == set()
+    assert forward_id_referenced_by[id(ses[1])] == set([ses[0]])
+    assert backward_id_referenced_by[id(ses[1])] == set()
 
 
 def test_SyncGraph():
@@ -145,63 +145,63 @@ def test_merge_into_trivial(simple_adapter):
 
     # CHECK REFERENCE MAP (before merge):
     # c is referenced by a
-    assert len(st.forward_references[se_a.uuid]) == 1
-    se_c in st.forward_references[se_a.uuid]
-    assert len(st.forward_references[se_b.uuid]) == 0
-    assert len(st.forward_references[se_c.uuid]) == 0
-    assert len(st.backward_references[se_a.uuid]) == 0
-    assert len(st.backward_references[se_b.uuid]) == 0
-    assert len(st.backward_references[se_c.uuid]) == 1
-    se_a in st.backward_references[se_c.uuid]
-
-    assert len(st.forward_id_references[se_a.uuid]) == 1
-    se_c in st.forward_id_references[se_a.uuid]
-    assert len(st.forward_id_references[se_b.uuid]) == 0
-    assert len(st.forward_id_references[se_c.uuid]) == 0
-    assert len(st.backward_id_references[se_a.uuid]) == 0
-    assert len(st.backward_id_references[se_b.uuid]) == 0
-    assert len(st.backward_id_references[se_c.uuid]) == 1
-    se_a in st.backward_id_references[se_c.uuid]
-
-    assert len(st.forward_id_referenced_by[se_a.uuid]) == 1
-    se_c in st.forward_id_referenced_by[se_a.uuid]
-    assert len(st.forward_id_referenced_by[se_b.uuid]) == 0
-    assert len(st.forward_id_referenced_by[se_c.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_a.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_b.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_c.uuid]) == 1
-    se_a in st.backward_id_referenced_by[se_c.uuid]
+    assert len(st.forward_references[id(se_a)]) == 1
+    se_c in st.forward_references[id(se_a)]
+    assert len(st.forward_references[id(se_b)]) == 0
+    assert len(st.forward_references[id(se_c)]) == 0
+    assert len(st.backward_references[id(se_a)]) == 0
+    assert len(st.backward_references[id(se_b)]) == 0
+    assert len(st.backward_references[id(se_c)]) == 1
+    se_a in st.backward_references[id(se_c)]
+
+    assert len(st.forward_id_references[id(se_a)]) == 1
+    se_c in st.forward_id_references[id(se_a)]
+    assert len(st.forward_id_references[id(se_b)]) == 0
+    assert len(st.forward_id_references[id(se_c)]) == 0
+    assert len(st.backward_id_references[id(se_a)]) == 0
+    assert len(st.backward_id_references[id(se_b)]) == 0
+    assert len(st.backward_id_references[id(se_c)]) == 1
+    se_a in st.backward_id_references[id(se_c)]
+
+    assert len(st.forward_id_referenced_by[id(se_a)]) == 1
+    se_c in st.forward_id_referenced_by[id(se_a)]
+    assert len(st.forward_id_referenced_by[id(se_b)]) == 0
+    assert len(st.forward_id_referenced_by[id(se_c)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_a)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_b)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_c)]) == 1
+    se_a in st.backward_id_referenced_by[id(se_c)]
 
     st.set_id_of_node(se_a, 101)
 
     # CHECK REFERENCE MAP (after merge):
     # c is now referenced by b
-    assert se_a.uuid not in st.forward_references
-    assert len(st.forward_references[se_b.uuid]) == 1
-    se_c in st.forward_references[se_b.uuid]
-    assert len(st.forward_references[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_references
-    assert len(st.backward_references[se_b.uuid]) == 0
-    assert len(st.backward_references[se_c.uuid]) == 1
-    se_b in st.backward_references[se_c.uuid]
-
-    assert se_a.uuid not in st.forward_id_references
-    assert len(st.forward_id_references[se_b.uuid]) == 1
-    se_c in st.forward_id_references[se_b.uuid]
-    assert len(st.forward_id_references[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_id_references
-    assert len(st.backward_id_references[se_b.uuid]) == 0
-    assert len(st.backward_id_references[se_c.uuid]) == 1
-    se_b in st.backward_id_references[se_c.uuid]
-
-    assert se_a.uuid not in st.forward_id_referenced_by
-    assert len(st.forward_id_referenced_by[se_b.uuid]) == 1
-    se_c in st.forward_id_referenced_by[se_b.uuid]
-    assert len(st.forward_id_referenced_by[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_id_referenced_by
-    assert len(st.backward_id_referenced_by[se_b.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_c.uuid]) == 1
-    se_b in st.backward_id_referenced_by[se_c.uuid]
+    assert id(se_a) not in st.forward_references
+    assert len(st.forward_references[id(se_b)]) == 1
+    se_c in st.forward_references[id(se_b)]
+    assert len(st.forward_references[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_references
+    assert len(st.backward_references[id(se_b)]) == 0
+    assert len(st.backward_references[id(se_c)]) == 1
+    se_b in st.backward_references[id(se_c)]
+
+    assert id(se_a) not in st.forward_id_references
+    assert len(st.forward_id_references[id(se_b)]) == 1
+    se_c in st.forward_id_references[id(se_b)]
+    assert len(st.forward_id_references[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_id_references
+    assert len(st.backward_id_references[id(se_b)]) == 0
+    assert len(st.backward_id_references[id(se_c)]) == 1
+    se_b in st.backward_id_references[id(se_c)]
+
+    assert id(se_a) not in st.forward_id_referenced_by
+    assert len(st.forward_id_referenced_by[id(se_b)]) == 1
+    se_c in st.forward_id_referenced_by[id(se_b)]
+    assert len(st.forward_id_referenced_by[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_id_referenced_by
+    assert len(st.backward_id_referenced_by[id(se_b)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_c)]) == 1
+    se_b in st.backward_id_referenced_by[id(se_c)]
 
 
 def test_merge_into_simple(simple_adapter):
@@ -217,70 +217,70 @@ def test_merge_into_simple(simple_adapter):
 
     # CHECK REFERENCE MAP:
     # c is referenced by a & b
-    assert len(st.forward_references[se_a.uuid]) == 1
-    se_c in st.forward_references[se_a.uuid]
-    assert len(st.forward_references[se_b.uuid]) == 1
-    se_c in st.forward_references[se_b.uuid]
-    assert len(st.forward_references[se_c.uuid]) == 0
-    assert len(st.backward_references[se_a.uuid]) == 0
-    assert len(st.backward_references[se_b.uuid]) == 0
-    assert len(st.backward_references[se_c.uuid]) == 2
-    se_a in st.backward_references[se_c.uuid]
-    se_b in st.backward_references[se_c.uuid]
-
-    assert len(st.forward_id_references[se_a.uuid]) == 1
-    se_c in st.forward_id_references[se_a.uuid]
-    assert len(st.forward_id_references[se_b.uuid]) == 1
-    se_c in st.forward_id_references[se_b.uuid]
-    assert len(st.forward_id_references[se_c.uuid]) == 0
-    assert len(st.backward_id_references[se_a.uuid]) == 0
-    assert len(st.backward_id_references[se_b.uuid]) == 0
-    assert len(st.backward_id_references[se_c.uuid]) == 2
-    se_a in st.backward_id_references[se_c.uuid]
-    se_b in st.backward_id_references[se_c.uuid]
-
-    assert len(st.forward_id_referenced_by[se_a.uuid]) == 1
-    se_c in st.forward_id_referenced_by[se_a.uuid]
-    assert len(st.forward_id_referenced_by[se_b.uuid]) == 1
-    se_c in st.forward_id_referenced_by[se_b.uuid]
-    assert len(st.forward_id_referenced_by[se_c.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_a.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_b.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_c.uuid]) == 2
-    se_a in st.backward_id_referenced_by[se_c.uuid]
-    se_b in st.backward_id_referenced_by[se_c.uuid]
+    assert len(st.forward_references[id(se_a)]) == 1
+    se_c in st.forward_references[id(se_a)]
+    assert len(st.forward_references[id(se_b)]) == 1
+    se_c in st.forward_references[id(se_b)]
+    assert len(st.forward_references[id(se_c)]) == 0
+    assert len(st.backward_references[id(se_a)]) == 0
+    assert len(st.backward_references[id(se_b)]) == 0
+    assert len(st.backward_references[id(se_c)]) == 2
+    se_a in st.backward_references[id(se_c)]
+    se_b in st.backward_references[id(se_c)]
+
+    assert len(st.forward_id_references[id(se_a)]) == 1
+    se_c in st.forward_id_references[id(se_a)]
+    assert len(st.forward_id_references[id(se_b)]) == 1
+    se_c in st.forward_id_references[id(se_b)]
+    assert len(st.forward_id_references[id(se_c)]) == 0
+    assert len(st.backward_id_references[id(se_a)]) == 0
+    assert len(st.backward_id_references[id(se_b)]) == 0
+    assert len(st.backward_id_references[id(se_c)]) == 2
+    se_a in st.backward_id_references[id(se_c)]
+    se_b in st.backward_id_references[id(se_c)]
+
+    assert len(st.forward_id_referenced_by[id(se_a)]) == 1
+    se_c in st.forward_id_referenced_by[id(se_a)]
+    assert len(st.forward_id_referenced_by[id(se_b)]) == 1
+    se_c in st.forward_id_referenced_by[id(se_b)]
+    assert len(st.forward_id_referenced_by[id(se_c)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_a)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_b)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_c)]) == 2
+    se_a in st.backward_id_referenced_by[id(se_c)]
+    se_b in st.backward_id_referenced_by[id(se_c)]
 
     st._merge_into(se_a, se_b)
 
     # CHECK REFERENCE MAP (after merge):
     # c is now referenced by b
     # (same situation as above)
-    assert se_a.uuid not in st.forward_references
-    assert len(st.forward_references[se_b.uuid]) == 1
-    se_c in st.forward_references[se_b.uuid]
-    assert len(st.forward_references[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_references
-    assert len(st.backward_references[se_b.uuid]) == 0
-    assert len(st.backward_references[se_c.uuid]) == 1
-    se_b in st.backward_references[se_c.uuid]
-
-    assert se_a.uuid not in st.forward_id_references
-    assert len(st.forward_id_references[se_b.uuid]) == 1
-    se_c in st.forward_id_references[se_b.uuid]
-    assert len(st.forward_id_references[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_id_references
-    assert len(st.backward_id_references[se_b.uuid]) == 0
-    assert len(st.backward_id_references[se_c.uuid]) == 1
-    se_b in st.backward_id_references[se_c.uuid]
-
-    assert se_a.uuid not in st.forward_id_referenced_by
-    assert len(st.forward_id_referenced_by[se_b.uuid]) == 1
-    se_c in st.forward_id_referenced_by[se_b.uuid]
-    assert len(st.forward_id_referenced_by[se_c.uuid]) == 0
-    assert se_a.uuid not in st.backward_id_referenced_by
-    assert len(st.backward_id_referenced_by[se_b.uuid]) == 0
-    assert len(st.backward_id_referenced_by[se_c.uuid]) == 1
-    se_b in st.backward_id_referenced_by[se_c.uuid]
+    assert id(se_a) not in st.forward_references
+    assert len(st.forward_references[id(se_b)]) == 1
+    se_c in st.forward_references[id(se_b)]
+    assert len(st.forward_references[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_references
+    assert len(st.backward_references[id(se_b)]) == 0
+    assert len(st.backward_references[id(se_c)]) == 1
+    se_b in st.backward_references[id(se_c)]
+
+    assert id(se_a) not in st.forward_id_references
+    assert len(st.forward_id_references[id(se_b)]) == 1
+    se_c in st.forward_id_references[id(se_b)]
+    assert len(st.forward_id_references[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_id_references
+    assert len(st.backward_id_references[id(se_b)]) == 0
+    assert len(st.backward_id_references[id(se_c)]) == 1
+    se_b in st.backward_id_references[id(se_c)]
+
+    assert id(se_a) not in st.forward_id_referenced_by
+    assert len(st.forward_id_referenced_by[id(se_b)]) == 1
+    se_c in st.forward_id_referenced_by[id(se_b)]
+    assert len(st.forward_id_referenced_by[id(se_c)]) == 0
+    assert id(se_a) not in st.backward_id_referenced_by
+    assert len(st.backward_id_referenced_by[id(se_b)]) == 0
+    assert len(st.backward_id_referenced_by[id(se_c)]) == 1
+    se_b in st.backward_id_referenced_by[id(se_c)]
 
 
 def test_backward_id_referenced_by():
@@ -296,7 +296,7 @@ def test_backward_id_referenced_by():
     ent_list = [referenced, db.Record(name="A").add_parent("BR").add_property("ref", referenced), ]
 
     st = SyncGraph(ent_list, ident_adapter)
-    assert st.nodes[1] in st.backward_id_referenced_by[st.nodes[0].uuid]
+    assert st.nodes[1] in st.backward_id_referenced_by[id(st.nodes[0])]
 
 
 def test_set_id_of_node(simple_adapter):