def setUp(self):
self.password = "******"
self.peon = UserFactory(password=self.password)
self.deleter = UserFactory(password=self.password)
self.deleter.groups.add(self.change_group)
self.changeset = ChangesetFactory()
self.url = reverse('delete_changeset',
kwargs={'pk': self.changeset.pk})
def setUp(self):
self.password = "******"
self.peon = UserFactory(password=self.password)
self.changer = UserFactory(password=self.password)
self.changer.groups.add(self.change_group)
self.approver = UserFactory(password=self.password)
self.approver.groups.add(self.approve_group)
self.queuer = UserFactory(password=self.password)
self.queuer.groups.add(self.queue_group)
self.deleter = UserFactory(password=self.password)
self.deleter.groups.add(self.change_group)
def setUp(self):
self.password = "******"
self.peon = UserFactory(password=self.password)
self.changer = UserFactory(password=self.password)
self.changer.groups.add(self.change_group)
self.approver = UserFactory(password=self.password)
self.approver.groups.add(self.approve_group)
self.queuer = UserFactory(password=self.password)
self.queuer.groups.add(self.queue_group)
self.changeset = ChangesetFactory()
self.url = reverse('approve_changeset',
kwargs={'pk': self.changeset.pk})
self.read_url = reverse('read_changeset', args=[self.changeset.pk])
def setUp(self):
super(ViewsEmptyTestCase, self).setUp()
user = UserFactory(password='******')
user.is_superuser = True
user.save()
self.assertTrue(
self.client.login(username=user.username, password='******'))
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_approval_warning_checkbox(self):
# If the changeset has approvals, we include the approval warning checkbox
# If not, we don't.
# New changeset
form = ChangesetForm(data=self.data, request=MagicMock())
self.assertNotIn('okay_to_remove_approvals', form.fields)
# Existing changeset without approvals
changeset = ChangesetFactory()
form = ChangesetForm(instance=changeset, data=self.data, request=MagicMock())
self.assertNotIn('okay_to_remove_approvals', form.fields)
# Approvals
self.approver = UserFactory()
self.approver.user_permissions.add(
get_permission_object_by_name(APPROVE_CHANGESET_PERMISSION))
changeset.approve(self.approver)
form = ChangesetForm(instance=changeset, data=self.data, request=MagicMock())
self.assertIn('okay_to_remove_approvals', form.fields)
# And we must check it
self.assertFalse(form.is_valid())
self.assertIn('okay_to_remove_approvals', form.errors)
# If we save, it removes the approvals
self.data['okay_to_remove_approvals'] = True
mock_request = MagicMock()
mock_request.__class__ = HttpRequest
form = ChangesetForm(instance=changeset, data=self.data, request=mock_request)
self.assertTrue(form.is_valid(), form.errors)
changeset = form.save()
self.assertEqual(0, changeset.number_of_approvals)
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 create_staff_user(self):
user = UserFactory(username=self.username,
email=self.email,
password=self.password)
user.is_staff = True
user.save()
return user
def setUp(self):
self.home_url = reverse('upload_broadcast')
self.staff_user = UserFactory(username='******', password='******')
self.staff_user.is_staff = True
self.staff_user.save()
self.staff_user.user_permissions.add(Permission.objects.get(codename='add_broadcast'))
self.staff_user.user_permissions.add(Permission.objects.get(codename='approve_broadcast'))
self.client.login(username='******', password='******')
def test_revoke_approval_updates_status(self):
changeset = ChangesetFactory()
user = give_approve_permission(self.user)
user2 = give_approve_permission(UserFactory())
changeset.approve(user)
changeset.approve(user2)
changeset = refresh_model(changeset)
self.assertEqual(Changeset.STATUS_APPROVED, changeset.status)
changeset.revoke_approval(user)
self.assertEqual(Changeset.STATUS_NEW, changeset.status)
def setUp(self):
self.url = reverse('check_registration')
self.user = UserFactory(username='******', password='******')
self.client.login(username='******', password='******')
# captcha has 2 form fields, _0 is a key, _1 is the text entered by the user
self.captcha = {'captcha_0': 'dummy', 'captcha_1': 'PASSED'}
self.registration = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=PAST_DAY)
self.election = ElectionFactory(polling_start_time=FUTURE_DAY,
polling_end_time=FUTURE_DAY)
def setUp(self):
self.password = '******'
self.user = UserFactory(username='******', password=self.password)
self.user.is_staff = True
self.user.save()
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
self.staff_url = reverse('staff')
self.httptester_url = reverse('httptester-index')
def test_create_changeset(self):
# We can create a changeset
mock_request = MagicMock(user=UserFactory())
form = ChangesetForm(data=self.data, request=mock_request)
self.assertTrue(form.is_valid(), msg=str(form.errors))
changeset = form.save()
changeset = refresh_model(changeset)
self.assertEqual(Changeset.CHANGE_CENTER, changeset.change)
self.assertEqual(Changeset.SELECT_CENTERS, changeset.how_to_select)
self.assertIn(self.center1, changeset.selected_centers.all())
self.assertIn(self.center2, changeset.selected_centers.all())
def test_number_of_approvals(self):
changeset = ChangesetFactory()
self.assertEqual(0, changeset.number_of_approvals)
self.user = give_approve_permission(self.user)
changeset.approve(self.user)
self.assertEqual(1, changeset.number_of_approvals)
user2 = give_approve_permission(UserFactory())
changeset.approve(user2)
self.assertEqual(2, changeset.number_of_approvals)
changeset.revoke_approval(user2)
self.assertEqual(1, changeset.number_of_approvals)
def test_set_password_mismatch(self):
user = UserFactory(username='******', first_name='Jeff', last_name='Doe',
password='******')
url = reverse('staff_set_password', kwargs={'pk': user.pk})
data = {
'new_password1': 'foo',
'new_password2': 'bar',
}
rsp = self.client.post(url, data=data, follow=False)
self.assertEqual(200, rsp.status_code)
user = User.objects.get(pk=user.pk)
self.assertTrue(user.check_password('puppy'))
def create_staff_user(self):
user = UserFactory(username=self.username,
email=self.email,
password=self.password)
user.is_staff = True
user.save()
if self.model:
content_type = ContentType.objects.get_for_model(self.model)
for perm in self.permissions:
user.user_permissions.add(
Permission.objects.get(content_type=content_type,
codename=perm))
return user
def test_cannot_revoke_approval_after_queueing(self):
superuser = UserFactory(is_superuser=True, password=self.password)
self.changeset.approve(self.approver)
self.changeset.approve(superuser)
self.changeset.status = Changeset.STATUS_QUEUED
self.changeset.save()
self.login(superuser)
rsp = self.client.post(self.url, data={'revoke': True})
self.assertContains(rsp,
"after the changeset has been started.",
status_code=BAD_REQUEST)
def test_access(self):
UserFactory(username='******', password='******')
for m in models:
instance = m()
urls = instance.get_urls()
for url in urls:
try:
path = reverse(url.name)
except NoReverseMatch:
path = reverse(url.name, args=[1])
self.client.login(username='******', password='******')
self.assertForbidden(self.client.get(path))
self.client.logout()
self.assertRedirectsToLogin(self.client.get(path))
def setUp(self):
self.number = 397
self.msg = MessageText.objects.create(
number=self.number,
msg_en="Message",
msg_ar="Message (ar)",
enhanced_en="Enh msg",
enhanced_ar="Enh msg (ar)",
)
self.staff_user = UserFactory(username='******', password='******')
self.perm = Permission.objects.get(codename='change_messagetext')
self.staff_user.user_permissions.add(self.perm)
assert self.client.login(username='******', password='******')
self.list_url = reverse('message_list')
self.change_url = reverse('message_update', args=[self.msg.pk])
def test_upload_file(self):
# We can successfully upload a file of NIDs and look up the citizens
# and blank lines are okay
data = self.data
data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
filetext = "{nid1}\n\n{nid2}\n".format(nid1=citizen1.national_id, nid2=citizen2.national_id)
upload_file = SimpleUploadedFile('my_filename', filetext)
mock_request = MagicMock(user=UserFactory())
form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=mock_request)
self.assertTrue(form.is_valid(), msg=str(form.errors))
changeset = form.save()
self.assertIn(citizen1, changeset.selected_citizens.all())
self.assertIn(citizen2, changeset.selected_citizens.all())
def setUp(self):
super(ViewsInProgressJobTestCase, self).setUp()
self.user = UserFactory(password='******')
self.user.is_superuser = True
self.user.save()
self.assertTrue(
self.client.login(username=self.user.username,
password='******'))
# I would like to create an in-progress job "organically", but that's hard to do under
# test conditions. Instead I simulate the conditions of in-progress job.
with open(os.path.join(self.output_path, ROLLGEN_FLAG_FILENAME),
'w') as f:
f.write(' ')
self.dirname = os.path.basename(self.output_path)
def test_staff_update(self):
group = Group.objects.get(name=HELP_DESK_SUPERVISORS_GROUP)
user = UserFactory(username='******', first_name='Jeff', last_name='Doe',
password='******')
url = reverse('staff_update', kwargs={'pk': user.pk})
data = {
'username': '******',
'first_name': 'Fred',
'last_name': 'Boggs',
'email': '*****@*****.**',
'help_desk_group': group.name,
}
self.client.post(url, data=data)
user = User.objects.get(username='******')
self.assertEqual(user.last_name, 'Boggs')
self.assertTrue(user.check_password('puppy'))
self.assertIn(group, user.groups.all())
self.assertEqual(1, user.groups.count())
def setUp(self):
super(ViewsNonEmptyTestCase, self).setUp()
user = UserFactory(password='******')
user.is_superuser = True
user.save()
self.assertTrue(
self.client.login(username=user.username, password='******'))
phase = 'in-person'
self.input_arguments['phase'] = phase
with override_settings(ROLLGEN_OUTPUT_DIR=self.faux_output_dir):
self.job = Job(phase, [self.center], self.input_arguments,
self.user.username, self.output_path)
self.job.generate_rolls()
self.dirname = os.path.basename(self.job.output_path)
def setUp(self):
self.staff_user = UserFactory()
self.staff_user.is_staff = True
self.staff_user.save()
assert self.client.login(username=self.staff_user.username,
password=DEFAULT_USER_PASSWORD)
self.bad_center_id = 'abcd'
self.bad_phone_number = 'abcd'
self.good_center_id = RegistrationCenterFactory().center_id
self.good_looking_center_id = self.good_center_id + 1 # until the next center is created
self.assertFalse(
RegistrationCenter.objects.filter(
center_id=self.good_looking_center_id).exists())
# these will both get whitelisted by this test class
self.good_phone_number_1 = 218000000106
self.good_phone_number_2 = 218000000107
def setUp(self):
self.user = UserFactory()
def setUp(self):
self.staff_user = UserFactory()
self.staff_user.is_staff = True
self.staff_user.save()
assert self.client.login(username=self.staff_user.username,
password=DEFAULT_USER_PASSWORD)
self.reporting_user = test_reports.TEST_USERNAME
self.reporting_password = test_reports.TEST_PASSWORD
REPORT_USER_DB[self.reporting_user] = self.reporting_password
# Pick a start time that represents different days in Libya vs UTC
tz = timezone(settings.TIME_ZONE)
polling_start_time = astz(FUTURE_DAY.replace(hour=22), tz)
polling_end_time = tz.normalize(polling_start_time +
timedelta(hours=16))
self.election = ElectionFactory(
polling_start_time=polling_start_time,
polling_end_time=polling_end_time,
)
self.election_day_dt = self.election.polling_start_time
# Create "decoy" election just to confirm that it doesn't break reports.
decoy_start_time = tz.normalize(polling_start_time -
timedelta(days=10))
decoy_end_time = tz.normalize(decoy_start_time + timedelta(hours=16))
ElectionFactory(
polling_start_time=decoy_start_time,
polling_end_time=decoy_end_time,
)
self.all_centers = []
self.rc_1 = RegistrationCenterFactory()
self.all_centers.append(self.rc_1)
self.rc_2 = RegistrationCenterFactory()
self.all_centers.append(self.rc_2)
self.rc_3 = RegistrationCenterFactory()
self.all_centers.append(self.rc_3)
self.rc_4 = RegistrationCenterFactory()
self.all_centers.append(self.rc_4)
self.copy_of_rc_1 = RegistrationCenterFactory(copy_of=self.rc_1,
office=self.rc_1.office)
self.all_centers.append(self.copy_of_rc_1)
# rc_5 is inactive for this election
self.rc_5 = RegistrationCenterFactory(office=self.rc_1.office)
self.all_centers.append(self.rc_5)
inactive_on_election = CenterClosedForElection(
registration_center=self.rc_5, election=self.election)
inactive_on_election.full_clean()
inactive_on_election.save()
self.all_office_ids = [center.office_id for center in self.all_centers]
self.carrier_1 = BackendFactory()
self.citizen_1 = CitizenFactory()
# Create registrations on the 4 days leading up to election day
# Put the registrations at different hours of the day to stress TZ handling.
self.registration_dates = []
self.registration_date_strs = []
hour_of_day = 0
for delta_days in range(10, 4, -1):
assert hour_of_day < 24
reg_date = astz(self.election_day_dt - timedelta(days=delta_days), tz)\
.replace(hour=hour_of_day)
hour_of_day += 4
self.registration_dates.append(reg_date)
self.registration_date_strs.append(reg_date.strftime('%Y-%m-%d'))
self.yesterday_date, _ = calc_yesterday(self.registration_date_strs)
self.yesterday_date_dm = self.yesterday_date.strftime('%d/%m')
# yesterday_date is a date; get a datetime form
self.yesterday_date_dt = tz.localize(
datetime(self.yesterday_date.year, self.yesterday_date.month,
self.yesterday_date.day, 0, 0, 0))
self.staff_phone_number = STAFF_PHONE_NUMBER_PATTERN % 12345
def setUp(self):
self.password = "******"
user = UserFactory(password=self.password)
user.groups.add(self.change_group)
assert self.client.login(username=user.username,
password=self.password)
def setUp(self):
super(GroupMembershipNegativeTestCase, self).setUp()
password = '******'
self.user = UserFactory(password=password)
self.assertTrue(
self.client.login(username=self.user.username, password=password))
def test_nonstaff_cant_see_form(self):
self.client.logout()
self.nonstaff_user = UserFactory(username='******', password='******')
self.client.login(username='******', password='******')
self.assertForbidden(self.client.get(self.url))
def test_get_home_view_not_staff(self):
# get view not_staff -> 403
self.client.logout()
self.user = UserFactory(username='******', password='******')
self.client.login(username='******', password='******')
self.assertForbidden(self.client.get(self.home_url))
