def test_women_post_incorrect_ballot_released(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
ballot = create_ballot(available_for_release=True)
create_result_form(barcode,
tally=tally,
ballot=ballot,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_quality_control(result_form, self.user)
create_candidates(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'result_form': result_form.pk,
'incorrect': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/confirm-reject',
response['location'])
result_form = ResultForm.objects.get(pk=result_form.pk)
quality_control = result_form.qualitycontrol_set.all()[0]
self.assertTrue(quality_control.active)
self.assertEqual(result_form.form_state, FormState.QUALITY_CONTROL)
self.assertEqual(result_form.rejected_count, 0)
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(self):
barcode = '123456789'
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
create_result_form(barcode,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlView.as_view()
data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/dashboard',
response['location'])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.QUALITY_CONTROL)
self.assertEqual(result_form.qualitycontrol.user, self.user)
def test_reconciliation_post_correct(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
create_result_form(barcode,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'result_form': result_form.pk,
'correct': 1,
'tally_id': tally.pk,
}
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, 302)
self.assertIn('quality-control/print',
response['location'])
quality_control = QualityControl.objects.get(
pk=result_form.qualitycontrol.pk)
self.assertEqual(result_form.form_state, FormState.QUALITY_CONTROL)
self.assertTrue(quality_control.passed_reconciliation)
def test_dashboard_abort_post(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
create_result_form(barcode,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
result_form = ResultForm.objects.get(barcode=barcode)
create_quality_control(result_form, self.user)
view = views.QualityControlDashboardView.as_view()
data = {
'result_form': result_form.pk,
'abort': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
quality_control = result_form.qualitycontrol_set.all()[0]
self.assertEqual(quality_control.active, False)
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/home',
response['location'])
self.assertEqual(request.session, {})
def test_dashboard_submit_post(self):
barcode = '123456789'
create_result_form(barcode,
form_state=FormState.QUALITY_CONTROL)
self._create_and_login_user()
result_form = ResultForm.objects.get(barcode=barcode)
quality_control = create_quality_control(result_form, self.user)
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
quality_control.save()
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {'result_form': result_form.pk,
'correct': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/success',
response['location'])
self.assertEqual(result_form.form_state, FormState.ARCHIVING)
def test_women_post_incorrect(self):
self._create_and_login_user()
barcode = "123456789"
create_result_form(barcode, form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_quality_control(result_form, self.user)
create_candidates(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {"result_form": result_form.pk, "incorrect": 1}
request = self.factory.post("/", data=data)
request.user = self.user
request.session = {"result_form": result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn("quality-control/reject", response["location"])
self.assertEqual(result_form.rejected_count, 0)
result_form = ResultForm.objects.get(pk=result_form.pk)
quality_control = result_form.qualitycontrol_set.all()[0]
results = result_form.results.all()
self.assertTrue(len(results) > 0)
for result in results:
self.assertEqual(result.active, False)
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertEqual(result_form.rejected_count, 1)
self.assertEqual(quality_control.active, False)
self.assertEqual(quality_control.passed_women, False)
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_redirects_no_center(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
create_result_form(barcode,
form_state=FormState.UNSUBMITTED,
tally=tally)
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.id,
}
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/enter-center',
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_confirm_form_reset_view_post(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
ballot = create_ballot(available_for_release=True)
create_result_form(barcode,
tally=tally,
ballot=ballot,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.ConfirmFormResetView.as_view()
reject_reason = 'Form Incorrect'
data = {
'reject_reason': reject_reason
}
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 = ResultForm.objects.get(pk=result_form.pk)
quality_control = result_form.qualitycontrol_set.all()[0]
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/reject',
response['location'])
self.assertEqual(request.session, {})
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertEqual(result_form.rejected_count, 1)
self.assertEqual(result_form.reject_reason, reject_reason)
self.assertFalse(quality_control.active)
self.assertFalse(quality_control.passed_reconciliation)
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(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_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_forms(self):
create_result_form(form_state=FormState.CLEARANCE,
station_number=42)
response = self._common_view_tests(
views.DashboardView.as_view())
self.assertContains(response, 'Clearance')
self.assertContains(response, '42')
def test_create_clearance_post(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
barcode = 123456789
serial_number = 0
clearable_states = [FormState.CORRECTION,
FormState.DATA_ENTRY_1,
FormState.DATA_ENTRY_2,
FormState.INTAKE,
FormState.QUALITY_CONTROL,
FormState.ARCHIVING,
FormState.UNSUBMITTED]
for form_state in clearable_states:
result_form = create_result_form(form_state=form_state,
barcode=barcode,
serial_number=serial_number)
create_recon_forms(result_form, self.user)
create_candidates(result_form, self.user)
view = views.CreateClearanceView.as_view()
data = {'barcode': result_form.barcode,
'barcode_copy': result_form.barcode}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
self.assertIsNotNone(result_form.clearance)
self.assertEqual(result_form.clearance.user, self.user)
for result in result_form.reconciliationform_set.all():
self.assertFalse(result.active)
for result in result_form.results.all():
self.assertFalse(result.active)
barcode = barcode + 1
serial_number = serial_number + 1
# unclearable
result_form = create_result_form(form_state=FormState.ARCHIVED,
barcode=barcode,
serial_number=serial_number)
view = views.CreateClearanceView.as_view()
data = {'barcode': result_form.barcode,
'barcode_copy': result_form.barcode}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.form_state, FormState.ARCHIVED)
def test_create_audit_post(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.AUDIT_CLERK)
barcode = 123456789
serial_number = 0
auditable_states = [FormState.CORRECTION,
FormState.ARCHIVING,
FormState.DATA_ENTRY_1,
FormState.DATA_ENTRY_2,
FormState.QUALITY_CONTROL]
for form_state in auditable_states:
result_form = create_result_form(form_state=form_state,
barcode=barcode,
serial_number=serial_number)
create_recon_forms(result_form, self.user)
create_candidates(result_form, self.user)
view = views.CreateAuditView.as_view()
data = {'barcode': result_form.barcode,
'barcode_copy': result_form.barcode}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.form_state, FormState.AUDIT)
self.assertEqual(result_form.audited_count, 1)
self.assertEqual(result_form.audit.user, self.user)
for result in result_form.reconciliationform_set.all():
self.assertFalse(result.active)
for result in result_form.results.all():
self.assertFalse(result.active)
barcode = barcode + 1
serial_number = serial_number + 1
# not auditable state
result_form = create_result_form(form_state=FormState.ARCHIVED,
barcode=barcode,
serial_number=serial_number)
view = views.CreateAuditView.as_view()
data = {'barcode': result_form.barcode,
'barcode_copy': result_form.barcode}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.form_state, FormState.ARCHIVED)
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_archive_post_supervisor(self):
self._create_and_login_user()
barcode = '123456789'
create_result_form(form_state=FormState.ARCHIVED)
self._add_user_to_group(self.user, groups.ARCHIVE_SUPERVISOR)
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)
self.assertEqual(response.status_code, 302)
self.assertIn('archive/print', response['location'])
def test_dashboard_get_csv(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
create_result_form(form_state=FormState.CLEARANCE,
tally=tally)
view = views.DashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk, format='csv')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/csv')
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_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_corrections_general_post_abort(self):
view = views.CorrectionRequiredView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION)
create_results(result_form, vote1=2, vote2=3)
self._add_user_to_group(self.user, groups.CORRECTIONS_CLERK)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 2)
session = {'result_form': result_form.pk}
post_data = {
'candidate_%s' % result_form.results.all()[0].candidate.pk: 2,
'result_form': result_form.pk,
'abort_submit': 'reject'
}
request = self.factory.post('/', post_data)
request.session = session
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn('/corrections', response['location'])
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
for result in updated_result_form.results.all():
self.assertNotEqual(result.entry_version, EntryVersion.FINAL)
self.assertEqual(updated_result_form.form_state,
FormState.CORRECTION)
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_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_review_post_supervisor(self):
# save audit as clerk
result_form = create_result_form(form_state=FormState.AUDIT)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.AUDIT_CLERK)
view = views.ReviewView.as_view()
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0}
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.AUDIT_SUPERVISOR)
view = views.ReviewView.as_view()
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
audit = result_form.audit
self.assertEqual(audit.supervisor, self.user)
self.assertEqual(audit.action_prior_to_recommendation, 1)
self.assertEqual(response.status_code, 302)
def test_quality_control_post(self):
barcode = "123456789"
create_result_form(barcode, form_state=FormState.QUALITY_CONTROL)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlView.as_view()
data = {"barcode": barcode, "barcode_copy": barcode}
request = self.factory.post("/", data=data)
request.user = self.user
request.session = {}
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn("quality-control/dashboard", response["location"])
result_form = ResultForm.objects.get(barcode=barcode)
self.assertEqual(result_form.form_state, FormState.QUALITY_CONTROL)
self.assertEqual(result_form.qualitycontrol.user, self.user)
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_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_new_form_post_invalid(self):
# save clearance as clerk
result_form = create_result_form(
form_state=FormState.CLEARANCE,
force_ballot=False,
gender=None)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
view = views.NewFormView.as_view()
data = {'result_form': result_form.pk,
'gender': [u'0']}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
result_form.reload()
pk = request.session['result_form']
self.assertEqual(response.status_code, 200)
self.assertIsNotNone(pk)
result_form = ResultForm.objects.get(pk=pk)
self.assertIsNotNone(result_form.barcode)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
def test_review_post_supervisor_return(self):
# save clearance as clerk
result_form = create_result_form(form_state=FormState.CLEARANCE)
self._create_and_login_user()
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}
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': 0,
'return': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
clearance = result_form.clearance
self.assertEqual(clearance.supervisor, self.user)
self.assertEqual(clearance.action_prior_to_recommendation, 1)
self.assertEqual(clearance.reviewed_team, False)
self.assertEqual(response.status_code, 302)
def test_edit_result_form_get(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
result_form = create_result_form(form_state=FormState.UNSUBMITTED,
center=center,
tally=tally,
station_number=station_number)
view = views.EditResultFormView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, form_id=result_form.pk, tally_id=tally.pk)
self.assertContains(response, 'Edit Form')
def test_review_get(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.AUDIT_CLERK)
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.AUDIT,
tally=tally)
view = views.ReviewView.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, 'Forward to Supervisor')
def test_dashboard_submit_post(self):
barcode = '123456789'
create_result_form(barcode, form_state=FormState.QUALITY_CONTROL)
self._create_and_login_user()
result_form = ResultForm.objects.get(barcode=barcode)
quality_control = create_quality_control(result_form, self.user)
quality_control.passed_general = True
quality_control.passed_reconciliation = True
quality_control.passed_women = True
quality_control.save()
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {'result_form': result_form.pk, 'correct': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('quality-control/success', response['location'])
self.assertEqual(result_form.form_state, FormState.ARCHIVING)
def test_form_action_view_post_review_audit(self):
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.AUDIT,
tally=tally)
request = self._get_request()
view = views.FormActionView.as_view()
data = {'result_form': result_form.pk, 'review': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('/audit/review', response['Location'])
def test_overview_report_get(self):
tally = create_tally()
tally.users.add(self.user)
for i in range(1, 11):
center = create_center(tally=tally)
ballot = create_ballot(tally=tally)
create_result_form(
center=center, ballot=ballot,
station_number=i,
tally=tally,
barcode=i,
serial_number=i,
form_state=i - 1)
request = self._get_request()
view = offices.OfficesReportView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {}
response = view(request, tally_id=tally.pk)
self.assertContains(response, 'Per Office')
self.assertContains(response, 'Tally Center Progress Report')
self.assertContains(response, "<td>Not Received</td>")
def test_new_form_get_with_form(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
result_form = create_result_form(form_state=FormState.UNSUBMITTED)
view = views.NewFormView.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.assertEqual(str(response.context_data['result_form'].barcode),
result_form.barcode)
def test_review_post_invalid(self):
result_form = create_result_form(form_state=FormState.CLEARANCE)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
view = views.ReviewView.as_view()
# invalid enum value
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 9,
'resolution_recommendation': 0}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
self.assertEqual(response.status_code, 200)
def test_intaken_get(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.INTAKE,
tally=tally)
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
view = views.ConfirmationView.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,
reverse('intake', kwargs={'tally_id': tally.pk}))
def test_center_detail_redirects_no_center(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
create_result_form(barcode,
form_state=FormState.UNSUBMITTED,
tally=tally)
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.id,
}
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/enter-center', 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_review_post_supervisor_return(self):
# save audit as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.AUDIT_CLERK)
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.AUDIT,
tally=tally)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'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.AUDIT_SUPERVISOR)
tally.users.add(self.user)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'return': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
data['encoded_result_form_audit_start_time'] =\
self.encoded_result_form_audit_start_time
request.session = data
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
audit = result_form.audit
self.assertEqual(audit.supervisor, self.user)
self.assertEqual(audit.action_prior_to_recommendation,
ActionsPrior.REQUEST_AUDIT_ACTION_FROM_FIELD)
self.assertEqual(audit.reviewed_team, False)
def test_number_ballots_used_results(self):
expected_votes = 0
for num_results in xrange(1, 4):
for votes in xrange(1, 4):
result_form = create_result_form()
create_candidates(result_form,
self.user,
votes=votes,
num_results=num_results)
re_form = create_reconciliation_form(result_form, self.user)
expected_votes += num_results * votes * 2
self.assertEqual(re_form.number_ballots_used,
self.num_used + expected_votes)
def test_review_get_supervisor(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_SUPERVISOR)
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.CLEARANCE,
tally=tally)
view = views.ReviewView.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, 'Mark Form as Resolved')
self.assertContains(response, 'Return to Clearance Team')
def test_remove_result_form_confirmation_get(self):
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.UNSUBMITTED,
center=center,
tally=tally,
station_number=station_number)
view = views.RemoveResultFormConfirmationView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, form_id=result_form.pk, tally_id=tally.pk)
self.assertContains(response, '<form name="remove-form-form"')
def test_sanity_check_results(self):
"""Test sanity checks for final results"""
votes = 12
result_form = create_result_form()
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)
self.assertEqual(result_form.results_final.filter().count(), 4)
sanity_check_final_results(result_form)
self.assertEqual(result_form.results_final.filter().count(), 2)
def test_dashboard_get_supervisor(self):
username = '******'
self._create_and_login_user(username=username)
result_form = create_result_form(form_state=FormState.AUDIT,
station_number=42)
create_audit(result_form, self.user, reviewed_team=True)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.AUDIT_SUPERVISOR)
request = self.factory.get('/')
request.user = self.user
view = views.DashboardView.as_view()
response = view(request)
self.assertContains(response, 'Audit')
self.assertContains(response, username)
self.assertContains(response, '42')
def test_print_cover_supervisor(self):
username = '******'
self._create_and_login_user(username=username)
result_form = create_result_form(form_state=FormState.CLEARANCE,
station_number=42)
create_clearance(result_form, self.user, reviewed_team=True)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_SUPERVISOR)
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
view = views.PrintCoverView.as_view()
response = view(request)
self.assertContains(response, 'Clearance Case')
self.assertContains(response, '42')
def test_clearance(self):
result_form = create_result_form()
self._create_or_login_intake_clerk()
view = views.ClearanceView.as_view()
self.request.user = self.user
self.request.session = {'result_form': result_form.pk}
with self.assertRaises(Exception):
response = view(self.request)
result_form.form_state = FormState.INTAKE
result_form.save()
result_form.form_state = FormState.CLEARANCE
result_form.save()
response = view(self.request)
self.assertIsNone(self.request.session.get('result_form'))
self.assertContains(response,
'Form Sent to Clearance. Pass to Supervisor')
def test_remove_center_post_result_exists(self):
center = create_center('12345')
result_form = create_result_form(center=center,
form_state=FormState.AUDIT)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
self.assertTrue(Result.objects.filter().count() > 0)
view = views.RemoveCenterView.as_view()
data = {'center_number': center.code}
request = self.factory.post('/', data)
request.user = self.user
response = view(request)
self.assertContains(response, u"Results exist for barcodes")
self.assertContains(response, result_form.barcode)
def test_print_post_supervisor(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.ARCHIVE_SUPERVISOR)
result_form = create_result_form(form_state=FormState.ARCHIVED)
view = views.ArchivePrintView.as_view()
data = {'result_form': result_form.pk}
request = self.factory.post('/', data=data)
request.session = data
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn('/archive/success', response['location'])
result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(result_form.form_state, FormState.ARCHIVED)
def test_surpervisors_approvals_get_with_data(self):
tally = create_tally()
tally.users.add(self.user)
result_form =\
create_result_form(
name="Example",
tally=tally,
form_state=FormState.AUDIT)
start_time = timezone.now()
minutes = 65.5
end_time = start_time + timezone.timedelta(minutes=minutes)
form_processing_time_in_seconds =\
(end_time - start_time).total_seconds()
# Audit supervisor audit review
audit_supervisor_user =\
self._create_user('audit_supervisor', 'password')
self._add_user_to_group(audit_supervisor_user, groups.AUDIT_SUPERVISOR)
create_result_form_stats(
processing_time=form_processing_time_in_seconds,
user=audit_supervisor_user,
result_form=result_form,
reviewed_by_supervisor=True,
approved_by_supervisor=True)
request = self._get_request()
view = staff_performance_metrics.SupervisorsApprovalsView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(
request,
tally_id=tally.pk,
)
self.assertContains(response,
"<h1>Supervisors Approvals Rate Report</h1>")
self.assertContains(response,
"<h3>Audit Supervisors Approval Rate</h3>")
self.assertContains(response, "<h3>Tally Managers Approval Rate</h3>")
self.assertContains(response, "<th>Number of Approved Forms</th>")
self.assertContains(response,
"<th>Number of Forms Sent For Review</th>")
self.assertContains(response, "<th>Approval Rate</th>")
self.assertContains(response, '<td>1</td>')
self.assertContains(response, '<td>100.0%</td>')
def test_print_cover_post_supervisor(self):
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1)
self._create_and_login_user()
self._add_user_to_group(self.user, groups.INTAKE_SUPERVISOR)
view = views.PrintCoverView.as_view()
request = self.factory.post('/', data={'result_form': result_form.pk})
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertIn('', response['location'])
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(request.session.get('result_form'),
result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.DATA_ENTRY_1)
def test_intake_clerk_selects_matches(self):
barcode = '123456789'
result_form = create_result_form(barcode)
self._create_and_login_user()
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'}
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)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/printcover', response['location'])
def test_review_post_supervisor(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)
result_form = create_result_form(form_state=FormState.CLEARANCE,
tally=tally)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'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': 0,
'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.clearance
self.assertEqual(clearance.supervisor, self.user)
self.assertNotEqual(clearance.date_supervisor_modified, None)
self.assertNotEqual(clearance.date_team_modified, None)
self.assertEqual(clearance.action_prior_to_recommendation,
ActionsPrior.REQUEST_AUDIT_ACTION_FROM_FIELD)
self.assertEqual(response.status_code, 302)
def test_new_form_get_with_form(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)
result_form = create_result_form(form_state=FormState.UNSUBMITTED,
tally=tally)
view = CreateResultFormView.as_view(clearance_result_form=True)
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.assertIsNotNone(result_form.barcode)
self.assertEqual(str(response.context_data['title']),
'Clearance: New Result Form')
def test_print_cover_get(self):
self._create_or_login_intake_clerk()
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(tally=tally)
view = views.PrintCoverView.as_view()
self.request.user = self.user
self.request.session = {'result_form': result_form.pk}
result_form.form_state = FormState.INTAKE
result_form.save()
response = view(self.request, tally_id=tally.pk)
expected_strings = [
'Intake:', 'Successful', '>Print</button>', 'Data Entry One:',
'Data Entry Two:', 'To Quality Control [ ]'
]
for test_string in expected_strings:
self.assertContains(response, test_string)
def test_print_cover_get_supervisor(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(tally=tally,
form_state=FormState.DATA_ENTRY_1)
self._add_user_to_group(self.user, groups.INTAKE_SUPERVISOR)
view = views.PrintCoverView.as_view()
self.request.user = self.user
self.request.session = {'result_form': result_form.pk}
response = view(self.request, tally_id=tally.pk)
expected_strings = [
'Intake:', 'Successful', '>Print</button>', 'Data Entry One:',
'Data Entry Two:', 'To Quality Control [ ]'
]
for test_string in expected_strings:
self.assertContains(response, test_string)
def test_corrections_women_post_corrections(self):
view = views.CorrectionRequiredView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
data_entry_2_user =\
self._create_user('data_entry_2', 'password')
self._add_user_to_group(data_entry_2_user, groups.DATA_ENTRY_2_CLERK)
start_time = timezone.now()
minutes = 65.5
end_time = start_time + timezone.timedelta(minutes=minutes)
form_processing_time_in_seconds =\
(end_time - start_time).total_seconds()
result_form_stat = create_result_form_stats(
processing_time=form_processing_time_in_seconds,
user=data_entry_2_user,
result_form=result_form)
create_results(result_form, vote1=2, vote2=3, race_type=RaceType.WOMEN)
self._add_user_to_group(self.user, groups.CORRECTIONS_CLERK)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 2)
session = {'result_form': result_form.pk}
candate_pk = result_form.results.all()[0].candidate.pk
post_data = {
f'candidate_women_{candate_pk}': 2,
'result_form': result_form.pk,
'submit_corrections': 'submit corrections',
'tally_id': self.tally.pk,
}
request = self.factory.post('/', post_data)
request.session = session
request.user = self.user
response = view(request, tally_id=self.tally.pk)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
self.assertEqual(response.status_code, 302)
self.assertIn('/corrections/success', response['location'])
result_form_stat.reload()
self.assertEqual(result_form_stat.data_entry_errors, 1)
def test_confirmation_get_corrections(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.DATA_ENTRY_2_CLERK)
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=tally)
view = views.ConfirmationView.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.assertIsNone(request.session.get('result_form'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Corrections')
self.assertContains(response, reverse(
'data-entry', kwargs={'tally_id': tally.pk}))
def test_confirmation_get(self):
result_form = create_result_form(form_state=FormState.QUALITY_CONTROL,
tally=self.tally)
self._add_user_to_group(self.user, groups.CORRECTIONS_CLERK)
view = views.ConfirmationView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
request.session['encoded_result_form_corrections_start_time'] =\
self.encoded_result_form_corrections_start_time
response = view(request, tally_id=self.tally.pk)
self.assertEqual(response.status_code, 200)
self.assertIsNone(request.session.get('result_form'))
self.assertContains(response, 'Quality Control')
self.assertContains(
response, reverse('corrections',
kwargs={'tally_id': self.tally.pk}))
def test_enter_results_success_data_entry(self):
self._create_and_login_user('data_entry_1')
self._add_user_to_group(self.user, groups.DATA_ENTRY_1_CLERK)
tally = create_tally()
tally.users.add(self.user)
code = '12345'
center = create_center(code, tally=tally)
create_station(center)
result_form = create_result_form(form_state=FormState.DATA_ENTRY_1,
tally=tally)
ballot = result_form.ballot
candidate_name = 'candidate name'
create_candidate(ballot, candidate_name)
view = views.EnterResultsView.as_view()
data = result_form_data(result_form)
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
data_entry_1 = self.user
self._create_and_login_user('data_entry_2')
self._add_user_to_group(self.user, groups.DATA_ENTRY_2_CLERK)
tally.users.add(self.user)
request.user = self.user
response = view(request, tally_id=tally.pk)
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)
results = updated_result_form.results.filter(
entry_version=EntryVersion.DATA_ENTRY_2)
self.assertTrue(results.count() > 0)
self.assertEqual(results.all()[0].user, self.user)
results = updated_result_form.results.filter(
entry_version=EntryVersion.DATA_ENTRY_2)
self.assertTrue(results.count() > 0)
for result in results:
self.assertEqual(result.user, self.user)
self.assertNotEqual(result.user, data_entry_1)
