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_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_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)