def test_matchBooking_withExistingFirstSeenTime_usesExistingValue(self):
        db_first_seen_time = datetime(2018, 1, 4)
        ingested_first_seen_time = datetime(2018, 1, 9)
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID,
            admission_date=_DATE,
            admission_date_inferred=True,
            custody_status=CustodyStatus.IN_CUSTODY,
            first_seen_time=db_first_seen_time,
        )
        ingested_booking = entities.Booking.new_with_defaults(
            admission_date=_DATE_2,
            admission_date_inferred=True,
            custody_status=CustodyStatus.HELD_ELSEWHERE,
            first_seen_time=ingested_first_seen_time,
        )

        expected_booking = attr.evolve(
            ingested_booking,
            booking_id=db_booking.booking_id,
            admission_date=_DATE,
            first_seen_time=db_first_seen_time,
        )

        db_person = entities.Person.new_with_defaults(bookings=[db_booking])
        ingested_person = entities.Person.new_with_defaults(
            bookings=[ingested_booking])
        county_entity_matcher.match_bookings(db_person=db_person,
                                             ingested_person=ingested_person,
                                             orphaned_entities=[])

        self.assertCountEqual(ingested_person.bookings, [expected_booking])
    def test_matchBooking_withInferredDate(self):
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID,
            admission_date=_DATE,
            admission_date_inferred=True,
            custody_status=CustodyStatus.IN_CUSTODY,
        )
        ingested_booking = entities.Booking.new_with_defaults(
            admission_date=_DATE_2,
            admission_date_inferred=True,
            custody_status=CustodyStatus.HELD_ELSEWHERE,
        )

        expected_booking = attr.evolve(ingested_booking,
                                       booking_id=db_booking.booking_id,
                                       admission_date=_DATE)

        db_person = entities.Person.new_with_defaults(bookings=[db_booking])
        ingested_person = entities.Person.new_with_defaults(
            bookings=[ingested_booking])
        orphaned_entities = []
        county_entity_matcher.match_bookings(
            db_person=db_person,
            ingested_person=ingested_person,
            orphaned_entities=orphaned_entities,
        )

        self.assertCountEqual(ingested_person.bookings, [expected_booking])
        self.assertEqual(len(orphaned_entities), 0)
    def test_matchBooking_duplicateMatch_throws(self):
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID,
            admission_date=_DATE,
            admission_date_inferred=True,
            custody_status=CustodyStatus.IN_CUSTODY,
        )
        ingested_booking_open = entities.Booking.new_with_defaults(
            admission_date=_DATE,
            admission_date_inferred=True,
            custody_status=CustodyStatus.HELD_ELSEWHERE,
        )
        ingested_booking_open_another = entities.Booking.new_with_defaults(
            admission_date=_DATE_2,
            admission_date_inferred=True,
            custody_status=CustodyStatus.HELD_ELSEWHERE,
        )

        db_person = entities.Person.new_with_defaults(bookings=[db_booking])
        orphaned_entities = []
        ingested_person = entities.Person.new_with_defaults(
            bookings=[ingested_booking_open, ingested_booking_open_another])

        with self.assertRaises(EntityMatchingError):
            county_entity_matcher.match_bookings(
                db_person=db_person,
                ingested_person=ingested_person,
                orphaned_entities=orphaned_entities,
            )
Exemplo n.º 4
0
    def test_matchAndCloseBookings(self):
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID, admission_date=_DATE_2,
            custody_status=CustodyStatus.IN_CUSTODY)
        db_booking_another = entities.Booking.new_with_defaults(
            booking_id=_ID_ANOTHER, admission_date=_DATE,
            custody_status=CustodyStatus.IN_CUSTODY)
        ingested_booking = entities.Booking.new_with_defaults(
            admission_date=_DATE_2, custody_status=CustodyStatus.IN_CUSTODY,
            facility=_FACILITY)

        expected_closed_booking = attr.evolve(
            db_booking_another,
            custody_status=CustodyStatus.REMOVED_WITHOUT_INFO,
            release_date=ingested_booking.admission_date,
            release_date_inferred=True)
        expected_matched_booking = attr.evolve(
            ingested_booking, booking_id=db_booking.booking_id)

        db_person = entities.Person.new_with_defaults(
            bookings=[db_booking, db_booking_another])
        ingested_person = entities.Person.new_with_defaults(
            bookings=[ingested_booking])

        orphaned_entities = []
        county_entity_matcher.match_bookings(
            db_person=db_person, ingested_person=ingested_person,
            orphaned_entities=orphaned_entities)
        self.assertCountEqual(
            ingested_person.bookings,
            [expected_closed_booking, expected_matched_booking])
        self.assertEqual(len(orphaned_entities), 0)
