class ExecuteCenterChangeTest(TestCase):
"""
Test executeing center change changesets.
Each test will set up a change in a different way but that ought to have the same
results. Then we'll try to roll back the change, after having one voter change
their registration, and check those results.
"""
def setUp(self):
self.from_center_1 = RegistrationCenterFactory()
self.from_center_2 = RegistrationCenterFactory()
self.center_3 = RegistrationCenterFactory()
self.to_center = RegistrationCenterFactory()
# these should be moved
self.reg1 = RegistrationFactory(registration_center=self.from_center_1, archive_time=None)
self.reg2 = RegistrationFactory(registration_center=self.from_center_2, archive_time=None)
# these should not
self.reg3 = RegistrationFactory(registration_center=self.center_3, archive_time=None)
self.reg4 = RegistrationFactory(registration_center=self.to_center, archive_time=None)
self.changeset = ChangesetFactory(
status=Changeset.STATUS_APPROVED,
change=Changeset.CHANGE_CENTER,
target_center=self.to_center
)
def doit(self):
# Execute the changeset and check out the results
self.changeset.full_clean()
citizens = self.changeset.get_citizens_to_change()
self.assertIn(self.reg1.citizen, citizens)
self.assertIn(self.reg2.citizen, citizens)
self.assertNotIn(self.reg3.citizen, citizens)
# citizen4 might or might not be in the 'get_citizens_to_change' result depending
# on the test
self.changeset.execute()
self.assertEqual(self.to_center, refresh_model(self.reg1).registration_center)
# There should also be an archived registration that is unchanged
archives = Registration.objects.archived()
self.assertEqual(1, archives.filter(citizen=self.reg1.citizen,
registration_center=self.from_center_1).count())
self.assertEqual(self.to_center, refresh_model(self.reg2).registration_center)
# There should also be an archived registration that is unchanged
self.assertEqual(1, archives.filter(citizen=self.reg2.citizen,
registration_center=self.from_center_2).count())
# reg 3 not moved, was at center 3
self.assertEqual(self.center_3, refresh_model(self.reg3).registration_center)
# No archived center
self.assertFalse(archives.filter(citizen=self.reg3.citizen).exists())
# reg 4 not moved, but was already at to_center
self.assertEqual(self.to_center, refresh_model(self.reg4).registration_center)
# No archived center
self.assertFalse(archives.filter(citizen=self.reg4.citizen).exists())
changeset = refresh_model(self.changeset)
if self.changeset.how_to_select == Changeset.SELECT_UPLOADED_NIDS:
# Ugh - this was the only test where we could "add" citizen4
self.assertEqual(Changeset.STATUS_PARTIALLY_SUCCESSFUL, changeset.status)
else:
self.assertEqual(Changeset.STATUS_SUCCESSFUL, changeset.status)
changes = changeset.change_records
self.assertEqual(1, changes.filter(citizen=self.reg1.citizen, changed=True).count())
self.assertEqual(1, changes.filter(citizen=self.reg2.citizen, changed=True).count())
# self.reg3 shouldn't be mentioned, they weren't in the set to be changed
self.assertFalse(changes.filter(citizen=self.reg3.citizen).exists())
# self.reg4 might or might not have a change record, but if it does, changed
# should be False
self.assertFalse(changes.filter(citizen=self.reg4.citizen, changed=True).exists())
# the citizen from self.reg2 moves themselves to another center, so they
# should not be rolled back
self.reg2.registration_center = self.center_3
self.reg2.save()
# Do a rollback
rollback = ChangesetFactory(
status=Changeset.STATUS_APPROVED,
change=Changeset.CHANGE_ROLLBACK,
how_to_select=Changeset.SELECT_OTHER_CHANGESET,
other_changeset=changeset,
)
rollback.full_clean()
citizens = list(rollback.get_citizens_to_change())
self.assertIn(self.reg1.citizen, citizens)
self.assertIn(self.reg2.citizen, citizens) # In the list, but we won't change them
self.assertNotIn(self.reg3.citizen, citizens)
self.assertNotIn(self.reg4.citizen, citizens) # was not changed
rollback.execute()
rollback = refresh_model(rollback)
self.assertEqual(Changeset.STATUS_PARTIALLY_SUCCESSFUL, rollback.status)
changeset = refresh_model(changeset)
self.assertEqual(Changeset.STATUS_ROLLED_BACK, changeset.status)
self.assertEqual(rollback, changeset.rollback_changeset)
self.assertEqual(self.from_center_1, refresh_model(self.reg1).registration_center)
# reg1 was changed then changed back, so there should be two archived versions
self.assertEqual(2, archives.filter(citizen=self.reg1.citizen).count())
self.assertEqual(1, archives.filter(citizen=self.reg1.citizen,
registration_center=self.from_center_1).count())
self.assertEqual(1, archives.filter(citizen=self.reg1.citizen,
registration_center=self.to_center).count())
self.assertEqual(self.center_3, refresh_model(self.reg2).registration_center)
self.assertEqual(1, rollback.change_records.filter(citizen=self.reg1.citizen, changed=True)
.count())
self.assertEqual(1, rollback.change_records.filter(citizen=self.reg2.citizen, changed=False)
.count())
def test_execute_center_change_by_center_and_partial_rollback(self):
# test selecting voters by center
self.changeset.how_to_select = Changeset.SELECT_CENTERS
self.changeset.save()
self.changeset.selected_centers.add(self.from_center_1, self.from_center_2)
self.doit()
def test_execute_center_change_by_upload_and_partial_rollback(self):
# test selecting voters by upload
self.changeset.how_to_select = Changeset.SELECT_UPLOADED_NIDS
self.changeset.save()
self.changeset.selected_citizens.add(self.reg1.citizen, self.reg2.citizen,
self.reg4.citizen)
self.doit()
def test_execute_center_change_by_another_changeset_and_partial_rollback(self):
# test selecting voters from another changeset
first_changeset = ChangesetFactory(status=Changeset.STATUS_SUCCESSFUL)
ChangeRecordFactory(changeset=first_changeset, citizen=self.reg1.citizen, changed=True)
ChangeRecordFactory(changeset=first_changeset, citizen=self.reg2.citizen, changed=True)
# reg3 had a change record, but was not changed
ChangeRecordFactory(changeset=first_changeset, citizen=self.reg3.citizen, changed=False)
# reg4 doesn't show up at all
self.changeset.how_to_select = Changeset.SELECT_OTHER_CHANGESET
self.changeset.other_changeset = first_changeset
self.changeset.save()
self.doit()