Esempio n. 1
0
    def test_all_mrd_case_related_dismissals_are_expungeable(self):
        case_related_dismissal = ChargeFactory.create_dismissed_charge(
            case_number=self.case_1.case_number, date=Time.TWO_YEARS_AGO)
        updated_case_1 = replace(
            self.case_1,
            charges=tuple([*self.case_1.charges, case_related_dismissal]))
        record = Record(tuple([updated_case_1]))
        expunger_result = Expunger.run(record)

        assert expunger_result[
            self.recent_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
        assert expunger_result[
            self.recent_dismissal.ambiguous_charge_id].reason == "Eligible now"
        assert expunger_result[
            self.recent_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.TWO_YEARS_AGO

        assert expunger_result[
            case_related_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
        assert expunger_result[case_related_dismissal.
                               ambiguous_charge_id].reason == "Eligible now"
        assert expunger_result[
            case_related_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.TWO_YEARS_AGO
class TestExpungementAnalyzerUnitTests(unittest.TestCase):

    TEN_YEARS = (date.today() + relativedelta(years=-10)).strftime('%m/%d/%Y')
    LESS_THAN_TEN_YEARS_AGO = (
        date.today() + relativedelta(years=-10, days=+1)).strftime('%m/%d/%Y')
    LESS_THAN_THREE_YEARS_AGO = (
        date.today() + relativedelta(years=-3, days=+1)).strftime('%m/%d/%Y')
    THREE_YEARS_AGO = (date.today() +
                       relativedelta(years=-3)).strftime('%m/%d/%Y')
    TWO_YEARS_AGO = (date.today() +
                     relativedelta(years=-2)).strftime('%m/%d/%Y')
    ONE_YEAR_AGO = (date.today() +
                    relativedelta(years=-1)).strftime('%m/%d/%Y')

    TWO_YEAR_AGO_DATE = (date.today() + relativedelta(years=-2))
    ONE_YEAR_AGO_DATE = (date.today() + relativedelta(years=-1))
    THREE_YEAR_AGO_DATE = (date.today() + relativedelta(years=-3))
    FOUR_YEAR_AGO_DATE = (date.today() + relativedelta(years=-4))

    def test_expunger_sets_most_recent_dismissal_when_charge_is_less_than_3yrs(
            self):
        case = CaseFactory.create()
        mrd_charge = ChargeFactory.create_dismissed_charge(
            date=self.LESS_THAN_THREE_YEARS_AGO)
        case.charges = [mrd_charge]

        expunger = Expunger([case])
        expunger.run()

        assert expunger._most_recent_dismissal is mrd_charge
Esempio n. 3
0
    def test_all_mrd_case_related_dismissals_are_expungeable(self):
        case_related_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.append(case_related_dismissal)

        record = Record([self.case_1])
        expunger = Expunger(record)
        expunger_result = expunger.run()

        assert expunger_result[
            self.recent_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
        assert expunger_result[
            self.recent_dismissal.ambiguous_charge_id].reason == "Eligible now"
        assert expunger_result[
            self.recent_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.TWO_YEARS_AGO

        assert expunger_result[
            case_related_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
        assert expunger_result[case_related_dismissal.
                               ambiguous_charge_id].reason == "Eligible now"
        assert expunger_result[
            case_related_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.TWO_YEARS_AGO
Esempio n. 4
0
    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]
Esempio n. 5
0
class TestExpungementAnalyzerUnitTests(unittest.TestCase):
    def test_expunger_sets_most_recent_dismissal_when_charge_is_less_than_3yrs(
            self):
        case = CaseFactory.create()
        mrd_charge = ChargeFactory.create_dismissed_charge(
            date=Time.LESS_THAN_THREE_YEARS_AGO)
        case.charges = [mrd_charge]
        record = Record([case])

        charges = ChargesSummarizer.summarize(record.charges)
        assert charges.most_recent_dismissal is mrd_charge
    def test_mrd_does_not_block_other_dismissals(self):
        unrelated_dismissal = ChargeFactory.create_dismissed_charge(
            case_number="2", date=Time.TEN_YEARS_AGO, violation_type="Offense Misdemeanor"
        )
        case_2 = CaseFactory.create(case_number="2", charges=tuple([unrelated_dismissal]))

        record = Record(tuple([self.case_1, case_2]))
        expunger_result = Expunger.run(record)

        assert expunger_result[unrelated_dismissal.ambiguous_charge_id].status is EligibilityStatus.ELIGIBLE
        assert expunger_result[unrelated_dismissal.ambiguous_charge_id].reason == "Eligible now"
        assert expunger_result[unrelated_dismissal.ambiguous_charge_id].date_will_be_eligible == Time.TEN_YEARS_AGO
Esempio n. 7
0
    def test_mrd_blocks_dismissals_in_unrelated_cases(self):
        unrelated_dismissal = ChargeFactory.create_dismissed_charge(
            case_number="2",
            date=Time.TEN_YEARS_AGO,
            violation_type="Offense Misdemeanor")
        case_2 = CaseFactory.create(case_number="2",
                                    charges=tuple([unrelated_dismissal]))

        record = Record(tuple([self.case_1, case_2]))
        expunger_result = Expunger.run(record)

        assert expunger_result[
            unrelated_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
        assert (expunger_result[unrelated_dismissal.ambiguous_charge_id].reason
                == "Three years from most recent other arrest (137.225(8)(a))")
        assert expunger_result[
            unrelated_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.ONE_YEARS_FROM_NOW
Esempio n. 8
0
    def test_mrd_blocks_dismissals_in_unrelated_cases(self):
        unrelated_dismissal = ChargeFactory.create_dismissed_charge(
            case_number=self.case_2.case_number,
            date=Time.TEN_YEARS_AGO,
            violation_type=self.case_2.violation_type)
        self.case_2.charges = [unrelated_dismissal]

        record = Record([self.case_1, self.case_2])
        expunger = Expunger(record)
        expunger_result = expunger.run()

        assert expunger_result[
            unrelated_dismissal.
            ambiguous_charge_id].status is EligibilityStatus.INELIGIBLE
        assert (expunger_result[unrelated_dismissal.ambiguous_charge_id].reason
                == "Three years from most recent other arrest (137.225(8)(a))")
        assert expunger_result[
            unrelated_dismissal.
            ambiguous_charge_id].date_will_be_eligible == Time.ONE_YEARS_FROM_NOW
Esempio n. 9
0
 def setUp(self):
     self.recent_dismissal = ChargeFactory.create_dismissed_charge(
         case_number="1", date=Time.TWO_YEARS_AGO)
     self.case_1 = CaseFactory.create(case_number="1",
                                      charges=tuple([self.recent_dismissal
                                                     ]))
Esempio n. 10
0
class TestExpungementAnalyzerUnitTests(unittest.TestCase):
    def test_expunger_sets_most_recent_dismissal_when_charge_is_less_than_3yrs(
            self):
        case = CaseFactory.create()
        mrd_charge = ChargeFactory.create_dismissed_charge(
            date=Time.LESS_THAN_THREE_YEARS_AGO)
        case.charges = [mrd_charge]
        record = Record([case])

        charges = ChargesSummarizer.summarize(record.charges)
        assert charges.most_recent_dismissal is mrd_charge

    def test_expunger_does_not_set_most_recent_dismissal_when_case_is_older_than_3yrs(
            self):
        case = CaseFactory.create()
        charge_1 = ChargeFactory.create_dismissed_charge(
            date=Time.THREE_YEARS_AGO)
        charge_2 = ChargeFactory.create_dismissed_charge(
            date=Time.THREE_YEARS_AGO)
        case.charges = [charge_1, charge_2]
        record = Record([case])

        charges = ChargesSummarizer.summarize(record.charges)
        assert charges.most_recent_dismissal is None

    def test_expunger_sets_mrd_when_mrd_is_in_middle_of_list(self):
        case = CaseFactory.create()
        mrd_charge = ChargeFactory.create_dismissed_charge(
            date=Time.TWO_YEARS_AGO)
        charge = ChargeFactory.create_dismissed_charge(
            date=Time.LESS_THAN_THREE_YEARS_AGO)
        case.charges = [charge, charge, mrd_charge, charge, charge]
    def test_expunger_sets_most_recent_dismissal_when_charge_is_less_than_3yrs(
            self):
        case = CaseFactory.create()
        mrd_charge = ChargeFactory.create_dismissed_charge(
            date=self.LESS_THAN_THREE_YEARS_AGO)
        case.charges = [mrd_charge]

        expunger = Expunger([case])
        expunger.run()

        assert expunger._most_recent_dismissal is mrd_charge

    def test_expunger_does_not_set_most_recent_dismissal_when_case_is_older_than_3yrs(
            self):
        case = CaseFactory.create()
        charge_1 = ChargeFactory.create_dismissed_charge(
            date=self.THREE_YEARS_AGO)
        charge_2 = ChargeFactory.create_dismissed_charge(
            date=self.THREE_YEARS_AGO)
        case.charges = [charge_1, charge_2]

        expunger = Expunger([case])
        expunger.run()

        assert expunger._most_recent_dismissal is None

    def test_expunger_sets_mrd_when_mrd_is_in_middle_of_list(self):
        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)