Exemplo n.º 5
0
    def test_matchBooking(self):
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID, admission_date=_DATE_2,
            custody_status=CustodyStatus.IN_CUSTODY)
        db_booking_closed = entities.Booking.new_with_defaults(
            booking_id=_ID_ANOTHER, admission_date=_DATE,
            custody_status=CustodyStatus.RELEASED, release_date=_DATE_2)
        ingested_booking_closed = entities.Booking.new_with_defaults(
            admission_date=_DATE_2, release_date=_DATE_3,
            custody_status=CustodyStatus.RELEASED)
        ingested_booking_open = entities.Booking.new_with_defaults(
            admission_date=_DATE_3, custody_status=CustodyStatus.IN_CUSTODY)

        expected_unchanged_closed_booking = attr.evolve(db_booking_closed)
        expected_new_closed_booking = attr.evolve(
            ingested_booking_closed,
            booking_id=db_booking.booking_id)
        expected_new_open_booking = attr.evolve(ingested_booking_open)

        db_person = entities.Person.new_with_defaults(
            bookings=[db_booking, db_booking_closed])
        ingested_person = entities.Person.new_with_defaults(
            bookings=[ingested_booking_closed, ingested_booking_open])

        orphaned_entities = []
        county_entity_matcher.match_bookings(
            db_person=db_person, ingested_person=ingested_person,
            orphaned_entities=orphaned_entities)

        self.assertCountEqual(ingested_person.bookings,
                              [expected_unchanged_closed_booking,
                               expected_new_closed_booking,
                               expected_new_open_booking])
        self.assertEqual(len(orphaned_entities), 0)
Exemplo n.º 6
0
    def test_matchBookingWithChildren(self):
        db_arrest = entities.Arrest.new_with_defaults(
            arrest_id=_ID, external_id=_EXTERNAL_ID, agency=_NAME)
        db_hold = entities.Hold.new_with_defaults(
            hold_id=_ID, external_id=_EXTERNAL_ID, jurisdiction_name=_NAME)
        db_sentence = entities.Sentence.new_with_defaults(
            sentence_id=_ID, external_id=_EXTERNAL_ID, sentencing_region=_NAME)
        db_bond = entities.Bond.new_with_defaults(
            bond_id=_ID, external_id=_EXTERNAL_ID, status=BondStatus.SET)
        db_charge = entities.Charge.new_with_defaults(
            charge_id=_ID, external_id=_EXTERNAL_ID, name=_NAME,
            sentence=db_sentence, bond=db_bond)
        db_booking = entities.Booking.new_with_defaults(
            booking_id=_ID, external_id=_EXTERNAL_ID, admission_date=_DATE,
            custody_status=CustodyStatus.IN_CUSTODY, arrest=db_arrest,
            holds=[db_hold], charges=[db_charge])
        db_person = entities.Person.new_with_defaults(
            person_id=_ID, external_id=_EXTERNAL_ID, bookings=[db_booking])

        ingested_arrest = entities.Arrest.new_with_defaults(
            external_id=_EXTERNAL_ID, agency=_NAME_2)
        ingested_hold = entities.Hold.new_with_defaults(
            external_id=_EXTERNAL_ID, jurisdiction_name=_NAME_2)
        ingested_sentence = entities.Sentence.new_with_defaults(
            external_id=_EXTERNAL_ID, sentencing_region=_NAME_2)
        ingested_bond = entities.Bond.new_with_defaults(
            external_id=_EXTERNAL_ID, status=BondStatus.POSTED)
        ingested_charge = entities.Charge.new_with_defaults(
            external_id=_EXTERNAL_ID, name=_NAME, sentence=ingested_sentence,
            bond=ingested_bond)
        ingested_booking = entities.Booking.new_with_defaults(
            external_id=_EXTERNAL_ID, admission_date=_DATE,
            custody_status=CustodyStatus.IN_CUSTODY, arrest=ingested_arrest,
            holds=[ingested_hold], charges=[ingested_charge])
        ingested_person = entities.Person.new_with_defaults(
            external_id=_EXTERNAL_ID, bookings=[ingested_booking])

        expected_arrest = attr.evolve(ingested_arrest, arrest_id=_ID)
        expected_hold = attr.evolve(ingested_hold, hold_id=_ID)
        expected_sentence = attr.evolve(ingested_sentence, sentence_id=_ID)
        expected_bond = attr.evolve(ingested_bond, bond_id=_ID)
        expected_charge = attr.evolve(
            ingested_charge, charge_id=_ID, bond=expected_bond,
            sentence=expected_sentence)
        expected_booking = attr.evolve(
            ingested_booking, booking_id=_ID, arrest=expected_arrest,
            holds=[expected_hold], charges=[expected_charge])

        orphaned_entities = []
        county_entity_matcher.match_bookings(
            db_person=db_person, ingested_person=ingested_person,
            orphaned_entities=orphaned_entities)

        self.assertCountEqual(ingested_person.bookings, [expected_booking])
        self.assertEqual(len(orphaned_entities), 0)