def test_center_detail_invalid_center(self):
code = '12345'
other_code = '21345'
station_number = 1
center = create_center(code)
other_center = create_center(other_code)
create_station(center)
create_station(other_center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
station_number=station_number)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
view = views.CenterDetailsView.as_view()
session = {'result_form': result_form.pk}
data = center_data(other_code, station_number=station_number)
data.update(session)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = session
response = view(request)
self.assertEqual(response.status_code, 200)
response.render()
self.assertContains(response,
'Center and station numbers do not match')
def test_center_detail_invalid_center(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
other_code = '21345'
station_number = 1
center = create_center(code, tally=tally)
other_center = create_center(other_code, tally=tally)
create_station(center)
create_station(other_center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
tally=tally,
station_number=station_number)
view = views.CenterDetailsView.as_view()
session = {'result_form': result_form.pk}
data = center_data(other_code,
station_number=station_number,
tally_id=tally.pk)
data.update(session)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = session
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
response.render()
self.assertContains(response,
'Center and station numbers do not match')
def setUp(self):
create_result_form(center=create_center(),
station_number=1,
barcode=1,
serial_number=1,
form_state=FormState.UNSUBMITTED)
create_result_form(center=create_center(),
station_number=2,
barcode=2,
serial_number=2,
form_state=FormState.INTAKE)
create_result_form(center=create_center(),
station_number=3,
barcode=3,
serial_number=3,
form_state=FormState.CLEARANCE)
create_result_form(center=create_center(),
station_number=4,
barcode=4,
serial_number=4,
form_state=FormState.DATA_ENTRY_1)
create_result_form(center=create_center(),
station_number=5,
barcode=5,
serial_number=5,
form_state=FormState.DATA_ENTRY_2)
create_result_form(center=create_center(),
station_number=6,
barcode=6,
serial_number=6,
form_state=FormState.CORRECTION)
create_result_form(center=create_center(),
station_number=7,
barcode=7,
serial_number=7,
form_state=FormState.QUALITY_CONTROL)
create_result_form(center=create_center(),
station_number=8,
barcode=8,
serial_number=8,
form_state=FormState.AUDIT)
self.center = create_center(code=2, office_name='office2')
create_result_form(center=self.center,
station_number=9,
barcode=9,
serial_number=9,
form_state=FormState.UNSUBMITTED)
create_result_form(center=self.center,
station_number=10,
barcode=10,
serial_number=10,
form_state=FormState.ARCHIVED)
self.assertEqual(ResultForm.objects.count(), 10)
def setUp(self):
self.factory = RequestFactory()
self._create_permission_groups()
self._create_and_login_user()
self._add_user_to_group(self.user, groups.TALLY_MANAGER)
self.tally = create_tally()
self.tally.users.add(self.user)
ballot = create_ballot(tally=self.tally)
center = create_center('12345', tally=self.tally)
station = create_station(center)
result_form = create_result_form(tally=self.tally,
ballot=ballot,
center=center,
station_number=station.station_number)
votes = 12
create_candidates(result_form,
votes=votes,
user=self.user,
num_results=1)
for result in result_form.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form, result.candidate, self.user, votes)
def test_process_results_form_row_ballot_number_error(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=2, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
row = [
str(ballot.number),
center.code,
str(station.station_number),
self.gender,
self.name,
self.office_name,
self.empty_string,
self.barcode,
self.serial_number]
with self.assertLogs(logger=self.logger, level='WARNING') as cm:
process_results_form_row(tally=self.tally,
row=row,
logger=self.logger)
self.assertIn(
str('WARNING:%s:Ballot number "%s" do not match for '
'center "%s" and station "%s"') %
(self.logger.name,
ballot.number,
center.code,
station.station_number), cm.output)
def test_archive_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(form_state=FormState.ARCHIVING,
center=center,
station_number=1)
recon_form = create_reconciliation_form(result_form,
self.user,
number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user, groups.ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(result_form.audit.quarantine_checks.all()[0].name[:9],
'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('archive/print', response['location'])
def test_print_quarantine_get(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.QUALITY_CONTROL,
center=center,
tally=tally,
station_number=station_number)
quarantine_check = QuarantineCheck.objects.create(user=self.user,
name='1',
method='1',
value=1)
audit = create_audit(result_form, self.user)
audit.quarantine_checks.add(quarantine_check)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.PrintView.as_view()
request = self.factory.get('/')
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Quarantined')
def test_quality_control_post_quarantine(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center()
create_station(center)
create_quarantine_checks()
result_form = create_result_form(
form_state=FormState.QUALITY_CONTROL,
tally=tally,
center=center,
station_number=1)
create_reconciliation_form(
result_form, self.user, number_unstamped_ballots=1000)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'correct': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 2)
self.assertEqual(result_form.audit.user, self.user)
self.assertEqual(result_form.audited_count, 1)
self.assertIn('quality-control/print', response['location'])
def test_dashboard_get_double_recon_raise(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user,
ballot_number_from=2)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
with self.assertRaises(SuspiciousOperation):
view(request, tally_id=tally.pk)
def test_women_get(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center()
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
name = 'general candidate name'
women_name = 'women candidate name'
votes = 123
create_candidates(result_form, self.user, name, votes, women_name)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
response.render()
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Women')
self.assertContains(response, women_name)
self.assertContains(response, name)
self.assertContains(response, str(votes))
def test_dashboard_get_double_recon(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'General Results Section')
self.assertContains(response, 'Cancel')
def test_enter_results_success_data_entry_two(self):
code = '12345'
center = create_center(code)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_2,
center=center)
ballot = result_form.ballot
candidate_name = 'candidate name'
create_candidate(ballot, candidate_name)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_2_CLERK)
response = self._post_enter_results(result_form)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry', response['location'])
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state, FormState.CORRECTION)
reconciliation_forms = updated_result_form.reconciliationform_set.all()
self.assertEqual(len(reconciliation_forms), 1)
self.assertEqual(reconciliation_forms[0].entry_version,
EntryVersion.DATA_ENTRY_2)
results = updated_result_form.results.all()
self.assertEqual(len(results), 1)
self.assertEqual(results[0].entry_version, EntryVersion.DATA_ENTRY_2)
self.assertEqual(results[0].user, self.user)
def test_enter_results_success_data_entry_one(self):
code = '12345'
center = create_center(code)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center)
ballot = result_form.ballot
candidate_name = 'candidate name'
create_candidate(ballot, candidate_name)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
response = self._post_enter_results(result_form)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry', response['location'])
result_form.reload()
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_2)
reconciliation_forms = result_form.reconciliationform_set.all()
self.assertEqual(len(reconciliation_forms), 1)
self.assertEqual(reconciliation_forms[0].entry_version,
EntryVersion.DATA_ENTRY_1)
results = result_form.results.all()
self.assertEqual(len(results), 1)
self.assertEqual(results[0].entry_version, EntryVersion.DATA_ENTRY_1)
for result in results:
self.assertEqual(result.user, self.user)
def test_review_post_supervisor_implement(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station_number = 2
result_form = create_result_form(form_state=FormState.CLEARANCE,
center=center,
tally=tally,
station_number=station_number)
self.assertEqual(result_form.center, center)
self.assertEqual(result_form.station_number, station_number)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'forward': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.CLEARANCE_SUPERVISOR)
tally.users.add(self.user)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 3,
'implement': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
clearance = result_form.clearances.all()[0]
result_form.reload()
self.assertEqual(clearance.supervisor, self.user)
self.assertFalse(clearance.active)
self.assertTrue(clearance.reviewed_supervisor)
self.assertTrue(clearance.reviewed_team)
self.assertEqual(clearance.action_prior_to_recommendation,
ActionsPrior.REQUEST_AUDIT_ACTION_FROM_FIELD)
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.form_state, FormState.UNSUBMITTED)
self.assertEqual(result_form.center, center)
self.assertEqual(result_form.station_number, station_number)
def test_duplicate_forms_post(self):
self._create_or_login_intake_clerk()
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center=center, tally=tally)
result_form = create_result_form(tally=tally,
center=center,
station_number=station.station_number,
form_state=FormState.DATA_ENTRY_1)
result_form2 = create_result_form(
'123456289',
tally=tally,
ballot=result_form.ballot,
center=result_form.center,
station_number=result_form.station_number,
serial_number=3)
view = views.CenterDetailsView.as_view()
data = {
'barcode': result_form2.barcode,
'barcode_copy': result_form2.barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(request.session['intake-error'],
INTAKE_DUPLICATE_ERROR_MESSAGE)
def test_dashboard_get(self):
barcode = '123456789'
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, 'General Results Section')
self.assertNotContains(response, 'Reconciliation')
self.assertContains(response, 'Cancel')
def test_print_quarantine_get(self):
self._create_and_login_user()
code = '12345'
station_number = 1
center = create_center(code)
create_station(center)
result_form = create_result_form(form_state=FormState.ARCHIVING,
center=center,
station_number=station_number)
quarantine_check = QuarantineCheck.objects.create(
user=self.user,
name='1',
method='1',
value=1)
audit = create_audit(result_form, self.user)
audit.quarantine_checks.add(quarantine_check)
self._add_user_to_group(self.user, groups.ARCHIVE_CLERK)
view = views.ArchivePrintView.as_view()
request = self.factory.get('/')
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Quarantined')
def test_archive_post_quarantine_pass_with_zero_diff(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(
form_state=FormState.ARCHIVING,
center=center, station_number=1)
recon_form = create_reconciliation_form(
result_form, self.user, number_unstamped_ballots=0)
self._add_user_to_group(self.user, groups.ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertIsNone(result_form.audit)
self.assertEqual(result_form.audited_count, 0)
self.assertIn('archive/print', response['location'])
def test_archive_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(
form_state=FormState.ARCHIVING,
center=center, station_number=1)
recon_form = create_reconciliation_form(
result_form, self.user, number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(
result_form.audit.quarantine_checks.all()[0].name[:9], 'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('archive/print', response['location'])
def test_new_form_post(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center)
office = create_office(tally=tally)
result_form = create_result_form(
form_state=FormState.CLEARANCE,
force_ballot=False,
tally=tally,
gender=Gender.MALE)
ballot = create_ballot(tally=tally)
view = CreateResultFormView.as_view(clearance_result_form=True)
data = {
'result_form': result_form.pk,
'gender': [u'0'],
'ballot': [ballot.pk],
'center': [center.pk],
'office': [office.pk],
'tally_id': tally.id,
'station_number': station.station_number,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.gender, Gender.MALE)
def test_review_post_supervisor_implement(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station_number = 2
result_form = create_result_form(form_state=FormState.CLEARANCE,
center=center,
tally=tally,
station_number=station_number)
self.assertEqual(result_form.center, center)
self.assertEqual(result_form.station_number, station_number)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'forward': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.CLEARANCE_SUPERVISOR)
tally.users.add(self.user)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 3,
'implement': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
clearance = result_form.clearances.all()[0]
result_form.reload()
self.assertEqual(clearance.supervisor, self.user)
self.assertFalse(clearance.active)
self.assertTrue(clearance.reviewed_supervisor)
self.assertTrue(clearance.reviewed_team)
self.assertEqual(clearance.action_prior_to_recommendation,
ActionsPrior.REQUEST_AUDIT_ACTION_FROM_FIELD)
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.form_state, FormState.UNSUBMITTED)
self.assertEqual(result_form.center, center)
self.assertEqual(result_form.station_number, station_number)
def test_pass_overvote_true(self):
center = create_center()
create_station(center=center,
registrants=1)
result_form = create_result_form(center=center)
create_reconciliation_form(result_form, self.user)
self.assertEqual(pass_overvote(result_form), True)
def test_center_detail_redirects_to_check_center_details_zero_prefix(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '000000001'
center = create_center(tally=tally)
create_result_form(barcode,
form_state=FormState.UNSUBMITTED,
tally=tally,
center=center)
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
view = views.CenterDetailsView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('intake/check-center-details',
response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.INTAKE)
self.assertEqual(result_form.user, self.user)
def test_center_detail_redirects_to_check_center_details_zero_prefix(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '000000001'
center = create_center(tally=tally)
create_result_form(barcode,
form_state=FormState.UNSUBMITTED,
tally=tally,
center=center)
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
view = views.CenterDetailsView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('intake/check-center-details', response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.INTAKE)
self.assertEqual(result_form.user, self.user)
def test_center_detail_redirects_to_enter_results(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
tally=tally,
station_number=station_number)
view = views.CenterDetailsView.as_view()
result_form_data = {'result_form': result_form.pk}
data = center_data(code,
station_number=station_number,
tally_id=tally.pk)
data.update(result_form_data)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = result_form_data
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry/enter-results',
response['location'])
def test_intake_clerk_selects_matches(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
result_form = create_result_form(barcode,
center=center,
tally=tally)
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
view = views.CheckCenterDetailsView.as_view()
post_data = {
'result_form': result_form.pk,
'is_match': 'true',
'tally_id': tally.id,
}
request = self.factory.post('/', data=post_data)
request.user = self.user
request.session = {'result_form': result_form.pk}
with self.assertRaises(Exception):
response = view(request)
result_form.form_state = FormState.INTAKE
result_form.save()
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/printcover', response['location'])
def test_archive_post_quarantine_pass_with_zero_diff(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(form_state=FormState.ARCHIVING,
center=center,
station_number=1)
recon_form = create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=0)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertIsNone(result_form.audit)
self.assertEqual(result_form.audited_count, 0)
self.assertIn('archive/print', response['location'])
def test_pass_tamper_true_no_recon(self):
"""Test pass tampering returns true with no recon form"""
center = create_center()
create_station(center=center,
registrants=1)
result_form = create_result_form(center=center)
self.assertEqual(pass_tampering(result_form), True)
def test_center_detail_redirects_to_enter_results(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
tally=tally,
station_number=station_number)
view = views.CenterDetailsView.as_view()
result_form_data = {'result_form': result_form.pk}
data = center_data(code,
station_number=station_number,
tally_id=tally.pk)
data.update(result_form_data)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = result_form_data
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry/enter-results',
response['location'])
def test_dashboard_get(self):
barcode = '123456789'
self._create_and_login_user()
center = create_center()
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, 'General Results Section')
self.assertNotContains(response, 'Reconciliation')
self.assertContains(response, 'Abort')
def test_intake_supervisor(self):
self._create_and_login_user(username='******')
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
form_user = self.user
barcode = '123456789'
center = create_center()
create_result_form(barcode,
form_state=FormState.DATA_ENTRY_1,
user=form_user,
tally=tally,
center=center)
self._add_user_to_group(self.user, groups.INTAKE_SUPERVISOR)
view = views.CenterDetailsView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('intake/printcover', response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertEqual(result_form.user, form_user)
def test_station_progress_list_data_view(self):
"""
Test that station progress list data view returns correct data
"""
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center=center, tally=tally)
create_result_form(form_state=FormState.ARCHIVED,
tally=tally,
station_number=station.station_number)
view = views.StationProgressListDataView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, tally_id=tally.pk)
office_name, sub_constituency_code, center_name, center_code,\
station_number, gender, registrants, active = json.loads(
response.content.decode())['data'][0]
self.assertEquals(office_name, str(station.center.office.name))
self.assertEquals(sub_constituency_code,
str(station.sub_constituency.code))
self.assertEquals(office_name, str(station.center.office.name))
self.assertEquals(center_name, str(station.center.name))
self.assertEquals(center_code, str(station.center.code))
self.assertEquals(station_number, str(station.station_number))
self.assertEquals(gender, str(station.gender.name.capitalize()))
self.assertEquals(registrants, str(station.registrants))
self.assertEquals(active, str(station.active))
def test_create_result_form_valid(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
barcode = '12345'
ballot = create_ballot(tally=tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(code, tally=tally, sub_constituency=sc)
station = create_station(center)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': barcode,
'created_user': self.request.user.userprofile,
'gender': 1
}
form = CreateResultForm(form_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.instance.barcode, barcode)
form.save()
self.assertEqual(
ResultForm.objects.get(id=form.instance.id).barcode, barcode)
def test_process_results_form_row_office_name_error(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
office_name = 'Mombasa'
row = [
str(ballot.number),
center.code,
str(station.station_number),
self.gender,
self.name,
office_name,
self.empty_string,
self.barcode,
self.serial_number]
with self.assertLogs(logger=self.logger, level='WARNING') as cm:
process_results_form_row(tally=self.tally,
row=row,
logger=self.logger)
self.assertIn(str('WARNING:%s:Office "%s" does not exist') %
(self.logger.name, office_name), cm.output)
def test_disable_entity_view_post_station(self):
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center)
comment_text = 'example comment text'
view = views.DisableEntityView.as_view()
data = {
'center_code_input': center.code,
'station_number_input': station.station_number,
'tally_id': tally.pk,
'comment_input': comment_text,
'disable_reason': '2',
}
request = self.factory.post('/', data)
request.user = self.user
response = view(request,
center_code=center.code,
station_number=station.station_number,
tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('/data/center-list/%s/' % tally.pk, response['Location'])
station.reload()
self.assertEqual(station.disable_reason.value, 2)
self.assertEqual(station.comments.all()[0].text, comment_text)
def test_dashboard_get_double_recon_raise(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form,
self.user,
ballot_number_from=2)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
with self.assertRaises(SuspiciousOperation):
view(request, tally_id=tally.pk)
def test_new_form_post(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center)
office = create_office(tally=tally)
result_form = create_result_form(form_state=FormState.CLEARANCE,
force_ballot=False,
tally=tally,
gender=Gender.MALE)
ballot = create_ballot(tally=tally)
view = CreateResultFormView.as_view(clearance_result_form=True)
data = {
'result_form': result_form.pk,
'gender': [u'0'],
'ballot': [ballot.pk],
'center': [center.pk],
'office': [office.pk],
'tally_id': tally.id,
'station_number': station.station_number,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.gender, Gender.MALE)
def test_duplicate_forms_post(self):
self._create_or_login_intake_clerk()
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center=center, tally=tally)
result_form = create_result_form(tally=tally,
center=center,
station_number=station.station_number,
form_state=FormState.DATA_ENTRY_1)
result_form2 = create_result_form(
'123456289',
tally=tally,
ballot=result_form.ballot,
center=result_form.center,
station_number=result_form.station_number,
serial_number=3)
view = views.CenterDetailsView.as_view()
data = {
'barcode': result_form2.barcode,
'barcode_copy': result_form2.barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(request.session['intake-error'],
INTAKE_DUPLICATE_ERROR_MESSAGE)
def test_women_get(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center()
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
name = 'general candidate name'
women_name = 'women candidate name'
votes = 123
create_candidates(result_form, self.user, name, votes, women_name)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
response.render()
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Women')
self.assertContains(response, women_name)
self.assertContains(response, name)
self.assertContains(response, str(votes))
def test_quality_control_post_quarantine(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center()
create_station(center)
create_quarantine_checks()
result_form = create_result_form(form_state=FormState.QUALITY_CONTROL,
tally=tally,
center=center,
station_number=1)
create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=1000)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'correct': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 2)
self.assertEqual(result_form.audit.user, self.user)
self.assertEqual(result_form.audited_count, 1)
self.assertIn('quality-control/print', response['location'])
def setUp(self):
center = create_center()
create_result_form(
barcode=1, serial_number=1, form_state=FormState.UNSUBMITTED)
create_result_form(
barcode=2, serial_number=2, form_state=FormState.INTAKE)
create_result_form(
barcode=3, serial_number=3, form_state=FormState.CLEARANCE)
create_result_form(
barcode=4, serial_number=4, form_state=FormState.DATA_ENTRY_1,
center=center)
create_result_form(
barcode=5, serial_number=5, form_state=FormState.DATA_ENTRY_2)
create_result_form(
barcode=6, serial_number=6, form_state=FormState.CORRECTION)
create_result_form(
barcode=7, serial_number=7, form_state=FormState.QUALITY_CONTROL,
center=center)
create_result_form(
barcode=8, serial_number=8, form_state=FormState.AUDIT)
create_result_form(
barcode=9, serial_number=9, form_state=FormState.UNSUBMITTED)
create_result_form(
barcode=10, serial_number=10, form_state=FormState.ARCHIVED)
create_result_form(form_state=FormState.ARCHIVING)
self.assertEqual(ResultForm.objects.count(), 11)
def test_center_detail_center_alpha_numeric(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
tally=tally,
station_number=station_number)
view = views.CenterDetailsView.as_view()
data = center_data('12345', '12346')
data['center_number'] = 'abcde'
data['center_number_copy'] = 'abcde'
session = {'result_form': result_form.pk}
data.update(session)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = session
response = view(request, tally_id=tally.pk)
self.assertContains(response,
u'Expecting only numbers for center number')
def test_intake_supervisor(self):
self._create_and_login_user(username='******')
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
form_user = self.user
barcode = '123456789'
center = create_center()
create_result_form(barcode,
form_state=FormState.DATA_ENTRY_1,
user=form_user,
tally=tally,
center=center)
self._add_user_to_group(self.user, groups.INTAKE_SUPERVISOR)
view = views.CenterDetailsView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('intake/printcover',
response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertEqual(result_form.user, form_user)
def test_dashboard_get_double_recon(self):
barcode = '123456789'
self._create_and_login_user()
center = create_center()
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'General Results Section')
self.assertContains(response, 'Abort')
def test_women_get(self):
barcode = "123456789"
center = create_center()
station = create_station(center=center)
create_result_form(
barcode, center=center, station_number=station.station_number, form_state=FormState.QUALITY_CONTROL
)
result_form = ResultForm.objects.get(barcode=barcode)
self._create_and_login_user()
name = "general candidate name"
women_name = "women candidate name"
votes = 123
create_candidates(result_form, self.user, name, votes, women_name)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get("/")
request.user = self.user
request.session = {"result_form": result_form.pk}
response = view(request)
response.render()
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, "Women")
self.assertContains(response, women_name)
self.assertContains(response, name)
self.assertContains(response, str(votes))
def test_center_detail_center_alpha_numeric(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center,
tally=tally,
station_number=station_number)
view = views.CenterDetailsView.as_view()
data = center_data('12345', '12346')
data['center_number'] = 'abcde'
data['center_number_copy'] = 'abcde'
session = {'result_form': result_form.pk}
data.update(session)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = session
response = view(request, tally_id=tally.pk)
self.assertContains(response,
u'Expecting only numbers for center number')
def test_general_get(self):
barcode = '123456789'
center = create_center()
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
self._create_and_login_user()
name = 'the candidate name'
women_name = 'women candidate name'
votes = 123
create_candidates(result_form, self.user, name, votes, women_name)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
response.render()
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, 'General')
self.assertContains(response, name)
self.assertContains(response, women_name)
self.assertContains(response, str(votes))
def test_enter_results_success_data_entry_two(self):
code = '12345'
center = create_center(code)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_2,
center=center)
ballot = result_form.ballot
candidate_name = 'candidate name'
create_candidate(ballot, candidate_name)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_2_CLERK)
response = self._post_enter_results(result_form)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry',
response['location'])
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.CORRECTION)
reconciliation_forms = updated_result_form.reconciliationform_set.all()
self.assertEqual(len(reconciliation_forms), 1)
self.assertEqual(reconciliation_forms[0].entry_version,
EntryVersion.DATA_ENTRY_2)
results = updated_result_form.results.all()
self.assertEqual(len(results), 1)
self.assertEqual(results[0].entry_version, EntryVersion.DATA_ENTRY_2)
self.assertEqual(results[0].user, self.user)
def test_enter_results_success_data_entry_one(self):
code = '12345'
center = create_center(code)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
center=center)
ballot = result_form.ballot
candidate_name = 'candidate name'
create_candidate(ballot, candidate_name)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
response = self._post_enter_results(result_form)
self.assertEqual(response.status_code, 302)
self.assertIn('data-entry',
response['location'])
result_form.reload()
self.assertEqual(result_form.form_state,
FormState.DATA_ENTRY_2)
reconciliation_forms = result_form.reconciliationform_set.all()
self.assertEqual(len(reconciliation_forms), 1)
self.assertEqual(reconciliation_forms[0].entry_version,
EntryVersion.DATA_ENTRY_1)
results = result_form.results.all()
self.assertEqual(len(results), 1)
self.assertEqual(results[0].entry_version, EntryVersion.DATA_ENTRY_1)
for result in results:
self.assertEqual(result.user, self.user)
def test_pass_tampering_true(self):
center = create_center()
create_station(center=center, registrants=1)
result_form = create_result_form(center=center)
create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=0)
self.assertEqual(pass_tampering(result_form), True)
def test_pass_overvote_true(self):
"""Test pass overvote returns true"""
center = create_center()
create_station(center=center,
registrants=1)
result_form = create_result_form(center=center)
create_reconciliation_form(result_form, self.user)
self.assertEqual(pass_overvote(result_form), True)
def test_remove_center_post_invalid(self):
view = views.RemoveCenterView.as_view()
center = create_center()
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
response = view(request)
self.assertContains(response,
'Ensure this value has at least 5 character')
def test_pass_tampering_true(self):
center = create_center()
create_station(center=center,
registrants=1)
result_form = create_result_form(center=center)
create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=0)
self.assertEqual(pass_tampering(result_form), True)
def test_remove_center_post_invalid(self):
view = views.RemoveCenterView.as_view()
center = create_center()
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
response = view(request)
self.assertContains(response,
'Ensure this value has at least 5 character')
def test_pass_overvote_false(self):
center = create_center()
station = create_station(center=center, registrants=1)
result_form = create_result_form(center=center,
station_number=station.station_number)
create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=11)
self.assertEqual(pass_overvote(result_form), False)
def test_pass_overvote_false(self):
center = create_center()
station = create_station(center=center, registrants=1)
result_form = create_result_form(
center=center,
station_number=station.station_number)
create_reconciliation_form(result_form,
self.user,
number_unstamped_ballots=11)
self.assertEqual(pass_overvote(result_form), False)
def test_edit_station_get(self):
tally = create_tally()
tally.users.add(self.user)
center = create_center('12345', tally=tally)
station = create_station(center)
view = views.EditStationView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, station_id=station.pk, tally_id=tally.pk)
self.assertContains(response, 'Edit Station')
self.assertContains(response, '<td>%s</td>' % station.station_number)
def test_remove_center_post_valid(self):
view = views.RemoveCenterView.as_view()
center = create_center('12345')
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
request.session = {}
request._messages = default_storage(request)
response = view(request)
self.assertEqual(response.status_code, 302)
with self.assertRaises(Center.DoesNotExist):
Center.objects.get(code=center.code)
def test_center_check_replaced_result_form_sent_to_clearance(self):
center = create_center(code='11111')
station = create_station(center)
ballot = create_ballot()
barcode = '123456789'
replacement_barcode = '012345678'
create_result_form(
barcode=barcode,
ballot=ballot,
form_state=FormState.UNSUBMITTED,
center=center,
station_number=station.station_number
)
replacement_result_form = create_result_form(
barcode=replacement_barcode,
ballot=ballot,
form_state=FormState.INTAKE,
serial_number=1
)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
view = views.EnterCenterView.as_view()
data = {'result_form': replacement_result_form.pk,
'center_number': center.code,
'center_number_copy': center.code,
'station_number': station.station_number,
'station_number_copy': station.station_number}
request = self.factory.post('/',
data=data)
request.user = self.user
request.session = {'result_form': replacement_result_form.pk}
response = view(request)
replacement_result_form.reload()
self.assertEqual(replacement_result_form.form_state, FormState.INTAKE)
self.assertEqual(replacement_result_form.station_number,
station.station_number)
self.assertEqual(replacement_result_form.center, center)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/check-center-details', response['location'])
view = views.CenterDetailsView.as_view()
barcode_data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/clearance', response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
def test_review_post_supervisor_implement_replacement_form(self):
center = create_center()
# save clearance as clerk
self._create_and_login_user()
result_form = create_result_form(form_state=FormState.CLEARANCE,
is_replacement=True,
center=center,
station_number=2)
self.assertEqual(result_form.center, center)
self.assertEqual(result_form.station_number, 2)
self.assertTrue(result_form.is_replacement)
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
view = views.ReviewView.as_view()
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'forward': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.CLEARANCE_SUPERVISOR)
view = views.ReviewView.as_view()
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 3,
'implement': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
clearance = result_form.clearances.all()[0]
result_form.reload()
self.assertEqual(clearance.supervisor, self.user)
self.assertFalse(clearance.active)
self.assertTrue(clearance.reviewed_supervisor)
self.assertTrue(clearance.reviewed_team)
self.assertEqual(clearance.action_prior_to_recommendation, 1)
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.form_state, FormState.UNSUBMITTED)
self.assertIsNone(result_form.center)
self.assertIsNone(result_form.station_number)
