def test_copy_read_only(self):
"""test that copy centers are uneditable once created."""
copy_center = RegistrationCenterFactory(center_type=RegistrationCenter.Types.COPY)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(force_text(cm.exception.message), 'Copy centres are read-only.')
def test_copy_of(self):
"""Exercise build_copy_info() for a center that is a copy"""
original = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory(copy_of=original)
expected = '{}: {}'.format(STRINGS['copy_of'],
copy_center.copy_of.center_id)
self.assertEqual(build_copy_info(copy_center), expected)
def setUp(self):
subconstituency_name = os.environ.get('ROLLGEN_TEST_SUBCONSTITUENCY_NAME', '')
subconstituency_name = subconstituency_name.decode('utf-8')
if not subconstituency_name:
subconstituency_name = generate_arabic_place_name()
center_name = os.environ.get('ROLLGEN_TEST_CENTER_NAME', '')
center_name = center_name.decode('utf-8')
if not center_name:
center_name = generate_arabic_place_name()
subconstituency = SubConstituencyFactory(name_arabic=subconstituency_name)
self.center = RegistrationCenterFactory(subconstituency=subconstituency, name=center_name)
# For the center that has copies, I give it the max number of copies possible in order
# to force the 'copied by' string to be as long as possible to reveal any line wrapping
# problems that result.
self.original_center = RegistrationCenterFactory()
self.copy_centers = RegistrationCenterFactory.create_batch(settings.N_MAX_COPY_CENTERS,
copy_of=self.original_center)
self.election = ElectionFactory()
def setUp(self):
self.center = RegistrationCenterFactory(
name=generate_arabic_place_name())
self.center_with_a_copy = RegistrationCenterFactory(
name=generate_arabic_place_name())
self.copy_center = RegistrationCenterFactory(
name=generate_arabic_place_name(), copy_of=self.center_with_a_copy)
# Create an unused center just to clutter things up a bit.
self.unused_center = RegistrationCenterFactory(
name=generate_arabic_place_name())
# Create a few voters and register them at each of these centers (except the copy center
# because voters can't register at copy centers).
self.n_voters = 3
archive_time = now()
self.voters = {}
for center in (self.center, self.center_with_a_copy,
self.unused_center):
self.voters[center] = create_voters(self.n_voters, FEMALE, center)
# Also create an archived registration for each center to ensure that
# get_voter_roll() ignores it.
voter = VoterFactory(post__center=center)
registration = voter.registration
registration.archive_time = archive_time
registration.save()
def test_edit_view(self):
self.center1 = RegistrationCenterFactory()
self.center2 = RegistrationCenterFactory()
data = {
'name': 'My Changeset',
'change': str(Changeset.CHANGE_CENTER),
'how_to_select': str(Changeset.SELECT_CENTERS),
'selected_centers_1': [str(self.center1.pk)],
'target_center_1': str(self.center2.pk),
'justification': 'Just because',
}
changeset = ChangesetFactory(
name=data['name'],
change=Changeset.CHANGE_CENTER,
how_to_select=Changeset.SELECT_CENTERS,
target_center=self.center2,
justification='Just because',
)
changeset.selected_centers.add(self.center1)
url = reverse('edit_changeset', kwargs={'pk': changeset.pk})
rsp = self.client.get(url)
self.assertEqual(OK, rsp.status_code)
data['name'] = 'My Edited Changeset'
data['justification'] = 'My edited justficiation'
rsp = self.client.post(url, data=data, follow=False)
self.assertEqual(302,
rsp.status_code) # , msg=rsp.content.decode('utf-8'))
self.assertRedirects(rsp, reverse('browse_changesets'))
changeset = Changeset.objects.get()
self.assertEqual(data['name'], changeset.name)
self.assertEqual(data['justification'], changeset.justification)
def test_copied_by_one(self):
"""Exercise build_copy_info() for a center that has a single copy"""
original = RegistrationCenterFactory()
RegistrationCenterFactory(copy_of=original)
expected = '{}: {}'.format(STRINGS['copied_by_singular'],
original.copied_by.all()[0].center_id)
self.assertEqual(build_copy_info(original), expected)
def test_find_invalid_center_ids(self):
"""exercise find_invalid_center_ids()"""
centers = [RegistrationCenterFactory(), RegistrationCenterFactory()]
center_ids = [center.center_id for center in centers]
center_ids += [99999, 88888]
# Note that order is preserved
self.assertEqual([99999, 88888], find_invalid_center_ids(center_ids))
def test_copy_center_must_remain_copy_center(self):
"""test that a copy center can't be made into a non-copy center"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory(copy_of=original_center)
copy_center.copy_of = None
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(force_text(cm.exception.message), 'Copy centres are read-only.')
def test_mismatched_numbers(self):
center1 = RegistrationCenterFactory()
center2 = RegistrationCenterFactory()
self.check_it_out("%d*%d" % (center1.center_id, center2.center_id),
POLLING_REPORT_CENTER_MISMATCH,
SMS.POLLING_REPORT_INVALID,
False,
False,
expect_center_opened=False)
def test_copy_read_only(self):
"""test that copy centers are uneditable once created."""
copy_center = RegistrationCenterFactory(
center_type=RegistrationCenter.Types.COPY)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(force_text(cm.exception.message),
'Copy centres are read-only.')
def test_copy_center_is_readonly(self):
"""Ensure copy centers can't be changed except for deleted status"""
original = RegistrationCenterFactory()
copy = RegistrationCenterFactory(copy_of=original)
center_admin = RegistrationCenterAdmin(RegistrationCenter, admin.site)
fields = set(center_admin.get_fields(Mock(), obj=copy))
readonly_fields = set(center_admin.get_readonly_fields(Mock(), obj=copy))
readwrite_fields = list(fields - readonly_fields)
self.assertEqual(readwrite_fields, ['deleted'])
def setUp(self):
self.sms = SMSFactory()
self.citizen = CitizenFactory(national_id=219782058018)
self.center = RegistrationCenterFactory()
RegistrationCenterFactory(center_id=self.center.center_id,
deleted=True)
self.mock_response = Mock()
self.reg_period = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=FUTURE_DAY)
def test_copy_registration_center(self):
"""test that people can't register against a copy center"""
copy_center = RegistrationCenterFactory()
copy_center.copy_of = self.center
copy_center.save()
# try to register
result = process_registration_request(
center_id=copy_center.center_id, national_id=self.citizen.national_id, sms=self.sms
)
self.assertEqual(result.message_code, constants.RESPONSE_CENTER_ID_INVALID)
def test_copy_center_requires_copy_type(self):
"""test that a copy center must have the correct type"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
copy_center.center_type = RegistrationCenter.Types.GENERAL
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(cm.exception.message,
'Copy centre type must be "copy".')
def test_copied_by_multiple(self):
"""Exercise build_copy_info() for a center that has multiple copies"""
original = RegistrationCenterFactory()
copy_centers = RegistrationCenterFactory.create_batch(3,
copy_of=original)
copy_center_ids = sorted([center.center_id for center in copy_centers])
copy_center_ids = (ARABIC_COMMA + ' ').join(map(str, copy_center_ids))
expected = '{}: {}'.format(STRINGS['copied_by_plural'],
copy_center_ids)
self.assertEqual(build_copy_info(original), expected)
def test_copy_of_copy_fails(self):
"""test that a copy center can't be a copy of another copy center"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory(copy_of=original_center)
copy_copy_center = RegistrationCenterFactory.build(copy_of=copy_center)
with self.assertRaises(ValidationError) as cm:
copy_copy_center.clean()
self.assertEqual(cm.exception.message,
'A copy centre cannot copy another copy centre.')
def test_copy_registration_center(self):
"""test that people can't register against a copy center"""
copy_center = RegistrationCenterFactory()
copy_center.copy_of = self.center
copy_center.save()
# try to register
result = process_registration_request(
center_id=copy_center.center_id,
national_id=self.citizen.national_id,
sms=self.sms)
self.assertEqual(result.message_code,
constants.RESPONSE_CENTER_ID_INVALID)
def test_noncopy_center_cannot_become_copy_center(self):
"""test that a non-copy center can't be made into a copy center"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory()
copy_center.copy_of = original_center
copy_center.center_type = RegistrationCenter.Types.COPY
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(force_text(cm.exception.message),
'A centre may not be changed to a copy centre.')
def test_ensure_copied_center_undeletable(self):
"""Ensure centers that have copies can't be deleted"""
original = RegistrationCenterFactory()
copy = RegistrationCenterFactory(copy_of=original)
center_admin = RegistrationCenterAdmin(RegistrationCenter, admin.site)
self.assertIn('deleted', center_admin.get_readonly_fields(Mock(), obj=original))
# However, if the copy is soft deleted, then it's OK to delete the original
copy.deleted = True
copy.save()
center_admin = RegistrationCenterAdmin(RegistrationCenter, admin.site)
self.assertNotIn('deleted', center_admin.get_readonly_fields(Mock(), obj=original))
def test_max_copies_per_center_limit(self):
"""test that register.models.N_MAX_COPY_CENTERS is respected"""
original_center = RegistrationCenterFactory()
create_batch(RegistrationCenterFactory,
settings.N_MAX_COPY_CENTERS,
copy_of=original_center)
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
msg = 'Copy centre already has the maximum number of copies ({n_max}).'
self.assertEqual(cm.exception.message,
msg.format(n_max=settings.N_MAX_COPY_CENTERS))
def setUp(self):
self.original = RegistrationCenterFactory()
self.copy = RegistrationCenterFactory(copy_of=self.original)
self.polling_locations = get_all_polling_locations()
self.election = ElectionFactory(
polling_start_time=now() - datetime.timedelta(hours=1),
polling_end_time=now() + datetime.timedelta(hours=1),
)
# add decoy elections before/after the real one
self.decoy_before_election = ElectionFactory(
polling_start_time=self.election.polling_start_time -
datetime.timedelta(days=5),
polling_end_time=self.election.polling_end_time -
datetime.timedelta(days=5),
)
self.decoy_after_election = ElectionFactory(
polling_start_time=self.election.polling_start_time +
datetime.timedelta(days=5),
polling_end_time=self.election.polling_end_time +
datetime.timedelta(days=5),
)
self.test_office_1 = 1
self.test_office_2 = 2
self.test_region = 3
self.polling_centers = {
'11001': {
'polling_center_code': 11001,
'office_id': self.test_office_1,
'subconstituency_id': 2,
'region': Office.REGION_NAMES[self.test_region],
'country': 'Libya'
},
'11002': {
'polling_center_code': 11002,
'office_id': self.test_office_2,
'subconstituency_id': 2,
'region': Office.REGION_NAMES[self.test_region],
'country': 'Libya'
},
'11003': {
'polling_center_code': 11003,
'office_id': self.test_office_1,
'subconstituency_id': 2,
'region': Office.REGION_NAMES[self.test_region],
'country': 'Libya'
}
}
self.center_opens = []
self.center_reports = []
self.inactive_for_election = ['11003']
def setUp(self):
self.center1 = RegistrationCenterFactory()
self.center2 = RegistrationCenterFactory()
self.center3 = RegistrationCenterFactory()
self.data = {
'name': 'My Changeset',
'change': str(Changeset.CHANGE_CENTER),
'how_to_select': str(Changeset.SELECT_CENTERS),
# django-selectable appends "_1" to the field name for the form name that
# has the actual data submitted:
'selected_centers_1': [str(self.center1.pk), str(self.center2.pk)],
'target_center_1': str(self.center3.pk),
'justification': 'Just because',
}
def test_delete_all_copy_centers(self):
"""test RegistrationCenterManager.delete_all_copy_centers()"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory(copy_of=original_center)
RegistrationCenter.objects.delete_all_copy_centers()
# Ensure the copy center is gone...
with self.assertRaises(RegistrationCenter.DoesNotExist):
RegistrationCenter.objects.get(pk=copy_center.id)
# ...but it still exists if you know where to look.
self.assertEqual(
copy_center,
RegistrationCenter.objects.unfiltered().get(pk=copy_center.id))
def test_user_can_change_from_inactivated_center(self):
# User should be able to change registration center, even if previous center was
# inactivated.
# Create a registration and inactivate the center
citizen = CitizenFactory()
inactivated_center = RegistrationCenterFactory()
self.receive("%s %s" % (citizen.national_id, inactivated_center.center_id), self.conn, fields=self.fields)
inactivated_center.reg_open = False
inactivated_center.save()
# User registers at a new center
new_center = RegistrationCenterFactory()
self.receive("%s %s" % (citizen.national_id, new_center.center_id), self.conn, fields=self.fields)
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
new_reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(new_reg.registration_center, new_center)
def setUp(self):
super(BadMessageTestPhoneActivatedNeitherOneNorTwoNumbers,
self).setUp()
self.center = RegistrationCenterFactory()
# Activate the phone to the center:
StaffPhone.objects.create(phone_number=self.NUMBER,
registration_center=self.center)
def test_new_view_no_centers(self):
"""Pass criteria that generate no centers to the new job form and test output"""
# This is the only validation that happens at the view level. All other validation happens
# in the form.
no_reg_center = RegistrationCenterFactory.build()
no_reg_center.reg_open = False
no_reg_center.save()
with override_settings(ROLLGEN_OUTPUT_DIR=self.faux_output_dir):
response = self.client.post(reverse('rollgen:new'),
{'name': 'kjghdhjdhjghfkjhgdf',
'center_selection_type': 'by_center_text_list',
'center_text_list': [str(no_reg_center.center_id)],
'phase': 'polling',
'forgive_no_voters': False,
'forgive_no_office': False,
}
)
self.assertResponseOK(response)
self.assertTemplateUsed(response, 'rollgen/new.html')
context = response.context
expected_keys = ('form', )
self.assertTrue(set(expected_keys) < set(context.keys()))
self.assertIsInstance(context['form'], NewJobForm)
self.assertFormError(response, 'form', None,
"The criteria you specified didn't match any active centres.")
def test_center_may_be_soft_deleted(self):
"""Unicode method of StaffPhone associated with deleted center should not fail."""
rc = RegistrationCenterFactory(deleted=True)
phone = StaffPhoneFactory(registration_center=rc)
# re-fetch the StaffPhone
fetched_phone = StaffPhone.objects.get(id=phone.id)
self.assertTrue(unicode(fetched_phone))
def test_can_repeat_reg(self):
# User can send multiple messages from the same phone number for the
# same voting center.
citizen = CitizenFactory()
center1 = RegistrationCenterFactory()
# Message #1 - original registration
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(center1, reg.registration_center)
self.assertEqual(constants.RESPONSE_VALID_REGISTRATION,
self.get_last_response_code())
# Repeat - message 2
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(center1, reg.registration_center)
# Repeated reg
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
def test_view_view(self):
self.center2 = RegistrationCenterFactory(name='Centra Dua')
changeset = ChangesetFactory(
name='My Changeset',
change=Changeset.CHANGE_CENTER,
how_to_select=Changeset.SELECT_UPLOADED_NIDS,
target_center=self.center2,
justification='Just because',
)
per_page = UploadedCitizenBrowse.paginate_by
self.assertIsNotNone(per_page)
citizens = [CitizenFactory() for i in range(per_page + 2)]
changeset.selected_citizens.add(*citizens)
citizens = sorted(citizens, key=attrgetter('national_id'))
# Get citizens affected by this changeset, sorted ascending by national ID
url = reverse(
'browse_uploadedcitizens') + "?changeset=%s&o=0" % changeset.pk
rsp = self.client.get(url)
self.assertEqual(OK, rsp.status_code)
context = rsp.context
object_list = context['object_list']
self.assertLessEqual(len(object_list), per_page)
# Should be on first page
self.assertContains(rsp, citizens[0].national_id)
self.assertContains(rsp, str(citizens[0]))
# Last citizen ought to be on the next page
self.assertNotContains(rsp, citizens[-1].national_id)
self.assertNotContains(rsp, str(citizens[-1]))
def setUp(self):
super(ViewsFailedJobTestCase, self).setUp()
self.user = UserFactory(password='******')
self.user.is_superuser = True
self.user.save()
self.assertTrue(
self.client.login(username=self.user.username,
password='******'))
# Generate a center with no voters to force an error when the job runs.
self.no_voters_center = RegistrationCenterFactory(
name=generate_arabic_place_name())
phase = 'in-person'
self.input_arguments['phase'] = phase
self.input_arguments['center_ids'] = [self.no_voters_center.center_id]
with override_settings(ROLLGEN_OUTPUT_DIR=self.faux_output_dir):
self.job = Job(phase, [self.no_voters_center],
self.input_arguments, self.user.username,
self.output_path)
try:
self.job.generate_rolls()
except NoVotersError as exception:
# This is expected. (In fact, it's the whole point of the test.)
handle_job_exception(exception, self.job.output_path)
self.dirname = os.path.basename(self.job.output_path)
def test(self):
center = RegistrationCenterFactory()
elections = [
{
'polling_start_time': now() - datetime.timedelta(days=60)
},
{
'polling_start_time': now() - datetime.timedelta(days=40)
},
{
'polling_start_time': now() - datetime.timedelta(days=20)
},
]
for election in elections:
election['polling_end_time'] = \
election['polling_start_time'] + datetime.timedelta(hours=6)
election['object'] = ElectionFactory(
polling_start_time=election['polling_start_time'],
polling_end_time=election['polling_end_time'],
)
election['staff_phone_1'] = StaffPhoneFactory(
registration_center=center,
creation_date=election['object'].work_start_time)
election['staff_phone_2'] = StaffPhoneFactory(
registration_center=center,
creation_date=election['object'].work_end_time)
for i, election in enumerate(elections, start=1):
messages_for_center = message_log(
election['object'])[center.center_id]
self.assertEqual(len(messages_for_center), i * 2)
# check for other junk leaking into the testcase
for message in messages_for_center:
self.assertEqual(message['type'], 'phonelink')
def test_new_view_no_centers(self):
"""Pass criteria that generate no centers to the new job form and test output"""
# This is the only validation that happens at the view level. All other validation happens
# in the form.
no_reg_center = RegistrationCenterFactory.build()
no_reg_center.reg_open = False
no_reg_center.save()
with override_settings(ROLLGEN_OUTPUT_DIR=self.faux_output_dir):
response = self.client.post(
reverse('rollgen:new'), {
'name': 'kjghdhjdhjghfkjhgdf',
'center_selection_type': 'by_center_text_list',
'center_text_list': [str(no_reg_center.center_id)],
'phase': 'polling',
'forgive_no_voters': False,
'forgive_no_office': False,
})
self.assertResponseOK(response)
self.assertTemplateUsed(response, 'rollgen/new.html')
context = response.context
expected_keys = ('form', )
self.assertTrue(set(expected_keys) < set(context.keys()))
self.assertIsInstance(context['form'], NewJobForm)
self.assertFormError(
response, 'form', None,
"The criteria you specified didn't match any active centres.")
def test_create_view(self):
url = reverse('add_changeset')
rsp = self.client.get(url)
self.assertEqual(OK, rsp.status_code)
self.center1 = RegistrationCenterFactory()
self.center2 = RegistrationCenterFactory()
data = {
'name': 'My Changeset',
'change': str(Changeset.CHANGE_CENTER),
'how_to_select': str(Changeset.SELECT_CENTERS),
'selected_centers_1': [str(self.center1.pk)],
'target_center_1': str(self.center2.pk),
'justification': 'Just because',
}
rsp = self.client.post(url, data=data, follow=True)
self.assertRedirects(rsp, reverse('browse_changesets'))
def setUp(self):
self.election = ElectionFactory()
self.center = RegistrationCenterFactory(name=generate_arabic_place_name())
self.office_id = self.center.office.id
# Create a bunch of voters registered at each of these centers. The number of voters
# matters somewhat.
# station_distributor() will create a unisex station under certain conditions if
# there are < N male or female voters, where N = UNISEX_TRIGGER (currently 25). The
# names of the generated PDFs (which this code tests) have the gender embedded, so if I
# change the # of voters and that causes a unisex station to be created, the filenames of
# the generated PDFs will be different than these tests expect so the tests will fail.
# I use a number of voters that guarantees I won't create a unisex station.
n_voters = (settings.ROLLGEN_UNISEX_TRIGGER * 2) + 2
self.voters = create_voters(n_voters, center=self.center)
self.password = '******'
self.user = UserFactory(password=self.password)
# Each test gets a fresh work dir.
self.output_path = tempfile.mkdtemp()
self.input_arguments = INPUT_ARGUMENTS_TEMPLATE.copy()
self.input_arguments['center_ids'] = [self.center.center_id]
def test_can_change_reg(self):
# User can send multiple messages from the same phone number and change
# their voting center.
citizen = CitizenFactory()
center1 = RegistrationCenterFactory()
center2 = RegistrationCenterFactory()
center3 = RegistrationCenterFactory()
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(center1, reg.registration_center)
# Initial registration
self.assertEqual(constants.RESPONSE_VALID_REGISTRATION,
self.get_last_response_code())
# They change their mind and register for a different center
self.receive("%s %s" % (citizen.national_id, center2.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg2 = models.Registration.objects.get(citizen=citizen)
self.assertEqual(reg.pk, reg2.pk)
# But at a new center
self.assertEqual(center2, reg2.registration_center)
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
# There's an archive
archive = models.Registration.objects.archived().get(citizen=citizen)
self.assertEqual(archive.archive_time, reg2.creation_date)
# The archive has the previous data
self.assertEqual(center1, archive.registration_center)
# They change their mind and register for a different center
self.receive("%s %s" % (citizen.national_id, center3.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg3 = models.Registration.objects.get(citizen=citizen)
# But at a new center
self.assertEqual(center3, reg3.registration_center)
self.assertEqual(constants.MESSAGE_4, self.get_last_response_code())
# most recent archive has the previous data
archive = models.Registration.objects.archived().filter(citizen=citizen)\
.order_by('-archive_time').first()
self.assertEqual(center2, archive.registration_center)
def test_copied_by_multiple(self):
"""Exercise build_copy_info() for a center that has multiple copies"""
original = RegistrationCenterFactory()
copy_centers = RegistrationCenterFactory.create_batch(3, copy_of=original)
copy_center_ids = sorted([center.center_id for center in copy_centers])
copy_center_ids = (ARABIC_COMMA + ' ').join(map(str, copy_center_ids))
expected = '{}: {}'.format(STRINGS['copied_by_plural'], copy_center_ids)
self.assertEqual(build_copy_info(original), expected)
def test_all_related_by_copy(self):
"""exercise all_related_by_copy()"""
original_center = RegistrationCenterFactory()
# Create copies with center ids in unsorted order to verify all_related_by_copy() sorts
# as promised.
copies = []
for center_id in (77777, 22222, 66666, 33333, 55555):
copy_center = RegistrationCenterFactory(center_id=center_id, copy_of=original_center)
copies.append(copy_center)
copies.sort(key=lambda center: center.center_id)
# test getting centers related to the original (parent) center
actual_copies = original_center.all_related_by_copy()
# original centers is always first in the returned list
self.assertEqual(original_center, actual_copies[0])
expected = copies
actual = actual_copies[1:]
self.assertEqual(expected, actual)
# test getting centers related to one of the copies
a_copy = copies[1]
actual_copies = a_copy.all_related_by_copy()
# original centers is always first in the returned list
self.assertEqual(original_center, actual_copies[0])
# expected remains the same as above
actual = actual_copies[1:]
self.assertEqual(expected, actual)
# test that all_related_by_copy() doesn't return deleted centers
a_copy = copies[1]
a_copy.deleted = True
a_copy.save()
actual_copies = original_center.all_related_by_copy()
expected = [copies[0]] + copies[2:]
actual = actual_copies[1:]
self.assertEqual(expected, actual)
# test that all_related_by_copy() is the identity function for non-copy centers
copyless_center = RegistrationCenterFactory()
actual_copies = copyless_center.all_related_by_copy()
self.assertEqual(copyless_center, actual_copies[0])
self.assertEqual(len(actual_copies), 1)
def test_split_center_ok(self):
"""test that a split center can be created"""
split_center_subcon, unused = \
SubConstituency.objects.get_or_create(id=SPLIT_CENTER_SUBCONSTITUENCY_ID)
center = RegistrationCenterFactory.build(center_type=RegistrationCenter.Types.SPLIT,
subconstituency=split_center_subcon)
# This should not raise an error
center.clean()
def test_copy_of_copy_fails(self):
"""test that a copy center can't be a copy of another copy center"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory(copy_of=original_center)
copy_copy_center = RegistrationCenterFactory.build(copy_of=copy_center)
with self.assertRaises(ValidationError) as cm:
copy_copy_center.clean()
self.assertEqual(cm.exception.message, 'A copy centre cannot copy another copy centre.')
def test_copy_center_requires_copy_type(self):
"""test that a copy center must have the correct type"""
original_center = RegistrationCenterFactory()
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
copy_center.center_type = RegistrationCenter.Types.GENERAL
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(cm.exception.message, 'Copy centre type must be "copy".')
def test_copy_center_requires_copy_info(self):
"""test that a center with copy type requires copy_of info"""
copy_center = RegistrationCenterFactory.build(center_type=RegistrationCenter.Types.COPY)
copy_center.copy_of = None
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
self.assertEqual(cm.exception.message,
'Centre type "copy" requires copy centre information.')
def test_split_center_ok(self):
"""test that a split center can be created"""
split_center_subcon, unused = \
SubConstituency.objects.get_or_create(id=SPLIT_CENTER_SUBCONSTITUENCY_ID)
center = RegistrationCenterFactory.build(
center_type=RegistrationCenter.Types.SPLIT,
subconstituency=split_center_subcon)
# This should not raise an error
center.clean()
def test_split_center_must_use_split_subcon(self):
"""test that a split center must be associated with the correct subcon"""
some_random_subcon = SubConstituencyFactory()
center = RegistrationCenterFactory.build(center_type=RegistrationCenter.Types.SPLIT,
subconstituency=some_random_subcon)
with self.assertRaises(ValidationError) as cm:
center.clean()
msg = "Split centers must be associated with subconstituency {}."
msg = msg.format(SPLIT_CENTER_SUBCONSTITUENCY_ID)
self.assertEqual(cm.exception.message, msg)
def test_view_view(self):
self.center1 = RegistrationCenterFactory(name='Centero Uno')
self.center2 = RegistrationCenterFactory(name='Centra Dua')
changeset = ChangesetFactory(
name='My Changeset',
change=Changeset.CHANGE_CENTER,
how_to_select=Changeset.SELECT_CENTERS,
target_center=self.center2,
justification='Just because',
)
changeset.selected_centers.add(self.center1)
changeset.selected_centers.add(self.center2)
url = reverse('read_changeset', kwargs={'pk': changeset.pk})
rsp = self.client.get(url)
self.assertEqual(OK, rsp.status_code)
self.assertContains(rsp, self.center1.pk)
self.assertContains(rsp, self.center2.pk)
self.assertContains(rsp, 'Just because')
self.assertContains(rsp, 'My Changeset')
def test_nonsplit_center_cannot_use_split_subcon(self):
"""test that a non-split center cannot be associated with the split-specific subcon"""
split_center_subcon, unused = \
SubConstituency.objects.get_or_create(id=SPLIT_CENTER_SUBCONSTITUENCY_ID)
center = RegistrationCenterFactory.build(center_type=RegistrationCenter.Types.GENERAL,
subconstituency=split_center_subcon)
with self.assertRaises(ValidationError) as cm:
center.clean()
msg = "Only split centers may be associated with subconstituency {}."
msg = msg.format(SPLIT_CENTER_SUBCONSTITUENCY_ID)
self.assertEqual(cm.exception.message, msg)
def test_max_copies_per_center_limit(self):
"""test that register.models.N_MAX_COPY_CENTERS is respected"""
original_center = RegistrationCenterFactory()
create_batch(RegistrationCenterFactory, settings.N_MAX_COPY_CENTERS,
copy_of=original_center)
copy_center = RegistrationCenterFactory.build(copy_of=original_center)
with self.assertRaises(ValidationError) as cm:
copy_center.clean()
msg = 'Copy centre already has the maximum number of copies ({n_max}).'
self.assertEqual(cm.exception.message, msg.format(n_max=settings.N_MAX_COPY_CENTERS))