def test_pruneDanglingPlaceholders_isDangling(self):
# Arrange
dangling_placeholder_person = generate_person()
dangling_placeholder_sg = generate_sentence_group()
# Act
pruned_person = \
prune_dangling_placeholders_from_tree(dangling_placeholder_person)
pruned_sentence_group = \
prune_dangling_placeholders_from_tree(dangling_placeholder_sg)
# Assert
self.assertIsNone(pruned_person)
self.assertIsNone(pruned_sentence_group)
def test_pruneDanglingPlaceholders_placeholderHasNonPlaceholderChildren(self):
# Arrange
non_placeholder_sg = generate_sentence_group(external_id="external_id")
placeholder_person = generate_person(sentence_groups=[non_placeholder_sg])
expected_non_placeholder_sg = generate_sentence_group(external_id="external_id")
expected_placeholder_person = generate_person(
sentence_groups=[expected_non_placeholder_sg]
)
# Act
pruned_tree = prune_dangling_placeholders_from_tree(placeholder_person)
# Assert
self.assertIsNotNone(pruned_tree)
self.assertEqual(
attr.evolve(self.to_entity(pruned_tree)),
attr.evolve(self.to_entity(expected_placeholder_person)),
)
def assert_expected_db_people(
self,
expected_db_people: List[StatePerson],
debug: bool = False,
single_person_to_debug: Optional[str] = None,
# TODO(#2492): Once we properly clean up dangling placeholders,
# delete this.
ignore_dangling_placeholders: bool = False,
print_tree_structure_only: bool = False,
) -> None:
"""Asserts that the set of expected people matches all the people that currently exist in the database.
Args:
debug: (bool) If true, prints out both the found and expected entity trees.
single_person_to_debug: (str) A string external_id of a person. If debug=True and this is not None, this
will only check for equality between the people with that external_id. This should be used for debugging
only and this function will throw if this value is set in CI.
ignore_dangling_placeholders: (bool) If True, eliminates dangling placeholder objects (i.e. placeholders
with no non-placeholder children) from both the result and expected trees before doing a comparison.
print_tree_structure_only: (bool) If True and debug=True, then the printed result only shows the tree
structure - external ids and parent-child relationships.
"""
if debug:
print("\n\n************** ASSERTING *************")
session = SessionFactory.for_schema_base(StateBase)
found_people_from_db = dao.read_people(session)
found_people = cast(
List[StatePerson],
self.convert_and_clear_db_ids(found_people_from_db))
if ignore_dangling_placeholders:
pruned_found_people = []
for person in found_people:
pruned_person = cast(
StatePerson, prune_dangling_placeholders_from_tree(person))
if pruned_person is not None:
pruned_found_people.append(pruned_person)
found_people = pruned_found_people
pruned_expected_people: List[StatePerson] = []
for person in expected_db_people:
pruned_expected_person = cast(
StatePerson, prune_dangling_placeholders_from_tree(person))
if pruned_expected_person is not None:
pruned_expected_people.append(pruned_expected_person)
expected_db_people = pruned_expected_people
if debug:
if is_running_in_ci():
self.fail(
"The |debug| flag should only be used for local debugging."
)
if single_person_to_debug is not None:
found_people = [
p for p in found_people
if person_has_id(p, single_person_to_debug)
]
expected_db_people = [
p for p in expected_db_people
if person_has_id(p, single_person_to_debug)
]
print_visible_header_label("FINAL")
print_entity_trees(
found_people,
print_tree_structure_only=print_tree_structure_only)
print_visible_header_label("EXPECTED")
print_entity_trees(
expected_db_people,
print_tree_structure_only=print_tree_structure_only)
self.assertCountEqual(found_people, expected_db_people)
assert_no_unexpected_entities_in_db(found_people_from_db, session)
