def test_readPersons_ndSpecific(self):
schema_person = schema.StatePerson(person_id=1)
schema_sentence_group = schema.StateSentenceGroup(
sentence_group_id=1,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code='US_ND')
schema_sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=2,
external_id=_EXTERNAL_ID_2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code='US_ND')
schema_person.sentence_groups = [
schema_sentence_group, schema_sentence_group_2
]
schema_person_2 = schema.StatePerson(person_id=2)
session = SessionFactory.for_schema_base(StateBase)
session.add(schema_person)
session.add(schema_person_2)
session.commit()
ingested_sentence_group = StateSentenceGroup.new_with_defaults(
state_code='us_nd', external_id=_EXTERNAL_ID)
ingested_person = StatePerson.new_with_defaults(
sentence_groups=[ingested_sentence_group])
expected_people = StateSchemaToEntityConverter().convert_all(
[schema_person], populate_back_edges=False)
people = read_persons(session, 'us_nd', [ingested_person])
self.assertCountEqual(expected_people, people)
def test_readPeopleByExternalId(self):
# Arrange
person_no_match = schema.StatePerson(person_id=1)
person_match_external_id = schema.StatePerson(person_id=2)
person_external_id = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person_match_external_id,
)
person_match_external_id.external_ids = [person_external_id]
session = SessionFactory.for_schema_base(StateBase)
session.add(person_no_match)
session.add(person_match_external_id)
session.commit()
ingested_person = entities.StatePerson.new_with_defaults()
ingested_person.external_ids = \
[entities.StatePersonExternalId.new_with_defaults(
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=ingested_person,
)]
# Act
people = dao.read_people_by_external_ids(session, _REGION,
[ingested_person])
# Assert
expected_people = [person_match_external_id]
self.assertCountEqual(people, expected_people)
def test_readPeople(self):
# Arrange
person = schema.StatePerson(person_id=8,
full_name=_FULL_NAME,
birthdate=_BIRTHDATE)
person_different_name = schema.StatePerson(person_id=9,
full_name='diff_name')
person_different_birthdate = schema.StatePerson(
person_id=10, birthdate=datetime.date(year=2002, month=1, day=2))
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.add(person_different_name)
session.add(person_different_birthdate)
session.commit()
# Act
people = dao.read_people(session, full_name=None, birthdate=None)
# Assert
expected_people = [
converter.convert_schema_object_to_entity(person),
converter.convert_schema_object_to_entity(person_different_name),
converter.convert_schema_object_to_entity(
person_different_birthdate)
]
self.assertCountEqual(people, expected_people)
def test_readPeople(self) -> None:
# Arrange
person = schema.StatePerson(
person_id=8,
full_name=_FULL_NAME,
birthdate=_BIRTHDATE,
state_code=_STATE_CODE,
)
person_different_name = schema.StatePerson(person_id=9,
full_name="diff_name",
state_code=_STATE_CODE)
person_different_birthdate = schema.StatePerson(
state_code=_STATE_CODE,
person_id=10,
birthdate=datetime.date(year=2002, month=1, day=2),
)
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.add(person_different_name)
session.add(person_different_birthdate)
session.commit()
# Act
people = dao.read_people(session, full_name=None, birthdate=None)
# Assert
expected_people = [
person, person_different_name, person_different_birthdate
]
self.assertCountEqual(people, expected_people)
def test_readPlaceholderPeople(self) -> None:
placeholder_person = schema.StatePerson(person_id=1,
state_code=_STATE_CODE)
person = schema.StatePerson(person_id=2, state_code=_STATE_CODE)
person_external_id = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person,
)
person.external_ids = [person_external_id]
session = SessionFactory.for_schema_base(StateBase)
session.add(placeholder_person)
session.add(person)
session.commit()
# Act
people = dao.read_placeholder_persons(session, _STATE_CODE)
# Assert
expected_people = [placeholder_person]
self.assertCountEqual(people, expected_people)
def test_readPeopleByRootExternalIds(self) -> None:
# Arrange
person_no_match = schema.StatePerson(person_id=1,
state_code=_STATE_CODE)
person_match_external_id = schema.StatePerson(person_id=2,
state_code=_STATE_CODE)
person_external_id = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person_match_external_id,
)
person_match_external_id.external_ids = [person_external_id]
session = SessionFactory.for_schema_base(StateBase)
session.add(person_no_match)
session.add(person_match_external_id)
session.commit()
# Act
people = dao.read_people_by_cls_external_ids(session, _STATE_CODE,
schema.StatePerson,
[_EXTERNAL_ID])
# Assert
expected_people = [person_match_external_id]
self.assertCountEqual(people, expected_people)
def test_readPeople_byBirthdate(self) -> None:
# Arrange
person = schema.StatePerson(person_id=8,
birthdate=_BIRTHDATE,
state_code=_STATE_CODE)
person_different_birthdate = schema.StatePerson(
state_code=_STATE_CODE,
person_id=9,
birthdate=datetime.date(year=2002, month=1, day=2),
)
with SessionFactory.using_database(self.database_key,
autocommit=False) as session:
session.add(person)
session.add(person_different_birthdate)
session.commit()
# Act
people = dao.read_people(session,
full_name=None,
birthdate=_BIRTHDATE)
# Assert
expected_people = [person]
self.assertCountEqual(people, expected_people)
def test_add_fine_conflicting_external_id_same_session(self) -> None:
# Arrange
db_person = schema.StatePerson(full_name=self.FULL_NAME,
state_code=self.state_code)
db_fine = schema.StateFine(
person=db_person,
status=StateFineStatus.EXTERNAL_UNKNOWN.value,
state_code=self.state_code,
external_id=self.EXTERNAL_ID_1,
county_code=self.COUNTY_CODE,
)
db_sentence_group = schema.StateSentenceGroup(
status=StateSentenceStatus.EXTERNAL_UNKNOWN.value,
external_id=self.EXTERNAL_ID_1,
state_code=self.state_code,
county_code=self.COUNTY_CODE,
fines=[db_fine],
)
db_external_id = schema.StatePersonExternalId(
state_code=self.state_code,
external_id=self.EXTERNAL_ID_1,
id_type=self.ID_TYPE_1,
)
db_person.sentence_groups = [db_sentence_group]
db_person.external_ids = [db_external_id]
db_person_dupe = schema.StatePerson(full_name=self.FULL_NAME,
state_code=self.state_code)
db_fine_dupe = schema.StateFine(
person=db_person_dupe,
status=StateFineStatus.EXTERNAL_UNKNOWN.value,
state_code=self.state_code,
external_id=self.EXTERNAL_ID_1,
county_code=self.COUNTY_CODE,
)
db_sentence_group_dupe = schema.StateSentenceGroup(
status=StateSentenceStatus.EXTERNAL_UNKNOWN.value,
external_id=self.EXTERNAL_ID_2,
state_code=self.state_code,
county_code=self.COUNTY_CODE,
fines=[db_fine_dupe],
)
db_external_id_dupe = schema.StatePersonExternalId(
state_code=self.state_code,
external_id=self.EXTERNAL_ID_2,
id_type=self.ID_TYPE_1,
)
db_person_dupe.sentence_groups = [db_sentence_group_dupe]
db_person_dupe.external_ids = [db_external_id_dupe]
# Act
session = SessionFactory.for_schema_base(StateBase)
session.add(db_fine)
session.add(db_fine_dupe)
session.flush()
with self.assertRaises(sqlalchemy.exc.IntegrityError):
session.commit()
def test_readPersonsByRootEntityCls(self) -> None:
schema_person_with_root_entity = schema.StatePerson(
person_id=1, state_code=_STATE_CODE)
schema_sentence_group = schema.StateSentenceGroup(
sentence_group_id=_ID,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
)
schema_sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=_ID_2,
external_id=_EXTERNAL_ID_2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
)
schema_person_with_root_entity.sentence_groups = [
schema_sentence_group,
schema_sentence_group_2,
]
placeholder_schema_person = schema.StatePerson(person_id=_ID_2,
state_code=_STATE_CODE)
schema_person_other_state = schema.StatePerson(person_id=_ID_3,
state_code=_STATE_CODE)
schema_external_id_other_state = schema.StatePersonExternalId(
person_external_id_id=_ID_2,
external_id=_ID,
id_type=_ID_TYPE,
state_code=_STATE_CODE,
)
schema_person_other_state.external_ids = [
schema_external_id_other_state
]
with SessionFactory.using_database(self.database_key,
autocommit=False) as session:
session.add(schema_person_with_root_entity)
session.add(placeholder_schema_person)
session.add(schema_person_other_state)
session.commit()
ingested_sentence_group = schema.StateSentenceGroup(
state_code=_STATE_CODE, external_id=_EXTERNAL_ID)
ingested_person = schema.StatePerson(
sentence_groups=[ingested_sentence_group])
expected_people = [
schema_person_with_root_entity,
placeholder_schema_person,
]
people = read_persons_by_root_entity_cls(
session,
_STATE_CODE,
[ingested_person],
allowed_root_entity_classes=[schema.StateSentenceGroup],
)
self.assert_schema_object_lists_equal(expected_people, people)
def test_readDbEntitiesOfClsToMerge(self):
person_1 = schema.StatePerson(person_id=1, state_code=_STATE_CODE)
sentence_group_1 = schema.StateSentenceGroup(
sentence_group_id=1,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_1)
person_1.sentence_groups = [sentence_group_1]
person_2 = schema.StatePerson(person_id=2, state_code=_STATE_CODE)
sentence_group_1_dup = schema.StateSentenceGroup(
sentence_group_id=2,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=3,
external_id=_EXTERNAL_ID_2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
placeholder_sentence_group = schema.StateSentenceGroup(
sentence_group_id=4,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
person_2.sentence_groups = [
sentence_group_1_dup, sentence_group_2, placeholder_sentence_group
]
session = SessionFactory.for_schema_base(StateBase)
session.add(person_1)
session.add(person_2)
session.commit()
# Act
trees_to_merge = read_db_entity_trees_of_cls_to_merge(
session, _STATE_CODE, schema.StateSentenceGroup)
sentence_group_trees_to_merge = one(trees_to_merge)
self.assertEqual(len(sentence_group_trees_to_merge), 2)
for entity_tree in sentence_group_trees_to_merge:
self.assertIsInstance(entity_tree, EntityTree)
self.assertIsInstance(entity_tree.entity,
schema.StateSentenceGroup)
self.assertEqual(entity_tree.entity.external_id, _EXTERNAL_ID)
self.assertEqual(
{
entity_tree.entity.sentence_group_id
for entity_tree in sentence_group_trees_to_merge
}, {1, 2})
def test_readPersons_default(self):
schema_person = schema.StatePerson(person_id=1)
schema_person_2 = schema.StatePerson(person_id=2)
session = SessionFactory.for_schema_base(StateBase)
session.add(schema_person)
session.add(schema_person_2)
session.commit()
expected_people = [schema_person, schema_person_2]
people = read_persons(session, _STATE_CODE, [])
self.assert_schema_object_lists_equal(expected_people, people)
def test_readPersons_default(self):
schema_person = schema.StatePerson(person_id=1)
schema_person_2 = schema.StatePerson(person_id=2)
session = SessionFactory.for_schema_base(StateBase)
session.add(schema_person)
session.add(schema_person_2)
session.commit()
expected_people = StateSchemaToEntityConverter().convert_all(
[schema_person, schema_person_2])
people = read_persons(session, _STATE_CODE, [])
self.assertCountEqual(expected_people, people)
def test_readPersonIdsMatchMultiplePeople(self):
# Arrange
person1 = schema.StatePerson(person_id=1)
person1_external_id = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person1,
)
person1.external_ids = [person1_external_id]
person2 = schema.StatePerson(person_id=2)
person2_external_id = schema.StatePersonExternalId(
person_external_id_id=2,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person2,
)
person2.external_ids = [person2_external_id]
session = SessionFactory.for_schema_base(StateBase)
session.add(person1)
session.add(person2)
session.commit()
ingested_person = entities.StatePerson.new_with_defaults()
ingested_person.external_ids = \
[
entities.StatePersonExternalId.new_with_defaults(
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE),
entities.StatePersonExternalId.new_with_defaults(
external_id=_EXTERNAL_ID2,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE)
]
# Act
people = dao.read_people_by_external_ids(session, _REGION,
[ingested_person])
# Assert
expected_people = [
converter.convert_schema_object_to_entity(person1),
converter.convert_schema_object_to_entity(person2)
]
self.assertCountEqual(people, expected_people)
def test_readPersonIdsMatchMultiplePeople(self) -> None:
# Arrange
person1 = schema.StatePerson(person_id=1, state_code=_STATE_CODE)
person1_external_id = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person1,
)
person1.external_ids = [person1_external_id]
person2 = schema.StatePerson(person_id=2, state_code=_STATE_CODE)
person2_external_id = schema.StatePersonExternalId(
person_external_id_id=2,
external_id=_EXTERNAL_ID2,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person2,
)
person2.external_ids = [person2_external_id]
with SessionFactory.using_database(self.database_key,
autocommit=False) as session:
session.add(person1)
session.add(person2)
session.commit()
ingested_person = entities.StatePerson.new_with_defaults(
state_code=_STATE_CODE)
ingested_person.external_ids = [
entities.StatePersonExternalId.new_with_defaults(
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
),
entities.StatePersonExternalId.new_with_defaults(
external_id=_EXTERNAL_ID2,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
),
]
# Act
people = dao.read_people_by_external_ids(session, _REGION,
[ingested_person])
# Assert
expected_people = [person1, person2]
self.assertCountEqual(people, expected_people)
def test_readPersons_default(self) -> None:
schema_person = schema.StatePerson(person_id=1, state_code=_STATE_CODE)
schema_person_2 = schema.StatePerson(person_id=2,
state_code=_STATE_CODE)
with SessionFactory.using_database(self.database_key,
autocommit=False) as session:
session.add(schema_person)
session.add(schema_person_2)
session.commit()
expected_people = [schema_person, schema_person_2]
people = read_persons(session, _STATE_CODE, [])
self.assert_schema_object_lists_equal(expected_people, people)
def test_readObjsWithExternalIdMatch(self) -> None:
person_1 = schema.StatePerson(person_id=1, state_code=_STATE_CODE)
sentence_group_1 = schema.StateSentenceGroup(
sentence_group_id=1,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_1,
)
person_1.sentence_groups = [sentence_group_1]
person_2 = schema.StatePerson(person_id=2, state_code=_STATE_CODE)
sentence_group_1_dup = schema.StateSentenceGroup(
sentence_group_id=2,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2,
)
sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=3,
external_id=_EXTERNAL_ID2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2,
)
placeholder_sentence_group = schema.StateSentenceGroup(
sentence_group_id=4,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2,
)
person_2.sentence_groups = [
sentence_group_1_dup,
sentence_group_2,
placeholder_sentence_group,
]
with SessionFactory.using_database(self.database_key,
autocommit=False) as session:
session.add(person_1)
session.add(person_2)
session.flush()
# Act
external_ids = dao.read_external_ids_of_cls_with_external_id_match(
session, _STATE_CODE, schema.StateSentenceGroup)
# Assert
self.assertEqual(external_ids, [_EXTERNAL_ID])
def test_readPersonsByRootEntityCls(self):
schema_person_with_root_entity = schema.StatePerson(
person_id=1, state_code=_STATE_CODE)
schema_sentence_group = schema.StateSentenceGroup(
sentence_group_id=_ID,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code='US_ND')
schema_sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=_ID_2,
external_id=_EXTERNAL_ID_2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code='US_ND')
schema_person_with_root_entity.sentence_groups = [
schema_sentence_group, schema_sentence_group_2
]
placeholder_schema_person = schema.StatePerson(person_id=_ID_2,
state_code=_STATE_CODE)
schema_person_other_state = schema.StatePerson(person_id=_ID_3,
state_code=_STATE_CODE)
schema_external_id_other_state = schema.StatePersonExternalId(
person_external_id_id=_ID_2,
external_id=_ID,
id_type=_ID_TYPE,
state_code=_STATE_CODE)
schema_person_other_state.external_ids = [
schema_external_id_other_state
]
session = SessionFactory.for_schema_base(StateBase)
session.add(schema_person_with_root_entity)
session.add(placeholder_schema_person)
session.add(schema_person_other_state)
session.commit()
ingested_sentence_group = schema.StateSentenceGroup(
state_code='us_nd', external_id=_EXTERNAL_ID)
ingested_person = schema.StatePerson(
sentence_groups=[ingested_sentence_group])
expected_people = [
schema_person_with_root_entity, placeholder_schema_person
]
people = read_persons_by_root_entity_cls(
session,
'us_nd', [ingested_person],
allowed_root_entity_classes=[schema.StateSentenceGroup])
self.assert_schema_object_lists_equal(expected_people, people)
def test_readPeopleByRootExternalIds_entireTreeReturnedWithOneMatch(self):
# Arrange
person = schema.StatePerson(person_id=1)
external_id_match = schema.StatePersonExternalId(
person_external_id_id=1,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person,
)
external_id_no_match = schema.StatePersonExternalId(
person_external_id_id=2,
external_id=_EXTERNAL_ID,
id_type=external_id_types.US_ND_SID,
state_code=_STATE_CODE,
person=person,
)
person.external_ids = [external_id_match, external_id_no_match]
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.commit()
# Act
people = dao.read_people_by_cls_external_ids(session, _STATE_CODE,
schema.StatePerson,
[_EXTERNAL_ID])
# Assert
expected_people = [person]
self.assertCountEqual(people, expected_people)
def test_readPeopleByRootExternalIds_SentenceGroupExternalId(self) -> None:
# Arrange
person = schema.StatePerson(person_id=1, state_code=_STATE_CODE)
sentence_group = schema.StateSentenceGroup(
sentence_group_id=1,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person,
)
sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=2,
external_id=_EXTERNAL_ID2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person,
)
person.sentence_groups = [sentence_group, sentence_group_2]
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.commit()
# Act
people = dao.read_people_by_cls_external_ids(session, _STATE_CODE,
schema.StateSentenceGroup,
[_EXTERNAL_ID])
# Assert
expected_people = [person]
self.assertCountEqual(people, expected_people)
def test_getExternalIdsOfCls(self):
supervision_sentence = schema.StateSupervisionSentence(
external_id=_EXTERNAL_ID)
supervision_sentence_2 = schema.StateSupervisionSentence(
external_id=_EXTERNAL_ID_2)
supervision_sentence_3 = schema.StateSupervisionSentence(
external_id=_EXTERNAL_ID_3)
sentence_group = schema.StateSentenceGroup(external_id=_EXTERNAL_ID,
supervision_sentences=[
supervision_sentence,
supervision_sentence_2
])
sentence_group_2 = schema.StateSentenceGroup(
external_id=_EXTERNAL_ID_2,
supervision_sentences=[
supervision_sentence_2, supervision_sentence_3
])
external_id = schema.StatePersonExternalId(external_id=_EXTERNAL_ID)
person = schema.StatePerson(
external_ids=[external_id],
sentence_groups=[sentence_group, sentence_group_2])
self.assertCountEqual([_EXTERNAL_ID, _EXTERNAL_ID_2, _EXTERNAL_ID_3],
get_external_ids_of_cls(
[person], schema.StateSupervisionSentence))
self.assertCountEqual([_EXTERNAL_ID, _EXTERNAL_ID_2],
get_external_ids_of_cls(
[person], schema.StateSentenceGroup))
self.assertCountEqual([_EXTERNAL_ID],
get_external_ids_of_cls([person],
schema.StatePerson))
def test_getEntityRelationshipFieldNames_backedges(self):
entity = schema.StateSentenceGroup(fines=[schema.StateFine()],
person=schema.StatePerson(),
person_id=_ID,
sentence_group_id=_ID)
self.assertEqual({'person'},
get_set_entity_field_names(entity,
EntityFieldType.BACK_EDGE))
def test_getDbEntityRelationshipFieldNames_children(self):
entity = schema.StateSentenceGroup(fines=[schema.StateFine()],
person=schema.StatePerson(),
person_id=_ID,
sentence_group_id=_ID)
self.assertEqual({'fines'},
get_set_entity_field_names(
entity, EntityFieldType.FORWARD_EDGE))
def test_getEntityRelationshipFieldNames_all(self):
entity = schema.StateSentenceGroup(fines=[schema.StateFine()],
person=schema.StatePerson(),
person_id=_ID,
sentence_group_id=_ID)
self.assertEqual({'fines', 'person', 'person_id', 'sentence_group_id'},
get_set_entity_field_names(entity,
EntityFieldType.ALL))
def test_getEntityRelationshipFieldNames_foreignKeys(self):
entity = schema.StateSentenceGroup(fines=[schema.StateFine()],
person=schema.StatePerson(),
person_id=_ID,
sentence_group_id=_ID)
self.assertEqual({'person_id'},
get_set_entity_field_names(
entity, EntityFieldType.FOREIGN_KEYS))
def test_readPeople_byFullName(self):
# Arrange
person = schema.StatePerson(person_id=8, full_name=_FULL_NAME)
person_different_name = schema.StatePerson(person_id=9,
full_name='diff_name')
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.add(person_different_name)
session.commit()
# Act
people = dao.read_people(session, full_name=_FULL_NAME, birthdate=None)
# Assert
expected_people = [person]
self.assertCountEqual(people, expected_people)
def test_readPeople_byBirthdate(self):
# Arrange
person = schema.StatePerson(person_id=8, birthdate=_BIRTHDATE)
person_different_birthdate = schema.StatePerson(
person_id=9, birthdate=datetime.date(year=2002, month=1, day=2))
session = SessionFactory.for_schema_base(StateBase)
session.add(person)
session.add(person_different_birthdate)
session.commit()
# Act
people = dao.read_people(session, full_name=None, birthdate=_BIRTHDATE)
# Assert
expected_people = [person]
self.assertCountEqual(people, expected_people)
def test_removeSeosFromViolationIds_unexpectedFormat(self):
with pytest.raises(ValueError):
sv = schema.StateSupervisionViolation(external_id='bad_id')
sp = schema.StateSupervisionPeriod(
supervision_violation_entries=[sv])
ss = schema.StateSupervisionSentence(supervision_periods=[sp])
sg = schema.StateSentenceGroup(supervision_sentences=[ss])
p = schema.StatePerson(sentence_groups=[sg])
remove_suffix_from_violation_ids([p])
def test_isMatch_statePerson(self):
external_id = schema.StatePersonExternalId(state_code=_STATE_CODE,
external_id=_EXTERNAL_ID)
external_id_same = schema.StatePersonExternalId(
state_code=_STATE_CODE, external_id=_EXTERNAL_ID)
external_id_different = schema.StatePersonExternalId(
state_code=_STATE_CODE, external_id=_EXTERNAL_ID_2)
person = schema.StatePerson(full_name='name',
external_ids=[external_id])
person_another = schema.StatePerson(full_name='name_2',
external_ids=[external_id_same])
self.assertTrue(
_is_match(ingested_entity=person, db_entity=person_another))
person_another.external_ids = [external_id_different]
self.assertFalse(
_is_match(ingested_entity=person, db_entity=person_another))
def test_readObjsWithExternalIdMatch(self):
person_1 = schema.StatePerson(person_id=1)
sentence_group_1 = schema.StateSentenceGroup(
sentence_group_id=1,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_1)
person_1.sentence_groups = [sentence_group_1]
person_2 = schema.StatePerson(person_id=2)
sentence_group_1_dup = schema.StateSentenceGroup(
sentence_group_id=2,
external_id=_EXTERNAL_ID,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
sentence_group_2 = schema.StateSentenceGroup(
sentence_group_id=3,
external_id=_EXTERNAL_ID2,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
placeholder_sentence_group = schema.StateSentenceGroup(
sentence_group_id=4,
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
person=person_2)
person_2.sentence_groups = [
sentence_group_1_dup, sentence_group_2, placeholder_sentence_group
]
session = SessionFactory.for_schema_base(StateBase)
session.add(person_1)
session.add(person_2)
session.commit()
# Act
external_ids = dao.read_external_ids_of_cls_with_external_id_match(
session, _STATE_CODE, schema.StateSentenceGroup)
# Assert
self.assertEqual(external_ids, [_EXTERNAL_ID])
def test_isPlaceholder(self):
entity = schema.StateSentenceGroup(
status=StateSentenceStatus.PRESENT_WITHOUT_INFO.value,
state_code=_STATE_CODE,
fines=[schema.StateFine()],
person=schema.StatePerson(),
sentence_group_id=_ID)
self.assertTrue(is_placeholder(entity))
entity.county_code = 'county_code'
self.assertFalse(is_placeholder(entity))
