def test_general_get(self):
barcode = '123456789'
center = create_center()
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
self._create_and_login_user()
name = 'the candidate name'
women_name = 'women candidate name'
votes = 123
create_candidates(result_form, self.user, name, votes, women_name)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
response.render()
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, 'General')
self.assertContains(response, name)
self.assertContains(response, women_name)
self.assertContains(response, str(votes))
def setUp(self):
self.factory = RequestFactory()
self._create_permission_groups()
self._create_and_login_user()
self._add_user_to_group(self.user, groups.TALLY_MANAGER)
self.tally = create_tally()
self.tally.users.add(self.user)
ballot = create_ballot(tally=self.tally)
center = create_center('12345', tally=self.tally)
station = create_station(center)
result_form = create_result_form(tally=self.tally,
ballot=ballot,
center=center,
station_number=station.station_number)
votes = 12
create_candidates(result_form,
votes=votes,
user=self.user,
num_results=1)
for result in result_form.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form, result.candidate, self.user, votes)
def test_archive_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(form_state=FormState.ARCHIVING,
center=center,
station_number=1)
recon_form = create_reconciliation_form(result_form,
self.user,
number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(result_form.audit.quarantine_checks.all()[0].name[:9],
'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('archive/print', response['location'])
def test_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_review_post_check_audit_state_when_no_action_prior(self):
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.AUDIT_SUPERVISOR)
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(form_state=FormState.AUDIT,
tally=tally)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'resolution_recommendation': 1,
'implement': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
audit = Audit.objects.get(result_form=result_form)
self.assertEqual(audit.reviewed_supervisor, True)
self.assertNotEqual(audit.result_form.form_state, FormState.AUDIT)
self.assertEqual(audit.result_form.form_state, FormState.DATA_ENTRY_1)
def test_archive_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
barcode = '123456789'
result_form = create_result_form(
form_state=FormState.ARCHIVING,
center=center, station_number=1)
recon_form = create_reconciliation_form(
result_form, self.user, number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user, groups.ARCHIVE_CLERK)
view = views.ArchiveView.as_view()
data = {'barcode': barcode, 'barcode_copy': barcode}
request = self.factory.post('/', data=data)
request.session = {}
request.user = self.user
response = view(request)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(
result_form.audit.quarantine_checks.all()[0].name[:9], 'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('archive/print', response['location'])
def test_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_dashboard_get_double_recon_raise(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form,
self.user,
ballot_number_from=2)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
with self.assertRaises(SuspiciousOperation):
view(request, tally_id=tally.pk)
def test_women_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_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_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_dashboard_get_double_recon(self):
barcode = '123456789'
self._create_and_login_user()
center = create_center()
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user,
groups.QUALITY_CONTROL_ARCHIVE_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'General Results Section')
self.assertContains(response, 'Abort')
def test_dashboard_get_double_recon_raise(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user,
ballot_number_from=2)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
with self.assertRaises(SuspiciousOperation):
view(request, tally_id=tally.pk)
def test_dashboard_get_double_recon(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
barcode = '123456789'
center = create_center(tally=tally)
station = create_station(center=center)
result_form = create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'General Results Section')
self.assertContains(response, 'Cancel')
def test_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_ARCHIVE_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_form_action_view_post_confirm_audit(self):
result_form = create_result_form(form_state=FormState.AUDIT)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
audit = create_audit(result_form, self.user)
request = self._get_request()
view = views.FormActionView.as_view()
data = {'result_form': result_form.pk, 'confirm': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
audit.reload()
result_form.reload()
self.assertFalse(audit.active)
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertTrue(result_form.skip_quarantine_checks)
self.assertEqual(len(result_form.results.all()), 20)
self.assertEqual(len(result_form.reconciliationform_set.all()), 2)
for result in result_form.results.all():
self.assertFalse(result.active)
for result in result_form.reconciliationform_set.all():
self.assertFalse(result.active)
self.assertEqual(response.status_code, 302)
self.assertIn('/super-administrator/form-action-list',
response['Location'])
def test_form_action_view_post_confirm_audit(self):
result_form = create_result_form(form_state=FormState.AUDIT)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
audit = create_audit(result_form, self.user)
request = self._get_request()
view = views.FormActionView.as_view()
data = {'result_form': result_form.pk,
'confirm': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
audit.reload()
result_form.reload()
self.assertFalse(audit.active)
self.assertEqual(result_form.form_state, FormState.DATA_ENTRY_1)
self.assertTrue(result_form.skip_quarantine_checks)
self.assertEqual(len(result_form.results.all()), 20)
self.assertEqual(len(result_form.reconciliationform_set.all()),
2)
for result in result_form.results.all():
self.assertFalse(result.active)
for result in result_form.reconciliationform_set.all():
self.assertFalse(result.active)
self.assertEqual(response.status_code, 302)
self.assertIn('/super-administrator/form-action-list',
response['Location'])
def test_dashboard_get(self):
barcode = '123456789'
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center=center)
create_result_form(barcode,
center=center,
station_number=station.station_number,
tally=tally,
form_state=FormState.QUALITY_CONTROL)
result_form = ResultForm.objects.get(barcode=barcode)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get('/')
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 200)
# gender has been removed
# self.assertContains(response, str(result_form.gender_name))
self.assertContains(response, 'General Results Section')
self.assertNotContains(response, 'Reconciliation')
self.assertContains(response, 'Cancel')
def test_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_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_pass_tampering_true_diff(self):
center = create_center()
create_station(center=center, registrants=1)
result_form = create_result_form(center=center)
create_candidates(result_form, self.user, num_results=1)
create_reconciliation_form(result_form,
self.user,
number_ballots_inside_box=250,
number_unstamped_ballots=0)
self.assertEqual(pass_tampering(result_form), True)
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_review_post_supervisor_implement_de1(self):
# save audit as clerk
self._create_and_login_user()
result_form = create_result_form(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._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,
'forward': 1
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.AUDIT_SUPERVISOR)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 1,
'implement': 1
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
audit = Audit.objects.get(result_form=result_form)
self.assertEqual(audit.supervisor, self.user)
self.assertTrue(audit.reviewed_supervisor)
self.assertTrue(audit.reviewed_team)
self.assertFalse(audit.active)
self.assertEqual(audit.result_form.form_state, FormState.DATA_ENTRY_1)
self.assertEqual(len(audit.result_form.results.all()), 20)
self.assertEqual(len(audit.result_form.reconciliationform_set.all()),
2)
for result in audit.result_form.results.all():
self.assertFalse(result.active)
for result in audit.result_form.reconciliationform_set.all():
self.assertFalse(result.active)
self.assertEqual(audit.action_prior_to_recommendation, 1)
self.assertEqual(response.status_code, 302)
def test_pass_tampering_true_diff(self):
center = create_center()
create_station(center=center,
registrants=1)
result_form = create_result_form(center=center)
create_candidates(result_form, self.user, num_results=1)
create_reconciliation_form(result_form,
self.user,
number_ballots_inside_box=250,
number_unstamped_ballots=0)
self.assertEqual(pass_tampering(result_form), True)
def test_create_clearance_post_super(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.SUPER_ADMINISTRATOR)
tally = create_tally()
tally.users.add(self.user)
barcode = 123456789
serial_number = 0
clearable_states = [
FormState.ARCHIVED, FormState.CORRECTION, FormState.DATA_ENTRY_1,
FormState.DATA_ENTRY_2, FormState.INTAKE,
FormState.QUALITY_CONTROL, FormState.UNSUBMITTED
]
for form_state in clearable_states:
result_form = create_result_form(form_state=form_state,
barcode=barcode,
tally=tally,
serial_number=serial_number)
create_recon_forms(result_form, self.user)
create_candidates(result_form, self.user)
view = views.AddClearanceFormView.as_view()
data = {
'accept_submit': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
data['encoded_result_form_clearance_start_time'] =\
self.encoded_result_form_clearance_start_time
request.session = data
response = view(request, tally_id=tally.pk)
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)
result_form_stat = ResultFormStats.objects.get(
result_form=result_form)
self.assertEqual(result_form_stat.approved_by_supervisor, False)
self.assertEqual(result_form_stat.reviewed_by_supervisor, False)
self.assertEqual(result_form_stat.user, self.user)
self.assertEqual(result_form_stat.result_form, result_form)
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
def test_review_post_supervisor_implement_de1(self):
# save audit as clerk
self._create_and_login_user()
result_form = create_result_form(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._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,
'forward': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.AUDIT_SUPERVISOR)
view = views.ReviewView.as_view()
data = {'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 1,
'implement': 1}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request)
audit = Audit.objects.get(result_form=result_form)
self.assertEqual(audit.supervisor, self.user)
self.assertTrue(audit.reviewed_supervisor)
self.assertTrue(audit.reviewed_team)
self.assertFalse(audit.active)
self.assertEqual(audit.result_form.form_state,
FormState.AUDIT_PENDING_STATE)
self.assertEqual(len(audit.result_form.results.all()), 20)
self.assertEqual(len(audit.result_form.reconciliationform_set.all()),
2)
for result in audit.result_form.results.all():
self.assertFalse(result.active)
for result in audit.result_form.reconciliationform_set.all():
self.assertFalse(result.active)
self.assertEqual(audit.action_prior_to_recommendation, 1)
self.assertEqual(response.status_code, 302)
def test_duplicate_result_form_view_send_all_clearance_post(self):
tally = create_tally()
tally.users.add(self.user)
ballot = create_ballot(tally=tally)
barcode = '1234',
center = create_center('12345', tally=tally)
station = create_station(center)
result_form_1 = create_result_form(
tally=tally,
ballot=ballot,
center=center,
station_number=station.station_number)
result_form_2, _ = ResultForm.objects.get_or_create(
id=2,
ballot=ballot,
barcode=barcode,
serial_number=2,
form_state=FormState.UNSUBMITTED,
station_number=station.station_number,
user=None,
center=center,
gender=Gender.MALE,
is_replacement=False,
tally=tally,
)
votes = 12
create_candidates(result_form_1,
votes=votes,
user=self.user,
num_results=1)
for result in result_form_1.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form_2, result.candidate, self.user, votes)
view = views.DuplicateResultFormView.as_view()
data = {'send_all_clearance': 1}
request = self.factory.post('/', data=data)
request.user = self.user
configure_messages(request)
response = view(request, tally_id=tally.pk, ballot_id=ballot.pk)
result_form_1.reload()
result_form_2.reload()
self.assertEqual(response.status_code, 302)
self.assertIn("/super-administrator/duplicate-result-tracking",
response.url)
self.assertEqual(result_form_1.form_state, FormState.CLEARANCE)
self.assertTrue(result_form_1.duplicate_reviewed)
self.assertEqual(result_form_2.form_state, FormState.CLEARANCE)
self.assertTrue(result_form_2.duplicate_reviewed)
def test_sanity_check_results(self):
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_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_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_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_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_create_clearance_post_super(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.SUPER_ADMINISTRATOR)
tally = create_tally()
tally.users.add(self.user)
barcode = 123456789
serial_number = 0
clearable_states = [FormState.ARCHIVED,
FormState.CORRECTION,
FormState.DATA_ENTRY_1,
FormState.DATA_ENTRY_2,
FormState.INTAKE,
FormState.QUALITY_CONTROL,
FormState.UNSUBMITTED]
for form_state in clearable_states:
result_form = create_result_form(form_state=form_state,
barcode=barcode,
tally=tally,
serial_number=serial_number)
create_recon_forms(result_form, self.user)
create_candidates(result_form, self.user)
view = views.AddClearanceFormView.as_view()
data = {
'accept_submit': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
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
def test_reconciliation_post_incorrect_ballot_not_released(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_recon_forms(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
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/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)
recon_forms = result_form.reconciliationform_set.all()
self.assertTrue(len(recon_forms) > 0)
for recon in recon_forms:
self.assertEqual(recon.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_reconciliation, False)
def test_reviews_passed(self):
result_form = create_result_form()
create_candidates(result_form, self.user)
quality_control = QualityControl.objects.create(
result_form=result_form,
user=self.user)
self.assertFalse(quality_control.reviews_passed)
quality_control.passed_general = True
quality_control.save()
self.assertFalse(quality_control.reviews_passed)
quality_control.passed_reconciliation = True
quality_control.save()
self.assertFalse(quality_control.reviews_passed)
quality_control.passed_women = True
quality_control.save()
self.assertTrue(quality_control.reviews_passed)
def test_quality_control_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(tally=tally,
form_state=FormState.QUALITY_CONTROL,
center=center,
station_number=1)
recon_form = create_reconciliation_form(result_form,
self.user,
number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_quality_control(result_form, self.user)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'correct': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(result_form.audit.quarantine_checks.all()[0].name[:9],
'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('quality-control/print', response['location'])
def test_quality_control_post_quarantine_pass_below_tolerance(self):
center = create_center()
create_station(center)
create_quarantine_checks()
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
result_form = create_result_form(
tally=tally,
form_state=FormState.QUALITY_CONTROL,
center=center, station_number=1)
recon_form = create_reconciliation_form(
result_form, self.user, number_ballots_inside_box=21,
number_unstamped_ballots=0)
create_quality_control(result_form, self.user)
create_candidates(result_form, self.user, votes=1, num_results=10)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
data = {
'correct': 1,
'result_form': result_form.pk,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.session = {'result_form': result_form.pk}
request.user = self.user
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(result_form.num_votes,
recon_form.number_ballots_expected)
self.assertEqual(response.status_code, 302)
self.assertTrue(result_form.form_state, FormState.AUDIT)
self.assertTrue(result_form.audit)
self.assertEqual(result_form.audit.quarantine_checks.count(), 1)
self.assertEqual(
result_form.audit.quarantine_checks.all()[0].name[:9], 'Trigger 1')
self.assertEqual(result_form.audited_count, 1)
self.assertIn('quality-control/print', response['location'])
def setUp(self):
self.factory = RequestFactory()
self._create_permission_groups()
self._create_and_login_user()
self._add_user_to_group(self.user, groups.SUPER_ADMINISTRATOR)
self.tally = create_tally()
self.tally.users.add(self.user)
ballot = create_ballot(tally=self.tally)
self.center = create_center('12345', tally=self.tally)
self.station = create_station(self.center)
result_form = create_result_form(
tally=self.tally,
ballot=ballot,
center=self.center,
station_number=self.station.station_number)
votes = 12
create_candidates(result_form,
votes=votes,
user=self.user,
num_results=1)
def test_dashboard_get_double_recon(self):
barcode = "123456789"
self._create_and_login_user()
center = create_center()
station = create_station(center=center)
result_form = create_result_form(
barcode, center=center, station_number=station.station_number, form_state=FormState.QUALITY_CONTROL
)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
create_quality_control(result_form, self.user)
self._add_user_to_group(self.user, groups.QUALITY_CONTROL_CLERK)
view = views.QualityControlDashboardView.as_view()
request = self.factory.get("/")
request.user = self.user
request.session = {"result_form": result_form.pk}
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "General Results Section")
self.assertContains(response, "Abort")
def test_remove_station_post_result_exists(self):
tally = create_tally()
tally.users.add(self.user)
center = create_center('12345', tally=tally)
station = create_station(center)
result_form = create_result_form(center=center,
form_state=FormState.AUDIT,
station_number=station.station_number)
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.RemoveStationView.as_view()
data = {
'center_number': center.code,
'station_number': station.station_number,
'tally_id': tally.pk,
}
request = self.factory.post('/', data)
request.user = self.user
response = view(request, tally_id=tally.pk)
self.assertContains(response, u"Results exist for barcodes")
self.assertContains(response, result_form.barcode)
def test_get_result_form_with_duplicate_results(self):
tally = create_tally()
tally.users.add(self.user)
ballot_1 = create_ballot(tally=tally)
barcode = '1234',
center = create_center('12345', tally=tally)
station = create_station(center)
result_form_1 = create_result_form(
tally=tally,
ballot=ballot_1,
center=center,
station_number=station.station_number)
result_form_2, _ = ResultForm.objects.get_or_create(
id=2,
ballot=ballot_1,
barcode=barcode,
serial_number=2,
form_state=FormState.UNSUBMITTED,
station_number=station.station_number,
user=None,
center=center,
gender=Gender.MALE,
is_replacement=False,
tally=tally,
)
votes = 12
create_candidates(result_form_1,
votes=votes,
user=self.user,
num_results=1)
for result in result_form_1.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form_2, result.candidate, self.user, votes)
duplicate_results = views.get_result_form_with_duplicate_results(
tally_id=tally.pk)
self.assertIn(result_form_1, duplicate_results)
self.assertIn(result_form_2, duplicate_results)
# test filtering duplicate result forms by ballot
ballot_2, _ = Ballot.objects.get_or_create(id=2,
active=True,
number=2,
tally=tally,
available_for_release=False,
race_type=RaceType.GENERAL,
document="")
result_form_3, _ = ResultForm.objects.get_or_create(
id=3,
ballot=ballot_2,
barcode="12345",
serial_number=3,
form_state=FormState.UNSUBMITTED,
station_number=station.station_number,
user=None,
center=center,
gender=Gender.MALE,
is_replacement=False,
tally=tally,
)
result_form_4, _ = ResultForm.objects.get_or_create(
id=4,
ballot=ballot_2,
barcode="123456",
serial_number=4,
form_state=FormState.UNSUBMITTED,
station_number=station.station_number,
user=None,
center=center,
gender=Gender.MALE,
is_replacement=False,
tally=tally,
)
create_candidates(result_form_3,
votes=votes,
user=self.user,
num_results=1)
for result in result_form_3.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form_4, result.candidate, self.user, votes)
ballot_1_duplicates = views.get_result_form_with_duplicate_results(
ballot=ballot_1.pk, tally_id=tally.pk)
ballot_2_duplicates = views.get_result_form_with_duplicate_results(
ballot=ballot_2.pk, tally_id=tally.pk)
all_duplicates = views.get_result_form_with_duplicate_results(
tally_id=tally.pk)
# check result_form_1 and result_form_2 are in ballot_1_duplicates
self.assertIn(result_form_1, ballot_1_duplicates)
self.assertIn(result_form_2, ballot_1_duplicates)
# check result_form_3 and result_form_4 are not in ballot_1_duplicates
self.assertNotIn(result_form_3, ballot_1_duplicates)
self.assertNotIn(result_form_4, ballot_1_duplicates)
# check result_form_3 and result_form_4 are in ballot_2_duplicates
self.assertIn(result_form_3, ballot_2_duplicates)
self.assertIn(result_form_4, ballot_2_duplicates)
# check result_form_1 and result_form_2 are not in ballot_2_duplicates
self.assertNotIn(result_form_1, ballot_2_duplicates)
self.assertNotIn(result_form_2, ballot_2_duplicates)
self.assertIn(result_form_1, all_duplicates)
self.assertIn(result_form_2, all_duplicates)
self.assertIn(result_form_3, all_duplicates)
self.assertIn(result_form_4, all_duplicates)
def test_review_post_supervisor_implement_de1(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)
create_reconciliation_form(result_form, self.user)
create_reconciliation_form(result_form, self.user)
create_candidates(result_form, self.user)
view = views.ReviewView.as_view()
data = {
'result_form': result_form.pk,
'action_prior_to_recommendation': 1,
'resolution_recommendation': 0,
'forward': 1,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = data
response = view(request, tally_id=tally.pk)
# save as supervisor
self._create_and_login_user(username='******')
self._add_user_to_group(self.user, groups.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': 1,
'implement': 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 = Audit.objects.get(result_form=result_form)
self.assertEqual(audit.supervisor, self.user)
self.assertTrue(audit.reviewed_supervisor)
self.assertTrue(audit.reviewed_team)
self.assertFalse(audit.active)
self.assertEqual(audit.result_form.form_state, FormState.AUDIT)
self.assertEqual(len(audit.result_form.results.all()), 20)
self.assertEqual(len(audit.result_form.reconciliationform_set.all()),
2)
result_form_stat = ResultFormStats.objects.get(result_form=result_form)
approved_by_supervisor =\
audit.for_superadmin and audit.active
self.assertEqual(result_form_stat.approved_by_supervisor,
approved_by_supervisor)
self.assertEqual(result_form_stat.reviewed_by_supervisor,
audit.reviewed_supervisor)
self.assertEqual(result_form_stat.user, self.user)
self.assertEqual(result_form_stat.result_form, result_form)
for result in audit.result_form.results.all():
self.assertFalse(result.active)
for result in audit.result_form.reconciliationform_set.all():
self.assertFalse(result.active)
self.assertEqual(audit.action_prior_to_recommendation,
ActionsPrior.REQUEST_AUDIT_ACTION_FROM_FIELD)
def test_duplicate_result_form_view_send_clearance_post(self):
tally = create_tally()
tally.users.add(self.user)
ballot = create_ballot(tally=tally)
barcode = '1234',
center = create_center('12345', tally=tally)
station = create_station(center)
result_form = create_result_form(tally=tally,
ballot=ballot,
barcode=barcode,
center=center,
station_number=station.station_number)
votes = 12
create_candidates(result_form,
votes=votes,
user=self.user,
num_results=1)
view = views.DuplicateResultFormView.as_view()
data = {'result_form': result_form.pk, 'send_clearance': 1}
request = self.factory.post('/', data=data)
request.user = self.user
configure_messages(request)
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk, ballot_id=ballot.pk)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertIn("/super-administrator/duplicate-result-tracking",
response.url)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
self.assertTrue(result_form.duplicate_reviewed)
# check archived form is not sent to clearance
result_form_2, _ = ResultForm.objects.get_or_create(
id=2,
ballot=ballot,
barcode="1234",
serial_number=2,
form_state=FormState.ARCHIVED,
station_number=station.station_number,
user=None,
center=center,
gender=Gender.MALE,
is_replacement=False,
tally=tally,
)
create_candidates(result_form_2,
votes=votes,
user=self.user,
num_results=1)
data = {'result_form': result_form_2.pk, 'send_clearance': 1}
request = self.factory.post('/', data=data)
request.user = self.user
configure_messages(request)
request.session = {'result_form': result_form_2.pk}
response = view(request, tally_id=tally.pk, ballot_id=ballot.pk)
result_form_2.reload()
self.assertNotEqual(result_form_2.form_state, FormState.CLEARANCE)
self.assertEqual(result_form_2.form_state, FormState.ARCHIVED)
self.assertEqual(response.status_code, 302)
self.assertEqual("/", response.url)
