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_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_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 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_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 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): 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 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_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 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_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_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_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_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 setUp(self): super(PrelimVoteReportTestPhoneActivated, self).setUp() self.center = RegistrationCenterFactory() # Activate the phone to the center: StaffPhone.objects.create(phone_number=self.NUMBER, registration_center=self.center) self.election = ElectionFactory( polling_start_time=now() - timedelta(hours=2), polling_end_time=now() + timedelta(hours=2), )
def setUp(self): self.username = os.environ.get('USER', 'unknown') self.command_name = 'generate_rolls' self.center = RegistrationCenterFactory() self.phase = 'polling' # Each test gets a fresh work dir. self.output_path = tempfile.mkdtemp()
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_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_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_wrong_center_center_opening(self): # Center opening message, not the center the phone is activated to center2 = RegistrationCenterFactory() self.check_it_out( "%d*%d" % (CENTER_OPEN_INDICATOR, center2.center_id), expected_response_code=CENTER_OPENING_NOT_AUTHORIZED, expected_msg_type=SMS.NOT_ACTIVATED, expect_phone_activated=DONT_CARE, # it already was expect_report_saved=False, expect_center_opened=False)
def setUp(self): self.username = os.environ.get('USER', 'unknown') self.command_name = 'generate_rolls' self.no_office, _ = Office.objects.get_or_create(id=NO_NAMEDTHING) self.no_office_center = RegistrationCenterFactory(office=self.no_office) self.center = RegistrationCenterFactory() self.copy_center = RegistrationCenterFactory(copy_of=self.center) self.phase = 'in-person' self.input_arguments = {'phase': self.phase, 'forgive_no_voters': False, 'forgive_no_office': False, 'office_ids': [], 'center_ids': [], } # Each test gets a fresh work dir. self.output_path = tempfile.mkdtemp()
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(PollingReportTestPhoneActivated, self).setUp() self.center = RegistrationCenterFactory() # Activate the phone to the center: StaffPhone.objects.create(phone_number=self.NUMBER, registration_center=self.center) # Create some registrations so that reports don't arrive for a center with no registrations. create_batch(RegistrationFactory, 11, registration_center=self.center, archive_time=None)
def test_numbers_unique(self): number1 = get_random_phone_number() number2 = str(1 + long(number1)) reg = RegistrationCenterFactory() StaffPhone.objects.create(phone_number=number1, registration_center=reg) StaffPhone.objects.create(phone_number=number2, registration_center=reg) obj = StaffPhone(phone_number=number2, registration_center=reg) with self.assertRaises(ValidationError): obj.clean()
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 setUp(self): self.number = get_random_phone_number() self.center = RegistrationCenterFactory() self.citizen = CitizenFactory() self.staffphone = StaffPhone.objects.create( phone_number=self.number, registration_center=self.center) self.conn = self.create_connection(data={'identity': self.number}) self.good_nid = self.citizen.national_id self.bad_nid = get_random_number_string(length=constants.NID_LENGTH) self.short_nid = get_random_number_string(length=constants.NID_LENGTH - 1) self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
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))