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))