def test_add_person_simple_no_flush(self) -> None:
# Arrange
session = SessionFactory.for_schema_base(StateBase)
db_external_id = generate_external_id(state_code=self.state_code,
external_id=EXTERNAL_ID_1,
id_type=ID_TYPE_1)
db_person = generate_person(state_code=self.state_code,
external_ids=[db_external_id])
session.add(db_person)
output_people = [db_person]
# Act
with self.assertRaises(SessionIsDirtyError) as e:
_ = validate_invariants(session, self.system_level,
self.state_code, output_people)
# Assert
self.assertEqual(
str(e.exception),
"Session unexpectedly dirty - flush before querying the database.",
)
def test_add_two_people_same_id_type(self) -> None:
# Arrange
db_external_id = generate_external_id(state_code=self.state_code,
external_id=EXTERNAL_ID_1,
id_type=ID_TYPE_1)
db_person = generate_person(state_code=self.state_code,
external_ids=[db_external_id])
db_external_id_2 = generate_external_id(state_code=self.state_code,
external_id=EXTERNAL_ID_2,
id_type=ID_TYPE_1)
db_person_2 = generate_person(state_code=self.state_code,
external_ids=[db_external_id_2])
# Act
session = SessionFactory.for_schema_base(StateBase)
session.add(db_person)
session.add(db_person_2)
session.flush()
output_people = [db_person, db_person_2]
errors = validate_invariants(session, self.system_level,
self.state_code, output_people)
# Assert
self.assertEqual(0, errors)
session.commit()
def test_add_person_two_ids_same_type_us_pa(self) -> None:
with SessionFactory.using_database(
self.database_key, autocommit=False
) as session:
# Arrange
self.state_code = "US_PA"
db_external_id = generate_external_id(
state_code=self.state_code, external_id=EXTERNAL_ID_1, id_type=ID_TYPE_1
)
db_external_id_2 = generate_external_id(
state_code=self.state_code, external_id=EXTERNAL_ID_2, id_type=ID_TYPE_1
)
db_person = generate_person(
state_code=self.state_code,
external_ids=[db_external_id, db_external_id_2],
)
session.add(db_person)
session.flush()
output_people = [db_person]
# Act
errors = validate_invariants(
session, self.system_level, self.state_code, output_people
)
# Assert
self.assertEqual(0, errors)
def match_and_write_people(session: Session) -> bool:
logging.info("Starting entity matching")
entity_matching_output = entity_matching.match(
session, ingest_metadata.region, people)
output_people = entity_matching_output.people
total_root_entities = (total_people if ingest_metadata.system_level
== SystemLevel.COUNTY else
entity_matching_output.total_root_entities)
logging.info(
"Completed entity matching with [%s] errors",
entity_matching_output.error_count,
)
logging.info(
"Completed entity matching and have [%s] total people "
"to commit to DB",
len(output_people),
)
if _should_abort(
total_root_entities=total_root_entities,
system_level=ingest_metadata.system_level,
conversion_result=conversion_result,
region_code=ingest_metadata.region,
entity_matching_errors=entity_matching_output.error_count,
):
# TODO(#1665): remove once dangling PERSIST session
# investigation is complete.
logging.info("_should_abort_ was true after entity matching")
return False
database_invariant_errors = (
database_invariant_validator.validate_invariants(
session,
ingest_metadata.system_level,
ingest_metadata.region,
output_people,
))
if _should_abort(
total_root_entities=total_root_entities,
system_level=ingest_metadata.system_level,
conversion_result=conversion_result,
region_code=ingest_metadata.region,
database_invariant_errors=database_invariant_errors,
):
logging.info(
"_should_abort_ was true after database invariant validation"
)
return False
database.write_people(
session,
output_people,
ingest_metadata,
orphaned_entities=entity_matching_output.orphaned_entities,
)
logging.info("Successfully wrote to the database")
return True
def test_clean_session(self) -> None:
# Arrange
session = SessionFactory.for_schema_base(StateBase)
# Act
errors = validate_invariants(session, self.system_level,
self.state_code, [])
# Assert
self.assertEqual(0, errors)
session.commit()
def test_clean_session(self) -> None:
with SessionFactory.using_database(
self.database_key, autocommit=False
) as session:
# Act
errors = validate_invariants(
session, self.system_level, self.state_code, []
)
# Assert
self.assertEqual(0, errors)
def test_invariant_validator_success_county(
self, mock_get_validators: MagicMock) -> None:
# Arrange
mock_get_validators.return_value = [validator_that_succeeds]
# Act
errors = database_invariant_validator.validate_invariants(
self.mock_session, SystemLevel.COUNTY, 'US_XX_YY', [])
# Assert
self.assertEqual(0, errors)
mock_get_validators.assert_called_once()
def test_invariant_validator_no_validations(
self, mock_get_validators: MagicMock) -> None:
# Arrange
mock_get_validators.return_value = []
# Act
errors = database_invariant_validator.validate_invariants(
self.mock_session, SystemLevel.STATE, 'US_XX', [])
# Assert
self.assertEqual(0, errors)
mock_get_validators.assert_called_once()
def test_invariant_validator_error(self, mock_get_validators: MagicMock) -> None:
# Arrange
mock_get_validators.return_value = [validator_that_fails]
# Act
errors = database_invariant_validator.validate_invariants(
self.mock_session, SystemLevel.STATE, "US_XX", []
)
# Assert
self.assertEqual(1, errors)
mock_get_validators.assert_called_once()
def test_invariant_validator_throws_session_is_dirty(
self, mock_get_validators: MagicMock) -> None:
# Arrange
mock_get_validators.return_value = [
validator_that_throws_session_is_dirty
]
# Act
with self.assertRaises(SessionIsDirtyError):
_ = database_invariant_validator.validate_invariants(
self.mock_session, SystemLevel.STATE, 'US_XX', [])
# Assert
mock_get_validators.assert_called_once()
def test_invariant_validator_mixed_errors_and_success(
self, mock_get_validators: MagicMock) -> None:
# Arrange
mock_get_validators.return_value = [
validator_that_succeeds,
validator_that_fails,
validator_that_succeeds,
validator_that_fails,
]
# Act
errors = database_invariant_validator.validate_invariants(
self.mock_session, SystemLevel.STATE, 'US_XX', [])
# Assert
self.assertEqual(2, errors)
mock_get_validators.assert_called_once()
def test_add_person_update_with_new_id(self) -> None:
with SessionFactory.using_database(
self.database_key, autocommit=False
) as arrange_session:
# Arrange
db_external_id = generate_external_id(
state_code=self.state_code, external_id=EXTERNAL_ID_1, id_type=ID_TYPE_1
)
db_person = generate_person(
state_code=self.state_code, external_ids=[db_external_id]
)
arrange_session.add(db_person)
arrange_session.commit()
db_external_id_2 = generate_external_id(
state_code=self.state_code, external_id=EXTERNAL_ID_2, id_type=ID_TYPE_1
)
# Act
with SessionFactory.using_database(
self.database_key, autocommit=False
) as session:
result = session.query(schema.StatePerson).all()
person_to_update = one(result)
person_to_update.external_ids.append(db_external_id_2)
session.flush()
output_people = [person_to_update]
errors = validate_invariants(
session, self.system_level, self.state_code, output_people
)
# Assert
self.assertEqual(1, errors)
