def test_expunger_with_an_empty_record(self):
CrawlerFactory.create(self.crawler, JohnDoe.BLANK_RECORD, {})
expunger = Expunger(self.crawler.result.cases)
assert expunger.run() is True
assert expunger._most_recent_dismissal is None
assert expunger._most_recent_conviction is None
def test_save_result(self):
with self.client:
user_id = self.user_data["user1"]["user_id"]
request_data = {
"first_name": "John",
"last_name": "Doe",
"middle_name": "Test",
"birth_date": "01/01/1980",
}
record = CrawlerFactory.create(CrawlerFactory.setup())
self.login(self.user_data["user1"]["email"],
self.user_data["user1"]["password"])
g.database = get_database()
expungeservice.stats.save_result(request_data, record)
g.database.connection.commit()
self.check_search_result_saved(self.user_data["user1"]["user_id"],
request_data,
num_eligible_charges=6,
num_charges=9)
def test_expunger_invokes_time_analyzer_with_most_recent_charge(self):
CrawlerFactory.create(
self.crawler,
cases={
'X0001':
CaseDetails.case_x(
arrest_date=self.FIFTEEN_YEARS_AGO.strftime('%m/%d/%Y'),
charge1_name='Aggravated theft in the first degree',
charge1_statute='164.057',
charge1_level='Felony Class B',
dispo_ruling_1='Convicted',
dispo_date=self.FIFTEEN_YEARS_AGO.strftime('%m/%d/%Y')),
'X0002':
CaseDetails.case_x(),
'X0003':
CaseDetails.case_x()
})
expunger = Expunger(self.crawler.result.cases)
expunger.run()
assert len(expunger._type_analyzer.class_b_felonies) == 1
assert expunger._type_analyzer.class_b_felonies[
0].name == 'Aggravated theft in the first degree'
assert expunger._time_analyzer._class_b_felonies[
0].name == 'Aggravated theft in the first degree'
assert expunger._time_analyzer._most_recent_charge.name == 'Aggravated theft in the first degree'
def test_expunger_calls_time_analyzer(self):
CrawlerFactory.create(
self.crawler,
cases={
'X0001':
CaseDetails.case_x(
arrest_date=self.FIFTEEN_YEARS_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='Dismissed',
dispo_ruling_2='Dismissed',
dispo_ruling_3='Acquitted'),
'X0002':
CaseDetails.case_x(
arrest_date=self.TWO_YEARS_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='Dismissed',
dispo_ruling_2='Convicted',
dispo_ruling_3='Dismissed'),
'X0003':
CaseDetails.case_x(
arrest_date=self.ONE_YEAR_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='No Complaint',
dispo_ruling_2='Convicted',
dispo_ruling_3='No Complaint')
})
expunger = Expunger(self.crawler.result.cases)
assert expunger.run() is True
assert expunger._time_analyzer._most_recent_conviction.date == self.ONE_YEAR_AGO
assert expunger._time_analyzer._second_most_recent_conviction.date == self.TWO_YEARS_AGO
assert expunger._time_analyzer._most_recent_dismissal.date == self.ONE_YEAR_AGO
assert expunger._time_analyzer._num_acquittals == 4
def test_it_creates_json(self):
crawler = CrawlerFactory.setup()
record = CrawlerFactory.create(crawler)
jsonified_dictionary = json.loads(
json.dumps(record, cls=ExpungeModelEncoder))
assert type(jsonified_dictionary) == dict
def setUp(self):
EndpointShared.setUp(self)
""" Save these actual function refs to reinstate after we're done mocking them."""
self.crawler_login = search.Crawler.login
self.search = search.Crawler.search
self.crawler = CrawlerFactory.setup()
self.crawler.logged_in = True
self.mock_record = {"john_doe": CrawlerFactory.create(self.crawler)}
def test_nonzero_balance_due_on_case(self):
CrawlerFactory.create(
self.crawler, JohnDoe.RECORD, {
'X0001': CaseDetails.CASE_X1,
'X0002': CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
'X0003': CaseDetails.CASE_WITHOUT_DISPOS
})
assert self.crawler.result.cases[0].get_balance_due() == 1516.80
def test_expunger_with_open_case(self):
CrawlerFactory.create(
self.crawler, JohnDoe.RECORD, {
'X0001': CaseDetails.CASE_X1,
'X0002': CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
'X0003': CaseDetails.CASE_WITHOUT_DISPOS
})
expunger = Expunger(self.crawler.result.cases)
assert expunger.run() is False
assert expunger.errors == ['Open cases exist']
def setup_and_teardown(service):
service.setup()
service.crawler = CrawlerFactory.setup()
service.crawler.logged_in = True
service.mock_record = {"john_doe": CrawlerFactory.create(service.crawler)}
service.search_request_data = {
"names": [{"first_name": "John", "last_name": "Doe", "middle_name": "", "birth_date": "02/02/1990"}]
}
yield
service.teardown()
def test_type_analyzer_runs_when_open_cases_exit(self):
CrawlerFactory.create(
self.crawler, JohnDoe.RECORD, {
'X0001': CaseDetails.CASE_X1,
'X0002': CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
'X0003': CaseDetails.CASE_WITHOUT_DISPOS
})
expunger = Expunger(self.crawler.result.cases)
expunger.run()
assert expunger.cases[0].charges[
1].expungement_result.type_eligibility is True
def example_record():
return CrawlerFactory.create(
record=JohnDoe.SINGLE_CASE_RECORD,
cases={
"CASEJD1": CaseDetails.CASE_WITH_REVOKED_PROBATION,
},
)
def record_with_odd_event_table_contents():
return CrawlerFactory.create(
record=JohnDoe.SINGLE_CASE_RECORD,
cases={
"CASEJD1": CaseDetails.CASE_WITH_ODD_EVENT_TABLE_CONTENTS,
},
)
def setUp(self):
EndpointShared.setUp(self)
""" Save these actual function refs to reinstate after we're done mocking them."""
self.crawler_login = search.Crawler.login
self.search = search.Crawler.search
self.save_result = search.save_result
self.crawler = CrawlerFactory.setup()
self.crawler.logged_in = True
self.mock_record = {"john_doe": CrawlerFactory.create(self.crawler)}
self.search_request_data = {
"first_name": "John",
"last_name": "Doe",
"middle_name": "",
"birth_date": "02/02/1990"
}
def test_search_function():
record = CrawlerFactory.create(
JohnDoe.RECORD,
{
"X0001": CaseDetails.CASE_X1,
"X0002": CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
"X0003": CaseDetails.CASE_WITHOUT_DISPOS,
},
)
assert record.__class__ == Record
assert len(record.cases) == 3
assert len(record.cases[0].charges) == 3
assert len(record.cases[1].charges) == 1
assert len(record.cases[2].charges) == 3
assert record.cases[0].charges[0].disposition.ruling == "Convicted - Failure to Appear"
assert record.cases[0].charges[0].disposition.date == datetime.date(datetime.strptime("06/12/2017", "%m/%d/%Y"))
assert record.cases[0].charges[1].disposition.ruling == "Dismissed"
assert record.cases[0].charges[1].disposition.date == datetime.date(datetime.strptime("06/12/2017", "%m/%d/%Y"))
assert record.cases[0].charges[2].disposition.ruling == "Dismissed"
assert record.cases[0].charges[2].disposition.date == datetime.date(datetime.strptime("06/12/2017", "%m/%d/%Y"))
assert record.cases[1].charges[0].disposition.ruling == "Dismissed"
assert record.cases[1].charges[0].disposition.date == datetime.date(datetime.strptime("04/30/1992", "%m/%d/%Y"))
assert record.cases[2].charges[0].disposition is None
assert record.cases[2].charges[0].disposition is None
assert record.cases[2].charges[1].disposition is None
assert record.cases[2].charges[1].disposition is None
assert record.cases[2].charges[2].disposition is None
assert record.cases[2].charges[2].disposition is None
def record_with_mj_under_21_and_traffic_violation():
return CrawlerFactory.create(
record=YoungDoe.SINGLE_CASE_RECORD,
cases={
"CASEJD1": CaseDetails.CASE_MJ_AND_TRAFFIC_CONVICTION,
},
)
def record_with_unrecognized_dispo(crawler):
return CrawlerFactory.create(
crawler,
cases={
"X0001":
CaseDetails.case_x(dispo_ruling_1="Something unrecognized")
})
def record_with_mj_over_21():
return CrawlerFactory.create(
record=JohnDoe.SINGLE_CASE_RECORD,
cases={
"CASEJD1": CaseDetails.CASE_MJ_CONVICTION,
},
)
def test_expunger_runs_time_analyzer(self):
record = CrawlerFactory.create(self.crawler,
cases={'X0001': CaseDetails.case_x(arrest_date=self.FIFTEEN_YEARS_AGO.strftime('%m/%d/%Y'),
dispo_date=self.FIFTEEN_YEARS_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='Dismissed',
dispo_ruling_2='Convicted',
dispo_ruling_3='Acquitted'),
'X0002': CaseDetails.case_x(arrest_date=self.TWO_YEARS_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='Dismissed',
dispo_ruling_2='Dismissed',
dispo_ruling_3='Dismissed'),
'X0003': CaseDetails.case_x(arrest_date=self.ONE_YEAR_AGO.strftime('%m/%d/%Y'),
dispo_ruling_1='No Complaint',
dispo_ruling_2='No Complaint',
dispo_ruling_3='No Complaint')})
expunger = Expunger(record)
assert expunger.run() is True
assert expunger.most_recent_conviction is None
assert expunger.second_most_recent_conviction is None
assert expunger.most_recent_dismissal.disposition.ruling == 'No Complaint'
assert len(expunger.acquittals) == 8
assert record.cases[0].charges[0].expungement_result.time_eligibility.status is False
assert record.cases[0].charges[1].expungement_result.time_eligibility.status is True
assert record.cases[0].charges[2].expungement_result.time_eligibility.status is False
assert record.cases[1].charges[0].expungement_result.time_eligibility.status is False
assert record.cases[1].charges[1].expungement_result.time_eligibility.status is False
assert record.cases[1].charges[2].expungement_result.time_eligibility.status is False
assert record.cases[2].charges[0].expungement_result.time_eligibility.status is True
assert record.cases[2].charges[1].expungement_result.time_eligibility.status is True
assert record.cases[2].charges[2].expungement_result.time_eligibility.status is True
def test_search_function():
record = CrawlerFactory.create(
JohnDoe.RECORD,
{
"X0001": CaseDetails.CASE_X1,
"X0002": CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
"X0003": CaseDetails.CASE_WITHOUT_DISPOS,
},
)
# sorting by date results in the order X0003, X0002, X0001
assert record.__class__ == Record
assert len(record.cases) == 3
assert len(record.cases[2].charges) == 3
assert len(record.cases[1].charges) == 1
assert len(record.cases[0].charges) == 3
assert record.cases[2].charges[0].disposition.ruling == "Convicted - Failure to Appear"
assert record.cases[2].charges[0].disposition.date == date_class(2017, 6, 12)
assert record.cases[2].charges[1].disposition.ruling == "Dismissed"
assert record.cases[2].charges[1].disposition.date == date_class(2017, 6, 12)
assert record.cases[2].charges[2].disposition.ruling == "Dismissed"
assert record.cases[2].charges[2].disposition.date == date_class(2017, 6, 12)
assert record.cases[1].charges[0].disposition.ruling == "Dismissed"
assert record.cases[1].charges[0].disposition.date == date_class(1992, 4, 30)
assert record.cases[0].charges[0].disposition.status == DispositionStatus.UNKNOWN
assert record.cases[0].charges[0].disposition.status == DispositionStatus.UNKNOWN
assert record.cases[0].charges[1].disposition.status == DispositionStatus.UNKNOWN
assert record.cases[0].charges[1].disposition.status == DispositionStatus.UNKNOWN
assert record.cases[0].charges[2].disposition.status == DispositionStatus.UNKNOWN
assert record.cases[0].charges[2].disposition.status == DispositionStatus.UNKNOWN
def record_with_specific_dates(crawler):
return CrawlerFactory.create(
crawler,
cases={
"X0001":
CaseDetails.case_x(
arrest_date=FIFTEEN_YEARS_AGO.strftime("%m/%d/%Y"),
dispo_date=FIFTEEN_YEARS_AGO.strftime("%m/%d/%Y"),
dispo_ruling_1="Dismissed",
dispo_ruling_2="Convicted",
dispo_ruling_3="Acquitted",
),
"X0002":
CaseDetails.case_x(
arrest_date=TWO_YEARS_AGO.strftime("%m/%d/%Y"),
dispo_ruling_1="Dismissed",
dispo_ruling_2="Dismissed",
dispo_ruling_3="Dismissed",
),
"X0003":
CaseDetails.case_x(
arrest_date=ONE_YEAR_AGO.strftime("%m/%d/%Y"),
dispo_ruling_1="No Complaint",
dispo_ruling_2="No Complaint",
dispo_ruling_3="No Complaint",
),
},
)
def record_with_single_duii():
return CrawlerFactory.create_ambiguous_record_with_questions(
record=JohnDoe.SINGLE_CASE_RECORD,
cases={
"CASEJD1": CaseDetails.CASE_WITH_SINGLE_DUII,
},
)
def test_search_function(self):
CrawlerFactory.create(
self.crawler, JohnDoe.RECORD, {
'X0001': CaseDetails.CASE_X1,
'X0002': CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
'X0003': CaseDetails.CASE_WITHOUT_DISPOS
})
assert len(self.crawler.result.cases) == 3
assert len(self.crawler.result.cases[0].charges) == 3
assert len(self.crawler.result.cases[1].charges) == 1
assert len(self.crawler.result.cases[2].charges) == 3
assert self.crawler.result.cases[0].charges[
0].disposition.ruling == 'Convicted - Failure to Appear'
assert self.crawler.result.cases[0].charges[
0].disposition.date == datetime.date(
datetime.strptime('06/12/2017', '%m/%d/%Y'))
assert self.crawler.result.cases[0].charges[
1].disposition.ruling == 'Dismissed'
assert self.crawler.result.cases[0].charges[
1].disposition.date == datetime.date(
datetime.strptime('06/12/2017', '%m/%d/%Y'))
assert self.crawler.result.cases[0].charges[
2].disposition.ruling == 'Dismissed'
assert self.crawler.result.cases[0].charges[
2].disposition.date == datetime.date(
datetime.strptime('06/12/2017', '%m/%d/%Y'))
assert self.crawler.result.cases[1].charges[
0].disposition.ruling == 'Dismissed'
assert self.crawler.result.cases[1].charges[
0].disposition.date == datetime.date(
datetime.strptime('04/30/1992', '%m/%d/%Y'))
assert self.crawler.result.cases[2].charges[
0].disposition.ruling is None
assert self.crawler.result.cases[2].charges[0].disposition.date is None
assert self.crawler.result.cases[2].charges[
1].disposition.ruling is None
assert self.crawler.result.cases[2].charges[1].disposition.date is None
assert self.crawler.result.cases[2].charges[
2].disposition.ruling is None
assert self.crawler.result.cases[2].charges[2].disposition.date is None
def record_with_multiple_disposition_errors():
return CrawlerFactory.create(cases={
"X0001":
CaseDetails.case_x(dispo_ruling_1="Something unrecognized"),
"X0002":
CaseDetails.case_x(dispo_ruling_1="Something else unrecognized"),
"X0003":
CaseDetails.CASE_WITHOUT_DISPOS,
}, )
def test_single_charge_conviction(self):
CrawlerFactory.create(self.crawler, JohnDoe.SINGLE_CASE_RECORD,
{'CASEJD1': CaseDetails.CASEJD1})
assert len(self.crawler.result.cases) == 1
assert len(self.crawler.result.cases[0].charges) == 1
assert self.crawler.result.cases[0].charges[0].name == 'Loading Zone'
assert self.crawler.result.cases[0].charges[0].statute == '29'
assert self.crawler.result.cases[0].charges[
0].level == 'Violation Unclassified'
assert self.crawler.result.cases[0].charges[0].date == datetime.date(
datetime.strptime('09/04/2008', '%m/%d/%Y'))
assert self.crawler.result.cases[0].charges[
0].disposition.ruling == 'Convicted'
assert self.crawler.result.cases[0].charges[
0].disposition.date == datetime.date(
datetime.strptime('11/18/2008', '%m/%d/%Y'))
def record_with_revoked_probation():
return CrawlerFactory.create(cases={
"X0001":
CaseDetails.CASE_WITH_REVOKED_PROBATION,
"X0002":
CaseDetails.case_x(dispo_ruling_1="Something unrecognized"),
"X0003":
CaseDetails.case_x(dispo_ruling_1="Something unrecognized"),
}, )
def record_with_open_case():
return CrawlerFactory.create(
JohnDoe.RECORD,
{
"X0001": CaseDetails.CASE_X1,
"X0002": CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
"X0003": CaseDetails.CASE_WITHOUT_DISPOS,
},
)
def test_nonzero_balance_due_on_case():
record = CrawlerFactory.create(
JohnDoe.RECORD,
{
"X0001": CaseDetails.CASE_X1,
"X0002": CaseDetails.CASE_WITHOUT_FINANCIAL_SECTION,
"X0003": CaseDetails.CASE_WITHOUT_DISPOS,
},
)
assert record.cases[0].get_balance_due() == 1516.80
def setup_and_teardown(service):
service.mock_record = {"john_doe": CrawlerFactory.create()}
service.search_request_data = {
"aliases": [{
"first_name": "John",
"last_name": "Doe",
"middle_name": "",
"birth_date": "02/02/1990"
}]
}
yield
def test_single_charge_conviction():
record = CrawlerFactory.create(JohnDoe.SINGLE_CASE_RECORD, {"CASEJD1": CaseDetails.CASEJD1})
assert len(record.cases) == 1
assert len(record.cases[0].charges) == 1
assert record.cases[0].charges[0].name == "Loading Zone"
assert record.cases[0].charges[0].statute == "29"
assert record.cases[0].charges[0].level == "Violation Unclassified"
assert record.cases[0].charges[0].date == date_class(2008, 9, 4)
assert record.cases[0].charges[0].disposition.ruling == "Convicted"
assert record.cases[0].charges[0].disposition.date == date_class(2008, 11, 18)
def test_single_charge_conviction():
record = CrawlerFactory.create(JohnDoe.SINGLE_CASE_RECORD, {"CASEJD1": CaseDetails.CASEJD1})
assert len(record.cases) == 1
assert len(record.cases[0].charges) == 1
assert record.cases[0].charges[0].name == "Loading Zone"
assert record.cases[0].charges[0].statute == "29"
assert record.cases[0].charges[0].level == "Violation Unclassified"
assert record.cases[0].charges[0].date == datetime.date(datetime.strptime("09/04/2008", "%m/%d/%Y"))
assert record.cases[0].charges[0].disposition.ruling == "Convicted"
assert record.cases[0].charges[0].disposition.date == datetime.date(datetime.strptime("11/18/2008", "%m/%d/%Y"))
