def setUp(self):
last_week = datetime.today() - timedelta(days=7)
self.single_charge = ChargeFactory.build()
self.single_charge["disposition"] = Disposition(date=last_week,
ruling="No Complaint")
self.charges = []
case_all_eligible.charges = [
ChargeFactory.create(
case=case_all_eligible,
name="Theft of dignity",
disposition=Disposition(ruling="Convicted",
date=Time.TEN_YEARS_AGO),
)
]
case_partially_eligible = CaseFactory.create(
case_number="0001",
balance="200.00",
date_location=["1/1/1995", "Clackamas"])
case_partially_eligible.charges = [
ChargeFactory.create(case=case_partially_eligible,
disposition=Disposition(ruling="Convicted",
date=Time.TEN_YEARS_AGO)),
ChargeFactory.create(
case=case_partially_eligible,
level="Felony Class A",
disposition=Disposition(ruling="Convicted",
date=Time.TEN_YEARS_AGO),
),
]
case_possibly_eligible = CaseFactory.create(
case_number="0002",
balance="300.00",
date_location=["1/1/1995", "Baker"])
case_possibly_eligible.charges = [
ChargeFactory.create(
case=case_possibly_eligible,
def setUp(self):
last_week = (datetime.today() - timedelta(days=7)).strftime('%m/%d/%Y')
self.single_charge = ChargeFactory.build()
self.single_charge['disposition'] = Disposition(ruling='Acquitted',
date=last_week)
self.charges = []
def setUp(self):
last_week = datetime.today() - timedelta(days=7)
self.dismissal = Disposition(ruling="Dismissed", date=last_week)
self.charge_dict = ChargeFactory.build()
self.charge_dict["disposition"] = Disposition(ruling="Convicted",
date=last_week)
def test_it_sets_most_recent_conviction_from_the_last_10yrs(self):
self.mrc_charge.disposition = Disposition(Time.LESS_THAN_TEN_YEARS_AGO, 'Convicted')
self.case.charges = [self.mrc_charge]
self.run_expunger([self.case])
assert self.expunger.most_recent_conviction is self.mrc_charge
def create_recent_charge(self):
charge = ChargeFactory.save(self.single_charge)
last_week = datetime.today() - timedelta(days=7)
charge.disposition = Disposition(ruling="Convicted", date=last_week)
return charge
}
@staticmethod
def save(charge):
return Charge.create(**charge)
@staticmethod
def create(case=CaseFactory.create(),
name='Theft of services',
statute='164.125',
level='Misdemeanor Class A',
date='1/1/0001',
disposition=None):
if disposition:
ruling, date = disposition
disposition = Disposition(date=date, ruling=ruling)
kwargs = {
'case': case,
'name': name,
'statute': statute,
'level': level,
'date': date,
'disposition': disposition
}
return Charge.create(**kwargs)
@staticmethod
def create_dismissed_charge(case=CaseFactory.create(),
name='Theft of services',
statute='164.125',
class TestDismissalBlock(unittest.TestCase):
def setUp(self):
self.case_1 = CaseFactory.create()
self.case_2 = CaseFactory.create()
self.recent_dismissal = ChargeFactory.create_dismissed_charge(
case=self.case_1, date=Time.TWO_YEARS_AGO)
self.case_1.charges = [self.recent_dismissal]
def test_record_with_only_an_mrd_is_time_eligible(self):
record = Record([self.case_1])
expunger = Expunger(record)
expunger.run()
assert self.recent_dismissal.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE
assert self.recent_dismissal.expungement_result.time_eligibility.reason == ""
assert self.recent_dismissal.expungement_result.time_eligibility.date_will_be_eligible == Time.TWO_YEARS_AGO
def test_all_mrd_case_related_dismissals_are_expungeable(self):
case_related_dismissal = ChargeFactory.create_dismissed_charge(
case=self.case_1, date=Time.TWO_YEARS_AGO)
self.case_1.charges.append(case_related_dismissal)
record = Record([self.case_1])
expunger = Expunger(record)
expunger.run()
assert self.recent_dismissal.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE
assert self.recent_dismissal.expungement_result.time_eligibility.reason == ""
assert self.recent_dismissal.expungement_result.time_eligibility.date_will_be_eligible == Time.TWO_YEARS_AGO
assert case_related_dismissal.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE
assert case_related_dismissal.expungement_result.time_eligibility.reason == ""
assert case_related_dismissal.expungement_result.time_eligibility.date_will_be_eligible == Time.TWO_YEARS_AGO
def test_mrd_blocks_dismissals_in_unrelated_cases(self):
unrelated_dismissal = ChargeFactory.create_dismissed_charge(
case=self.case_2, date=Time.TEN_YEARS_AGO)
self.case_2.charges = [unrelated_dismissal]
record = Record([self.case_1, self.case_2])
expunger = Expunger(record)
expunger.run()
assert unrelated_dismissal.expungement_result.time_eligibility.status is EligibilityStatus.INELIGIBLE
assert (unrelated_dismissal.expungement_result.time_eligibility.reason
== "Three years from most recent other arrest (137.225(8)(a))")
assert unrelated_dismissal.expungement_result.time_eligibility.date_will_be_eligible == Time.ONE_YEARS_FROM_NOW
def test_mrd_does_not_block_convictions(self):
case = CaseFactory.create()
convicted_charge = ChargeFactory.create(
case=case,
date=Time.TWENTY_YEARS_AGO,
disposition=Disposition(ruling="Convicted",
date=Time.TWENTY_YEARS_AGO),
)
case.charges = [convicted_charge]
record = Record([self.case_1, case])
expunger = Expunger(record)
expunger.run()
assert convicted_charge.expungement_result.time_eligibility.status is EligibilityStatus.ELIGIBLE
assert convicted_charge.expungement_result.time_eligibility.reason == ""
assert (convicted_charge.expungement_result.time_eligibility.
date_will_be_eligible == convicted_charge.disposition.date +
relativedelta(years=+3))
kwargs = {
"case": case,
"name": name,
"statute": statute,
"level": level,
"date": date_string,
"disposition": disposition,
}
return ChargeCreator.create(**kwargs)
@staticmethod
def create_dismissed_charge(
case=CaseFactory.create(),
name="Theft of services",
statute="164.125",
level="Misdemeanor Class A",
date=date_class(1901, 1, 1),
):
disposition = Disposition(date=date_class.today(), ruling="Dismissed")
kwargs = {
"case": case,
"name": name,
"statute": statute,
"level": level,
"date": date.strftime("%m/%d/%Y"),
"disposition": disposition,
}
return ChargeCreator.create(**kwargs)
def create_charge(self):
charge = ChargeFactory.save(self.charge)
charge.disposition = Disposition(**self.convicted_disposition)
return charge
def build_charges(statute, disposition_ruling):
last_week = datetime.today() - timedelta(days=7)
return ChargeFactory.create_ambiguous_charge(statute=statute,
disposition=Disposition(
ruling=disposition_ruling,
date=last_week))
class Dispositions:
LAST_WEEK = datetime.today() - timedelta(days=7)
CONVICTED = Disposition(ruling="Convicted", date=LAST_WEEK)
DISMISSED = Disposition(ruling="Dismissed", date=LAST_WEEK)
UNRECOGNIZED_DISPOSITION = Disposition(ruling="Something unrecognized", date=LAST_WEEK)
NO_COMPLAINT = Disposition(ruling="No Complaint", date=LAST_WEEK)
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_eligible_mrc_with_violation():
case = CaseFactory.create()
three_yr_mrc = ChargeFactory.create(case=case,
disposition=Disposition(
ruling="Convicted",
date=Time.THREE_YEARS_AGO))
arrest = ChargeFactory.create(case=case,
disposition=Disposition(
ruling="Dismissed",
date=Time.THREE_YEARS_AGO))
violation = ChargeFactory.create(level="Violation",
case=case,
disposition=Disposition(
ruling="Convicted",
date=Time.THREE_YEARS_AGO))
case.charges = [three_yr_mrc, arrest, violation]
record = Record([case])
case = CaseFactory.create()
mrd_charge = ChargeFactory.create_dismissed_charge(
date=self.TWO_YEARS_AGO)
charge = ChargeFactory.create_dismissed_charge(
date=self.LESS_THAN_THREE_YEARS_AGO)
case.charges = [charge, charge, mrd_charge]
expunger = Expunger([case])
expunger.run()
assert expunger._most_recent_dismissal is mrd_charge
def test_it_sets_most_recent_conviction_from_the_last_10yrs(self):
case = CaseFactory.create()
mrc_charge = ChargeFactory.create()
mrc_charge.disposition = Disposition(self.LESS_THAN_TEN_YEARS_AGO,
'Convicted')
case.charges = [mrc_charge]
expunger = Expunger([case])
expunger.run()
assert expunger._most_recent_conviction is mrc_charge
def test_it_sets_the_second_most_recent_conviction_within_the_last_10yrs(
self):
case = CaseFactory.create()
mrc_charge = ChargeFactory.create()
mrc_charge.disposition = Disposition(self.TWO_YEARS_AGO, 'Convicted')
second_mrc_charge = ChargeFactory.create()
second_mrc_charge.disposition = Disposition(
self.LESS_THAN_TEN_YEARS_AGO, 'Convicted')
def test_it_knows_if_it_has_a_recent_conviction_happy_path(self):
charge = ChargeFactory.create()
charge.disposition = Disposition(self.LESS_THAN_TEN_YEARS_AGO,
"Convicted")
assert charge.recent_conviction() is True
three_yr_conviction.expungement_result.time_eligibility.reason ==
"Ten years from most recent other conviction (137.225(7)(b))")
assert three_yr_conviction.expungement_result.time_eligibility.date_will_be_eligible == date.today(
) + relativedelta(years=7, days=1)
assert arrest.expungement_result.time_eligibility.status is EligibilityStatus.INELIGIBLE
assert arrest.expungement_result.time_eligibility.date_will_be_eligible == date.today(
) + relativedelta(years=7)
def test_ineligible_mrc_with_arrest_on_single_case(self):
# In this case, the friendly rule doesn't apply because the conviction doesn't become eligible
case = CaseFactory.create()
mrc = ChargeFactory.create(
case=case,
disposition=Disposition(ruling="Convicted",
date=Time.LESS_THAN_THREE_YEARS_AGO),
statute="666.666",
level="Felony Class A",
)
arrest = ChargeFactory.create(case=case,
disposition=Disposition(
ruling="Dismissed",
date=Time.LESS_THAN_THREE_YEARS_AGO))
case.charges = [mrc, arrest]
record = Record([case])
expunger = Expunger(record)
expunger.run()
assert arrest.expungement_result.time_eligibility.status is EligibilityStatus.INELIGIBLE
def test_it_knows_if_it_has_a_recent_conviction_sad_path(self):
charge = ChargeFactory.create()
charge.disposition = Disposition(self.TEN_YEARS_AGO, "Convicted")
assert charge.recent_conviction() is False
def setUp(self):
last_week = (datetime.today() - timedelta(days=7)).strftime('%m/%d/%Y')
disposition = Disposition(ruling='Convicted', date=last_week)
self.charge = ChargeFactory.build(disposition=disposition)
self.charges = []
def test_dismissed_charge_is_not_a_recent_conviction(self):
charge = ChargeFactory.create()
charge.disposition = Disposition(self.LESS_THAN_TEN_YEARS_AGO,
"Dismissed")
assert charge.recent_conviction() is False
def test_it_does_not_set_mrc_when_greater_than_10yrs(self):
self.mrc_charge.disposition = Disposition(Time.TEN_YEARS_AGO, 'Convicted')
self.case.charges = [self.mrc_charge]
self.run_expunger([self.case])
assert self.expunger.most_recent_conviction is None
def test_most_recent_dismissal_happy_path(self):
charge = ChargeFactory.create(date=self.LESS_THAN_THREE_YEARS_AGO)
charge.disposition = Disposition(date=self.LESS_THAN_THREE_YEARS_AGO,
ruling="Dismissed")
assert charge.recent_dismissal() is True
def setUp(self):
last_week = datetime.today() - timedelta(days=7)
disposition = Disposition(ruling="Convicted", date=last_week)
self.charge = ChargeFactory.build(disposition=disposition)
self.charges = []
def test_most_recent_dismissal_sad_path(self):
charge = ChargeFactory.create(date=self.THREE_YEARS_AGO)
charge.disposition = Disposition(date=self.THREE_YEARS_AGO,
ruling="Dismissed")
assert charge.recent_dismissal() is False
violation_type="Something",
current_status="CLOSED",
case_detail_link="alink",
balance_due_in_cents=0,
edit_status=EditStatus.UNCHANGED,
),
(
OeciCharge(
ambiguous_charge_id="X0001-1",
name="petty theft",
statute="100.000",
level="Misdemeanor",
date=date(2000, 1, 1),
disposition=Disposition(
date=date(2001, 1, 1),
ruling="Convicted",
status=DispositionStatus.CONVICTED,
amended=False,
),
probation_revoked=None,
balance_due_in_cents=0,
edit_status=EditStatus.UNCHANGED,
),
OeciCharge(
ambiguous_charge_id="X0001-2",
name="assault 3",
statute="200.000",
level="Felony Class C",
date=date(2001, 1, 1),
disposition=Disposition(
date=date(2001, 1, 1),
ruling="Convicted",
def test_convicted_charge_is_not_a_recent_dismissal(self):
charge = ChargeFactory.create(date=self.LESS_THAN_THREE_YEARS_AGO)
charge.disposition = Disposition(date=self.LESS_THAN_THREE_YEARS_AGO,
ruling="Convicted")
assert charge.recent_dismissal() is False
def __build_charge(charge_id, charge, case_parser):
if case_parser.hashed_dispo_data.get(charge_id):
charge['disposition'] = Disposition(
case_parser.hashed_dispo_data[charge_id].get('date'),
case_parser.hashed_dispo_data[charge_id].get('ruling'))
return ChargeCreator.create(**charge)
def setUp(self):
last_week = datetime.today() - timedelta(days=7)
self.single_charge = ChargeFactory.build()
self.single_charge["disposition"] = Disposition(ruling="Dismissed",
date=last_week)
self.charges = []
