From 1400f45c19288ec5e6495cace5529ed3e6e7f4ac Mon Sep 17 00:00:00 2001 From: Stanislav Pankevich Date: Sun, 31 Dec 2023 02:08:58 +0100 Subject: [PATCH] traceability_index: move more links to the new database class --- strictdoc/core/graph/validations.py | 4 +- strictdoc/core/graph_database.py | 83 +++++++--- strictdoc/core/traceability_index.py | 145 +++++++++++++----- strictdoc/core/traceability_index_builder.py | 77 +++++----- .../core/transforms/create_requirement.py | 9 +- strictdoc/core/transforms/section.py | 7 +- strictdoc/core/transforms/update_free_text.py | 1 - .../move_node_basic_moving/test_case.py | 5 +- .../strictdoc/core/test_graph_database.py | 6 +- .../transforms/test_update_requirement.py | 1 + 10 files changed, 228 insertions(+), 110 deletions(-) diff --git a/strictdoc/core/graph/validations.py b/strictdoc/core/graph/validations.py index 4d9efdd74..6f394afbe 100644 --- a/strictdoc/core/graph/validations.py +++ b/strictdoc/core/graph/validations.py @@ -23,7 +23,6 @@ def validate( node = database.get_link_value( link_type=GraphLinkType.MID_TO_NODE, lhs_node=lhs_node, - weak=False, ) if isinstance(node, Anchor): self.validate_anchor(database, node) @@ -32,10 +31,9 @@ def validate( def validate_anchor(database: GraphDatabase, anchor: Anchor): assert isinstance(anchor, Anchor) - existing_links = database.get_link_values( + existing_links = database.get_link_values_weak( link_type=GraphLinkType.NODE_TO_INCOMING_LINKS, lhs_node=anchor.reserved_mid, - weak=True, ) if existing_links is not None: diff --git a/strictdoc/core/graph_database.py b/strictdoc/core/graph_database.py index 0b213c070..58801f426 100644 --- a/strictdoc/core/graph_database.py +++ b/strictdoc/core/graph_database.py @@ -65,51 +65,74 @@ def has_link(self, *, link_type: LinkType, lhs_node: Any) -> bool: return False return True - def get_link_value( - self, *, link_type: LinkType, lhs_node: Any, weak: bool + def get_link_value_weak( + self, *, link_type: LinkType, lhs_node: Any ) -> Optional[Any]: - link_values = self.get_link_values( - link_type=link_type, lhs_node=lhs_node, weak=True + link_values = self.get_link_values_weak( + link_type=link_type, lhs_node=lhs_node ) if link_values is not None and len(link_values) > 0: assert len(link_values) == 1 return next(iter(link_values)) - if weak: - return None + return None + + def get_link_value(self, *, link_type: LinkType, lhs_node: Any) -> Any: + link_value = self.get_link_value_weak( + link_type=link_type, lhs_node=lhs_node + ) + if link_value is not None: + return link_value raise LookupError - def get_link_values( - self, *, link_type: LinkType, lhs_node: Any, weak: bool + def get_link_values_weak( + self, *, link_type: LinkType, lhs_node: Any ) -> Optional[OrderedSet]: if link_type not in self._links: - if weak: - return None - raise LookupError + return None links = self._links[link_type] if lhs_node not in links: return None return links[lhs_node] - def get_link_values_reverse( - self, *, link_type: LinkType, rhs_node: Any, weak: bool + def get_link_values( + self, *, link_type: LinkType, lhs_node: Any + ) -> OrderedSet: + link_values = self.get_link_values_weak( + link_type=link_type, lhs_node=lhs_node + ) + if link_values is not None: + return link_values + raise LookupError + + def get_link_values_reverse_weak( + self, *, link_type: LinkType, rhs_node: Any ) -> Optional[OrderedSet]: if link_type not in self._links_reverse: - if weak: - return None - raise LookupError + return None reverse_links = self._links_reverse[link_type] if rhs_node not in reverse_links: - if weak: - return None - raise LookupError + return None return reverse_links[rhs_node] + def get_link_values_reverse( + self, *, link_type: LinkType, rhs_node: Any + ) -> OrderedSet: + link_values_reverse = self.get_link_values_reverse_weak( + link_type=link_type, rhs_node=rhs_node + ) + if link_values_reverse is not None: + return link_values_reverse + raise LookupError + def create_link(self, *, link_type: LinkType, lhs_node: Any, rhs_node: Any): if not isinstance(lhs_node, link_type.lhs_type): raise TypeError( - f"Type mismatch: {type(lhs_node)} {link_type.lhs_type}" + f"LHS type mismatch: {type(lhs_node)} {link_type.lhs_type}" + ) + if not isinstance(rhs_node, link_type.rhs_type): + raise TypeError( + f"RHS type mismatch: {type(rhs_node)} {link_type.rhs_type}" ) - assert lhs_node != rhs_node, (lhs_node, rhs_node) links = self._links[link_type] @@ -148,6 +171,24 @@ def delete_link( self._links[link_type][lhs_node].remove(rhs_node) self._links_reverse[link_type][rhs_node].remove(lhs_node) + def delete_link_weak( + self, + *, + link_type: LinkType, + lhs_node: Any, + rhs_node: Any, + ): + assert link_type in self._links + if lhs_node not in self._links[link_type]: + return + assert rhs_node in self._links_reverse[link_type] + + if self.remove_node_validation is not None: + self.remove_node_validation.validate(self, link_type, lhs_node) + + self._links[link_type][lhs_node].discard(rhs_node) + self._links_reverse[link_type][rhs_node].discard(lhs_node) + def delete_all_links( self, *, diff --git a/strictdoc/core/traceability_index.py b/strictdoc/core/traceability_index.py index f969de352..25d2479d7 100644 --- a/strictdoc/core/traceability_index.py +++ b/strictdoc/core/traceability_index.py @@ -61,9 +61,16 @@ def get_child_uids(self) -> List[str]: class GraphLinkType(LinkType): - MID_TO_NODE = (1, "ONE_TO_ONE", MID, (InlineLink, Anchor)) + MID_TO_NODE = ( + 1, + "ONE_TO_ONE", + MID, + (Document, Requirement, Section, InlineLink, Anchor), + ) UID_TO_NODE = (2, "ONE_TO_ONE", str, (Anchor)) NODE_TO_INCOMING_LINKS = (3, "ONE_TO_MANY", MID, InlineLink) + DOCUMENT_TO_PARENT_DOCUMENTS = (4, "ONE_TO_MANY", MID, MID) + DOCUMENT_TO_CHILD_DOCUMENTS = (5, "ONE_TO_MANY", MID, MID) class TraceabilityIndex: # pylint: disable=too-many-public-methods, too-many-instance-attributes # noqa: E501 @@ -72,10 +79,7 @@ def __init__( document_iterators: Dict[Document, DocumentCachingIterator], requirements_parents: Dict[str, RequirementConnections], tags_map, - document_parents_map: Dict[Document, Set[Document]], - document_children_map: Dict[Document, Set[Document]], file_traceability_index: FileTraceabilityIndex, - map_id_to_node: Dict[MID, Any], graph_database: GraphDatabase, ): self._document_iterators: Dict[ @@ -85,14 +89,7 @@ def __init__( str, RequirementConnections ] = requirements_parents self._tags_map = tags_map - self._document_parents_map: Dict[ - Document, Set[Document] - ] = document_parents_map - self._document_children_map: Dict[ - Document, Set[Document] - ] = document_children_map self._file_traceability_index = file_traceability_index - self._map_mid_to_node: Dict[MID, Any] = map_id_to_node self.graph_database: GraphDatabase = graph_database self.document_tree: Optional[DocumentTree] = None @@ -170,13 +167,15 @@ def has_source_file_reqs(self, source_file_rel_path): def get_node_by_mid(self, node_mid: MID) -> Any: assert isinstance(node_mid, MID), node_mid - return self._map_mid_to_node[node_mid] + return self.graph_database.get_link_value( + link_type=GraphLinkType.MID_TO_NODE, lhs_node=node_mid + ) def get_node_by_mid_weak(self, node_mid: MID) -> Optional[Any]: assert isinstance(node_mid, MID), node_mid - if node_mid not in self._map_mid_to_node: - return None - return self._map_mid_to_node[node_mid] + return self.graph_database.get_link_value_weak( + link_type=GraphLinkType.MID_TO_NODE, lhs_node=node_mid + ) def get_file_traceability_index(self) -> FileTraceabilityIndex: return self._file_traceability_index @@ -325,8 +324,8 @@ def get_section_by_uid_weak(self, uid): return self._requirements_parents[uid].requirement def get_anchor_by_uid_weak(self, uid: str) -> Optional[Anchor]: - anchor = self.graph_database.get_link_value( - link_type=GraphLinkType.UID_TO_NODE, lhs_node=uid, weak=True + anchor = self.graph_database.get_link_value_weak( + link_type=GraphLinkType.UID_TO_NODE, lhs_node=uid ) if anchor is not None: return assert_cast(anchor, Anchor) @@ -368,10 +367,9 @@ def get_node_with_duplicate_anchor( def get_section_incoming_links( self, section: Section ) -> Optional[List[InlineLink]]: - section_incoming_links = self.graph_database.get_link_values( + section_incoming_links = self.graph_database.get_link_values_weak( link_type=GraphLinkType.NODE_TO_INCOMING_LINKS, lhs_node=section.reserved_mid, - weak=True, ) if section_incoming_links is None: return None @@ -379,10 +377,38 @@ def get_section_incoming_links( return list(section_incoming_links) def get_document_children(self, document) -> Set[Document]: - return self._document_children_map[document] + child_documents_mids = self.graph_database.get_link_values_weak( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=document.reserved_mid, + ) + if child_documents_mids is None: + return set() + return set( + map( + lambda document_mid_: self.graph_database.get_link_value( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=document_mid_, + ), + child_documents_mids, + ) + ) def get_document_parents(self, document) -> Set[Document]: - return self._document_parents_map[document] + parent_documents_mids = self.graph_database.get_link_values_weak( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=document.reserved_mid, + ) + if parent_documents_mids is None: + return set() + return set( + map( + lambda document_mid_: self.graph_database.get_link_value( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=document_mid_, + ), + parent_documents_mids, + ) + ) def create_traceability_info( self, @@ -420,7 +446,6 @@ def create_inline_link(self, new_link: InlineLink): self.graph_database.get_link_value( link_type=GraphLinkType.UID_TO_NODE, lhs_node=new_link.link, - weak=False, ), Anchor, ) @@ -491,8 +516,19 @@ def update_requirement_parent_uid( requirement_connections.parents.append((parent_requirement, role)) parent_requirement_connections.children.append((requirement, role)) - self._document_parents_map[document].add(parent_requirement_document) - self._document_children_map[parent_requirement_document].add(document) + + if document != parent_requirement_document: + self.graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=document.reserved_mid, + rhs_node=parent_requirement_document.reserved_mid, + ) + self.graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=parent_requirement_document.reserved_mid, + rhs_node=document.reserved_mid, + ) + cycle_detector = TreeCycleDetector() cycle_detector.check_node( requirement.reserved_uid, @@ -529,8 +565,19 @@ def update_requirement_child_uid( requirement_connections.children.append((child_requirement, role)) child_requirement_connections.parents.append((requirement, role)) - self._document_parents_map[document].add(child_requirement_document) - self._document_children_map[child_requirement_document].add(document) + + if document != child_requirement_document: + self.graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=child_requirement_document.reserved_mid, + rhs_node=document.reserved_mid, + ) + self.graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=document.reserved_mid, + rhs_node=child_requirement_document.reserved_mid, + ) + cycle_detector = TreeCycleDetector() cycle_detector.check_node( requirement.reserved_uid, @@ -546,10 +593,11 @@ def update_requirement_child_uid( def update_with_anchor(self, anchor: Anchor): # By this time, we know that the validations have passed just before. - existing_anchor: Optional[Anchor] = self.graph_database.get_link_value( + existing_anchor: Optional[ + Anchor + ] = self.graph_database.get_link_value_weak( link_type=GraphLinkType.UID_TO_NODE, lhs_node=anchor.value, - weak=True, ) if existing_anchor is not None: self.graph_database.delete_all_links( @@ -575,6 +623,8 @@ def update_with_anchor(self, anchor: Anchor): def update_disconnect_two_documents_if_no_links_left( self, document, other_document ): + assert document != other_document + for node in self.document_iterators[document].all_content(): if not node.is_requirement: continue @@ -594,10 +644,26 @@ def update_disconnect_two_documents_if_no_links_left( if child_requirement_.document == other_document: return - self._document_parents_map[document].discard(other_document) - self._document_parents_map[other_document].discard(document) - self._document_children_map[document].discard(other_document) - self._document_children_map[other_document].discard(document) + self.graph_database.delete_link_weak( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=document.reserved_mid, + rhs_node=other_document.reserved_mid, + ) + self.graph_database.delete_link_weak( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=other_document.reserved_mid, + rhs_node=document.reserved_mid, + ) + self.graph_database.delete_link_weak( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=document.reserved_mid, + rhs_node=other_document.reserved_mid, + ) + self.graph_database.delete_link_weak( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=other_document.reserved_mid, + rhs_node=document.reserved_mid, + ) def remove_requirement_parent_uid( self, requirement: Requirement, parent_uid: str, role: Optional[str] @@ -621,9 +687,10 @@ def remove_requirement_parent_uid( # If there are no requirements linking between the documents, # remove the link. - self.update_disconnect_two_documents_if_no_links_left( - document, parent_requirement_document - ) + if document != parent_requirement_document: + self.update_disconnect_two_documents_if_no_links_left( + document, parent_requirement_document + ) # Mark document and parent document (if different) for re-generation. document.ng_needs_generation = True @@ -651,9 +718,10 @@ def remove_requirement_child_uid( # If there are no requirements linking between the documents, # remove the link. - self.update_disconnect_two_documents_if_no_links_left( - document, child_requirement_document - ) + if document != child_requirement_document: + self.update_disconnect_two_documents_if_no_links_left( + document, child_requirement_document + ) # Mark document and parent document (if different) for re-generation. document.ng_needs_generation = True @@ -665,7 +733,6 @@ def remove_inline_link(self, inline_link: InlineLink) -> None: self.graph_database.get_link_values_reverse( link_type=GraphLinkType.NODE_TO_INCOMING_LINKS, rhs_node=inline_link, - weak=False, ) ) diff --git a/strictdoc/core/traceability_index_builder.py b/strictdoc/core/traceability_index_builder.py index 2256203d4..c276e10f0 100644 --- a/strictdoc/core/traceability_index_builder.py +++ b/strictdoc/core/traceability_index_builder.py @@ -1,8 +1,7 @@ import glob import os import sys -from collections import defaultdict -from typing import Any, Dict, Iterator, List, Optional, Set, Union +from typing import Dict, Iterator, List, Optional, Union from textx import TextXSyntaxError @@ -46,7 +45,6 @@ from strictdoc.helpers.cast import assert_cast from strictdoc.helpers.exception import StrictDocException from strictdoc.helpers.file_modification_time import get_file_modification_time -from strictdoc.helpers.mid import MID from strictdoc.helpers.timing import timing_decorator @@ -191,14 +189,7 @@ def create_from_document_tree( # workflow. d_01_document_iterators: Dict[Document, DocumentCachingIterator] = {} d_03_map_doc_titles_to_tag_lists = {} - d_05_map_documents_to_parents: Dict[ - Document, Set[Document] - ] = defaultdict(set) - d_06_map_documents_to_children: Dict[ - Document, Set[Document] - ] = defaultdict(set) d_07_file_traceability_index = FileTraceabilityIndex() - d_11_map_id_to_node: Dict[MID, Any] = {} graph_database = GraphDatabase() graph_database.remove_node_validation = RemoveNodeValidation() @@ -207,10 +198,7 @@ def create_from_document_tree( d_01_document_iterators, {}, d_03_map_doc_titles_to_tag_lists, - d_05_map_documents_to_parents, - d_06_map_documents_to_children, file_traceability_index=d_07_file_traceability_index, - map_id_to_node=d_11_map_id_to_node, graph_database=graph_database, ) @@ -241,7 +229,6 @@ def create_from_document_tree( for free_text in document.free_texts: for part in free_text.parts: if isinstance(part, Anchor): - assert part.value not in d_11_map_id_to_node graph_database.create_link( link_type=GraphLinkType.MID_TO_NODE, lhs_node=part.mid, @@ -253,7 +240,10 @@ def create_from_document_tree( rhs_node=part, ) - if document.reserved_mid in d_11_map_id_to_node: + if graph_database.has_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=document.reserved_mid, + ): raise StrictDocException( "TraceabilityIndex: " "the document MID is not unique: " @@ -261,21 +251,32 @@ def create_from_document_tree( "All machine identifiers (MID) must be unique values." ) - d_11_map_id_to_node[document.reserved_mid] = document + graph_database.create_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=document.reserved_mid, + rhs_node=document, + ) document_iterator = DocumentCachingIterator(document) d_01_document_iterators[document] = document_iterator if document.title not in d_03_map_doc_titles_to_tag_lists: d_03_map_doc_titles_to_tag_lists[document.title] = {} for node in document_iterator.all_content(): - if node.reserved_mid in d_11_map_id_to_node: + if graph_database.has_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=node.reserved_mid, + ): raise StrictDocException( "TraceabilityIndex: " "the node MID is not unique: " f"{node.reserved_mid}. " f"All machine identifiers (MID) must be unique values." ) - d_11_map_id_to_node[node.reserved_mid] = node + graph_database.create_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=node.reserved_mid, + rhs_node=node, + ) if node.is_section: for free_text in node.free_texts: @@ -288,7 +289,6 @@ def create_from_document_tree( # see create_inline_link below. pass elif isinstance(part, Anchor): - assert part.value not in d_11_map_id_to_node graph_database.create_link( link_type=GraphLinkType.MID_TO_NODE, lhs_node=part.mid, @@ -436,12 +436,17 @@ def create_from_document_tree( parent_reference.ref_uid ].document ) - d_05_map_documents_to_parents[requirement.document].add( - parent_document - ) - d_06_map_documents_to_children[parent_document].add( - requirement.document - ) + if document != parent_document: + graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=requirement.document.reserved_mid, + rhs_node=parent_document.reserved_mid, + ) + graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=parent_document.reserved_mid, + rhs_node=requirement.document.reserved_mid, + ) elif reference.ref_type == ReferenceType.CHILD: child_reference: ChildReqReference = assert_cast( reference, ChildReqReference @@ -471,17 +476,17 @@ def create_from_document_tree( assert_cast(child_requirement.reserved_uid, str) ].parents.append((requirement, child_reference.role)) # Set document dependencies. - parent_document = ( - traceability_index.requirements_connections[ - requirement.reserved_uid - ].document - ) - d_05_map_documents_to_parents[ - child_requirement.document - ].add(parent_document) - d_06_map_documents_to_children[parent_document].add( - child_requirement.document - ) + if document != child_requirement.document: + graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_PARENT_DOCUMENTS, + lhs_node=child_requirement.document.reserved_mid, + rhs_node=document.reserved_mid, + ) + graph_database.create_link( + link_type=GraphLinkType.DOCUMENT_TO_CHILD_DOCUMENTS, + lhs_node=document.reserved_mid, + rhs_node=child_requirement.document.reserved_mid, + ) elif reference.ref_type == ReferenceType.BIB_REF: # Explicitly nothing. pass diff --git a/strictdoc/core/transforms/create_requirement.py b/strictdoc/core/transforms/create_requirement.py index 4e95c2e20..fb2d5db6c 100644 --- a/strictdoc/core/transforms/create_requirement.py +++ b/strictdoc/core/transforms/create_requirement.py @@ -14,6 +14,7 @@ ) from strictdoc.backend.sdoc.models.section import Section from strictdoc.core.traceability_index import ( + GraphLinkType, TraceabilityIndex, ) from strictdoc.core.transforms.constants import NodeCreationOrder @@ -113,9 +114,11 @@ def perform(self): requirement.ng_document_reference = DocumentReference() requirement.ng_document_reference.set_document(document) requirement.ng_level = parent.ng_level + 1 - traceability_index._map_mid_to_node[ - requirement.reserved_mid - ] = requirement + traceability_index.graph_database.create_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=requirement.reserved_mid, + rhs_node=requirement, + ) parent.section_contents.insert(insert_to_idx, requirement) diff --git a/strictdoc/core/transforms/section.py b/strictdoc/core/transforms/section.py index 13aeab1ca..21616e1c5 100644 --- a/strictdoc/core/transforms/section.py +++ b/strictdoc/core/transforms/section.py @@ -14,6 +14,7 @@ from strictdoc.backend.sdoc.models.section import Section from strictdoc.core.project_config import ProjectConfig from strictdoc.core.traceability_index import ( + GraphLinkType, RequirementConnections, TraceabilityIndex, ) @@ -319,7 +320,11 @@ def perform(self): section.ng_document_reference.set_document(document) assert parent.ng_level is not None, parent section.ng_level = parent.ng_level + 1 - traceability_index._map_mid_to_node[section.reserved_mid] = section + traceability_index.graph_database.create_link( + link_type=GraphLinkType.MID_TO_NODE, + lhs_node=section.reserved_mid, + rhs_node=section, + ) parent.section_contents.insert(insert_to_idx, section) # Updating section title. diff --git a/strictdoc/core/transforms/update_free_text.py b/strictdoc/core/transforms/update_free_text.py index 85e0e85b6..a60cf9c1f 100644 --- a/strictdoc/core/transforms/update_free_text.py +++ b/strictdoc/core/transforms/update_free_text.py @@ -152,7 +152,6 @@ def perform(self): anchor = traceability_index.graph_database.get_link_value( link_type=GraphLinkType.UID_TO_NODE, lhs_node=anchor_uid_to_be_removed, - weak=False, ) traceability_index.graph_database.delete_all_links( link_type=GraphLinkType.MID_TO_NODE, diff --git a/tests/end2end/screens/document/move_node/move_node_basic_moving/test_case.py b/tests/end2end/screens/document/move_node/move_node_basic_moving/test_case.py index 48fa94c95..3539530f4 100644 --- a/tests/end2end/screens/document/move_node/move_node_basic_moving/test_case.py +++ b/tests/end2end/screens/document/move_node/move_node_basic_moving/test_case.py @@ -11,7 +11,10 @@ class Test(E2ECase): - # This drag and drop test does not work reliably on Linux. + """ + FIXME: This drag and drop test does not work reliably on Linux. + """ + @available_systems(["macos", "windows"]) def test(self): test_setup = End2EndTestSetup(path_to_test_file=__file__) diff --git a/tests/unit/strictdoc/core/test_graph_database.py b/tests/unit/strictdoc/core/test_graph_database.py index 0c2ece613..43d50c824 100644 --- a/tests/unit/strictdoc/core/test_graph_database.py +++ b/tests/unit/strictdoc/core/test_graph_database.py @@ -28,7 +28,6 @@ class Relation(LinkType): graph_database.get_link_value( link_type=Relation.INLINE_LINK_TO_ANCHOR, lhs_node=inline_link, - weak=False, ) == anchor ) @@ -36,14 +35,12 @@ class Relation(LinkType): graph_database.get_link_values( link_type=Relation.INLINE_LINK_TO_ANCHOR, lhs_node=inline_link, - weak=False, ) ) == [anchor] assert list( graph_database.get_link_values_reverse( link_type=Relation.INLINE_LINK_TO_ANCHOR, rhs_node=anchor, - weak=False, ) ) == [inline_link] graph_database.delete_link( @@ -53,10 +50,9 @@ class Relation(LinkType): ) assert ( - graph_database.get_link_value( + graph_database.get_link_value_weak( link_type=Relation.INLINE_LINK_TO_ANCHOR, lhs_node=inline_link, - weak=True, ) is None ) diff --git a/tests/unit/strictdoc/core/transforms/test_update_requirement.py b/tests/unit/strictdoc/core/transforms/test_update_requirement.py index 0262c2e16..eb263b4cf 100644 --- a/tests/unit/strictdoc/core/transforms/test_update_requirement.py +++ b/tests/unit/strictdoc/core/transforms/test_update_requirement.py @@ -285,6 +285,7 @@ def test_26_two_documents_remove_child_relation(): ) assert len(requirement2.references) == 1 document_2 = document_builder.build() + assert requirement1.document != requirement2.document file_tree = [] document_list = [document_1, document_2]