def test_felony_c_conviction():
charge = ChargeFactory.create(name="Theft in the first degree",
statute="164.055",
level="Felony Class C",
disposition=Dispositions.CONVICTED)
assert isinstance(charge.charge_type, FelonyClassC)
assert charge.type_eligibility.status is EligibilityStatus.ELIGIBLE
assert charge.type_eligibility.reason == "Eligible under 137.225(1)(b)"
def test_felony_c_dismissal():
charge = ChargeFactory.create(name="Theft in the first degree",
statute="164.055",
level="Felony Class C",
disposition=Dispositions.DISMISSED)
assert isinstance(charge.charge_type, DismissedCharge)
assert charge.type_eligibility.status is EligibilityStatus.ELIGIBLE
assert charge.type_eligibility.reason == "Dismissals are generally eligible under 137.225(1)(d)"
def test_arrest_is_unaffected_if_conviction_eligibility_is_older():
violation_charge = ChargeFactory.create(
level="Class A Violation",
date=Time.TEN_YEARS_AGO,
disposition=Disposition(ruling="Convicted",
date=Time.LESS_THAN_THREE_YEARS_AGO),
)
arrest = ChargeFactory.create(
disposition=Disposition(ruling="Dismissed", date=Time.ONE_YEAR_AGO))
case = CaseFactory.create()
case.charges = [violation_charge, arrest]
expunger = Expunger(Record([case]))
expunger.run()
assert arrest.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE
assert arrest.expungement_result.time_eligibility.date_will_be_eligible == arrest.date
assert arrest.expungement_result.time_eligibility.reason == ""
def test_violation_convicted():
charge = ChargeFactory.create(name="Viol Treatment",
statute="1615662",
level="Violation Unclassified",
disposition=Dispositions.CONVICTED)
assert isinstance(charge.charge_type, Violation)
assert charge.type_eligibility.status is EligibilityStatus.ELIGIBLE
assert charge.type_eligibility.reason == "Eligible under 137.225(5)(d)"
def test_no_dispo_violation_is_not_type_eligible():
charge = ChargeFactory.create(statute="801.000", level="Class C Traffic Violation", disposition=None)
assert charge.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert (
charge.type_eligibility.reason
== "Always ineligible under 137.225(7)(a) (for convictions) or by omission from statute (for dismissals)"
)
assert not charge.blocks_other_charges()
def test_charge_with_unrecognized_disposition_eligibility():
charge = ChargeFactory.create(level="Felony Class B",
disposition=DispositionCreator.create(
ruling="What am I",
date=date(2001, 1, 1)))
assert not charge.convicted()
assert not charge.dismissed()
assert charge.type_eligibility.status is EligibilityStatus.NEEDS_MORE_ANALYSIS
assert charge.type_eligibility.reason == "Disposition not recognized. Needs further analysis"
def test_misdemeanor_164125():
charge = ChargeFactory.create(name="Theft of services",
statute="164.125",
level="Misdemeanor Class A",
disposition=Dispositions.CONVICTED)
assert isinstance(charge, Misdemeanor)
assert charge.type_eligibility.status is EligibilityStatus.ELIGIBLE
assert charge.type_eligibility.reason == "Eligible under 137.225(5)(b)"
def test_convicted_violation_is_not_type_eligible():
charge = ChargeFactory.create(
statute="801.000", level="Class C Traffic Violation", disposition=Dispositions.CONVICTED
)
assert isinstance(charge, TrafficViolation)
assert charge.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert charge.type_eligibility.reason == "Ineligible under 137.225(7)(a)"
assert not charge.blocks_other_charges()
def test_more_than_ten_year_old_conviction(self):
charge = ChargeFactory.create(disposition=['Convicted', Time.TEN_YEARS_AGO])
self.expunger.charges = [charge]
TimeAnalyzer.evaluate(self.expunger)
assert charge.expungement_result.time_eligibility.status is True
assert charge.expungement_result.time_eligibility.reason == ''
assert charge.expungement_result.time_eligibility.date_will_be_eligible is None
def setUp(self):
self.case_1 = CaseFactory.create(case_number="1")
self.case_2 = CaseFactory.create(case_number="2")
self.recent_dismissal = ChargeFactory.create_dismissed_charge(
case_number=self.case_1.case_number,
date=Time.TWO_YEARS_AGO,
violation_type=self.case_1.violation_type)
self.case_1.charges = [self.recent_dismissal]
def setUp(self):
self.charge_dict = ChargeFactory.build()
case = CaseFactory.create(type_status=["Municipal Parking", "Closed"])
self.charge_dict["statute"] = "109"
self.charge_dict["case"] = case
self.charge_dict["level"] = "Violation Unclassified"
last_week = datetime.today() - timedelta(days=7)
self.convicted = ["Convicted", last_week]
self.dismissed = ["Dismissed", last_week]
def test_marijuana_eligible_hidden_in_summary():
charge = ChargeFactory.create(
name="Delivery of Marijuana to Minor",
statute="4758604A",
level="Felony Class A",
disposition=Dispositions.DISMISSED,
)
assert isinstance(charge, DismissedCharge)
assert charge.hidden_in_record_summary() == False
def test_10_yr_old_conviction_with_less_than_3_yr_old_mrc(self):
ten_yr_charge = ChargeFactory.create(
disposition=['Convicted', Time.TEN_YEARS_AGO])
less_than_three_yr_mrc = ChargeFactory.create(
disposition=['Convicted', Time.LESS_THAN_THREE_YEARS_AGO])
self.expunger.most_recent_conviction = less_than_three_yr_mrc
self.expunger.charges = [ten_yr_charge, less_than_three_yr_mrc]
TimeAnalyzer.evaluate(self.expunger)
assert ten_yr_charge.expungement_result.time_eligibility.status is False
assert ten_yr_charge.expungement_result.time_eligibility.reason == 'Time-ineligible under 137.225(7)(b)'
assert ten_yr_charge.expungement_result.time_eligibility.date_will_be_eligible == less_than_three_yr_mrc.disposition.date + Time.TEN_YEARS
assert less_than_three_yr_mrc.expungement_result.time_eligibility.status is False
assert less_than_three_yr_mrc.expungement_result.time_eligibility.reason == 'Most recent conviction is less than three years old'
assert less_than_three_yr_mrc.expungement_result.time_eligibility.date_will_be_eligible == date.today(
) + relativedelta(days=+1)
def test_other_charge_type_true_negatives(
person_felony_statute_with_other_charge_type):
charges = ChargeFactory.create_ambiguous_charge(
name="Generic",
statute=person_felony_statute_with_other_charge_type,
level="Felony Class B",
disposition=Dispositions.CONVICTED,
)
assert [not isinstance(charge, PersonFelonyClassB) for charge in charges]
def test_it_does_not_set_2nd_mrc_when_greater_than_10yrs(self):
self.mrc_charge.disposition = Disposition(Time.LESS_THAN_TEN_YEARS_AGO, 'Convicted')
second_mrc_charge = ChargeFactory.create()
second_mrc_charge.disposition = Disposition(Time.TEN_YEARS_AGO, 'Convicted')
self.case.charges = [self.mrc_charge, second_mrc_charge]
self.run_expunger([self.case])
assert self.expunger.second_most_recent_conviction is None
def test_sex_crimes(sex_crimes_statute):
sex_crime_convicted = ChargeFactory.create(
name="Generic",
statute=sex_crimes_statute,
level="Felony Class B",
disposition=Dispositions.CONVICTED)
assert isinstance(sex_crime_convicted.charge_type, SexCrime)
assert sex_crime_convicted.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert sex_crime_convicted.type_eligibility.reason == "Ineligible under 137.225(6)(a)"
def test_it_sets_the_second_most_recent_conviction_within_the_last_10yrs(self):
self.mrc_charge.disposition = Disposition(Time.TWO_YEARS_AGO, 'Convicted')
second_mrc_charge = ChargeFactory.create()
second_mrc_charge.disposition = Disposition(Time.LESS_THAN_TEN_YEARS_AGO, 'Convicted')
self.case.charges = [second_mrc_charge, self.mrc_charge]
self.run_expunger([self.case])
assert self.expunger.second_most_recent_conviction is second_mrc_charge
def test_dismissed_violation_is_not_type_eligible():
charge = ChargeFactory.create(
statute="801.000", level="Class C Traffic Violation", disposition=Dispositions.DISMISSED
)
assert isinstance(charge, TrafficViolation)
assert charge.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert charge.type_eligibility.reason == "Dismissed violations are ineligible by omission from statute"
assert not charge.blocks_other_charges()
def test_charge_provider_returns_valid_charge():
# GIVEN
Proxy()
charge = ChargeFactory(id=1)
Proxy().load(full=True)
# WHEN
provided_charge = ChargeProvider().get_charge(1)
# THEN
assert provided_charge == charge
def test_mrc_grouped_within_other_charges(self):
self.mrc_charge.disposition = Disposition(Time.TWO_YEARS_AGO,
"Convicted")
charge = ChargeFactory.create()
charge.disposition = Disposition(Time.TEN_YEARS_AGO, "Convicted")
self.case.charges = [charge, charge, self.mrc_charge, charge, charge]
self.run_expunger([self.case])
assert self.charges_with_summary.most_recent_conviction is self.mrc_charge
def test_violation_dismissed():
charge = ChargeFactory.create(name="Viol Treatment",
statute="1615662",
level="Violation Unclassified",
disposition=Dispositions.DISMISSED)
assert isinstance(charge.charge_type, Violation)
assert charge.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert charge.type_eligibility.reason == "Dismissed violations are ineligible by omission from statute"
def test_delivery_4758602():
marijuana_eligible_charge = ChargeFactory.create(
name="Delivery of Marijuana for Consideration",
statute="4758602",
level="Felony Class B",
disposition=Dispositions.CONVICTED,
)
assert isinstance(marijuana_eligible_charge.charge_type, MarijuanaEligible)
def test_attempt_to_commit_felony_class_b_charge():
charge = ChargeFactory.create_ambiguous_charge(
name="Attempt to Commit a Class B Felony",
statute="161.405(2)(c)",
level="Felony Class C",
disposition=Dispositions.CONVICTED,
)
assert isinstance(charge[0].charge_type, SexCrime)
assert isinstance(charge[1].charge_type, FelonyClassC)
def test_subsection_6_163145():
charges = ChargeFactory.create_ambiguous_charge(
name="Criminally negligent homicide",
statute="163.145",
level="Misdemeanor Class A",
disposition=Dispositions.CONVICTED,
)
assert isinstance(charges[0].charge_type, Misdemeanor)
def test_felony_b_person_felony_with_missing_subsection(person_felony_statute):
person_felony_class_b_convicted = ChargeFactory.create(
name="Generic",
statute=person_felony_statute[:6],
level="Felony Class B",
disposition=Dispositions.CONVICTED)
assert isinstance(person_felony_class_b_convicted, PersonFelonyClassB)
assert person_felony_class_b_convicted.type_eligibility.status is EligibilityStatus.INELIGIBLE
assert person_felony_class_b_convicted.type_eligibility.reason == "Ineligible under 137.225(5)(a)"
def create_class_b_felony_charge(case_number, date, ruling="Convicted"):
return ChargeFactory.create(
case_number=case_number,
name="Aggravated theft in the first degree",
statute="164.057",
level="Felony Class B",
date=date,
disposition=DispositionCreator.create(ruling=ruling, date=date),
)
def test_arrest_is_unaffected_if_conviction_eligibility_is_older():
violation_charge = ChargeFactory.create(
level="Class A Violation",
date=Time.TEN_YEARS_AGO,
disposition=DispositionCreator.create(
ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO),
)
arrest = ChargeFactory.create(disposition=DispositionCreator.create(
ruling="Dismissed", date=Time.ONE_YEAR_AGO))
case = CaseFactory.create(charges=tuple([violation_charge, arrest]))
expunger_result = Expunger.run(Record(tuple([case])))
assert expunger_result[
arrest.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
assert expunger_result[
arrest.ambiguous_charge_id].date_will_be_eligible == arrest.date
assert expunger_result[arrest.ambiguous_charge_id].reason == "Eligible now"
def test_3_violations_are_time_restricted():
violation_charge_1 = ChargeFactory.create(
level="Class A Violation",
date=Time.LESS_THAN_THREE_YEARS_AGO,
disposition=DispositionCreator.create(
ruling="Convicted", date=Time.LESS_THAN_THREE_YEARS_AGO),
)
violation_charge_2 = ChargeFactory.create(
level="Class A Violation",
date=Time.TWO_YEARS_AGO,
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.TWO_YEARS_AGO),
)
violation_charge_3 = ChargeFactory.create(
level="Class A Violation",
date=Time.ONE_YEAR_AGO,
disposition=DispositionCreator.create(ruling="Convicted",
date=Time.ONE_YEAR_AGO),
)
arrest = ChargeFactory.create(disposition=DispositionCreator.create(
ruling="Dismissed", date=Time.ONE_YEAR_AGO))
case = CaseFactory.create(charges=tuple(
[violation_charge_3, violation_charge_2, violation_charge_1, arrest]))
expunger_result = Expunger.run(Record(tuple([case])))
earliest_date_eligible = min(
expunger_result[
violation_charge_1.ambiguous_charge_id].date_will_be_eligible,
expunger_result[
violation_charge_2.ambiguous_charge_id].date_will_be_eligible,
expunger_result[
violation_charge_3.ambiguous_charge_id].date_will_be_eligible,
)
assert expunger_result[
arrest.ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
assert (
expunger_result[arrest.ambiguous_charge_id].reason ==
'Time eligibility of the arrest matches conviction on the same case (the "friendly" rule)'
)
assert expunger_result[
arrest.
ambiguous_charge_id].date_will_be_eligible == earliest_date_eligible
def test_subsection_6_163205():
charges = ChargeFactory.create_ambiguous_charge(
name="Criminal mistreatment in the first degree",
statute="163.205",
level="Felony Class C",
disposition=Dispositions.CONVICTED,
)
assert isinstance(charges[0].charge_type, FelonyClassC)
assert isinstance(charges[1].charge_type, Subsection6)
def test_subsection_6_163575():
charges = ChargeFactory.create_ambiguous_charge(
name="Endangering the welfare of a minor",
statute="163.575",
level="Misdemeanor Class A",
disposition=Dispositions.CONVICTED,
)
assert isinstance(charges[0].charge_type, Subsection6)
assert isinstance(charges[1].charge_type, Misdemeanor)
