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_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 setUp(self):
self.factory = RequestFactory()
self._create_permission_groups()
self._create_and_login_user()
self._add_user_to_group(self.user, groups.TALLY_MANAGER)
self.tally = create_tally()
self.tally.users.add(self.user)
ballot = create_ballot(tally=self.tally)
center = create_center('12345', tally=self.tally)
station = create_station(center)
result_form = create_result_form(tally=self.tally,
ballot=ballot,
center=center,
station_number=station.station_number)
votes = 12
create_candidates(result_form,
votes=votes,
user=self.user,
num_results=1)
for result in result_form.results.all():
result.entry_version = EntryVersion.FINAL
result.save()
# create duplicate final results
create_result(result_form, result.candidate, self.user, votes)
def test_process_results_form_row_ballot_number_error(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=2, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
row = [
str(ballot.number),
center.code,
str(station.station_number),
self.gender,
self.name,
self.office_name,
self.empty_string,
self.barcode,
self.serial_number]
with self.assertLogs(logger=self.logger, level='WARNING') as cm:
process_results_form_row(tally=self.tally,
row=row,
logger=self.logger)
self.assertIn(
str('WARNING:%s:Ballot number "%s" do not match for '
'center "%s" and station "%s"') %
(self.logger.name,
ballot.number,
center.code,
station.station_number), cm.output)
def test_new_form_post(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center)
office = create_office(tally=tally)
result_form = create_result_form(
form_state=FormState.CLEARANCE,
force_ballot=False,
tally=tally,
gender=Gender.MALE)
ballot = create_ballot(tally=tally)
view = CreateResultFormView.as_view(clearance_result_form=True)
data = {
'result_form': result_form.pk,
'gender': [u'0'],
'ballot': [ballot.pk],
'center': [center.pk],
'office': [office.pk],
'tally_id': tally.id,
'station_number': station.station_number,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.gender, Gender.MALE)
def test_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_process_results_form_row_office_name_error(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
office_name = 'Mombasa'
row = [
str(ballot.number),
center.code,
str(station.station_number),
self.gender,
self.name,
office_name,
self.empty_string,
self.barcode,
self.serial_number]
with self.assertLogs(logger=self.logger, level='WARNING') as cm:
process_results_form_row(tally=self.tally,
row=row,
logger=self.logger)
self.assertIn(str('WARNING:%s:Office "%s" does not exist') %
(self.logger.name, office_name), cm.output)
def test_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_new_form_post(self):
# save clearance as clerk
self._create_and_login_user()
self._add_user_to_group(self.user, groups.CLEARANCE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(tally=tally)
station = create_station(center)
office = create_office(tally=tally)
result_form = create_result_form(form_state=FormState.CLEARANCE,
force_ballot=False,
tally=tally,
gender=Gender.MALE)
ballot = create_ballot(tally=tally)
view = CreateResultFormView.as_view(clearance_result_form=True)
data = {
'result_form': result_form.pk,
'gender': [u'0'],
'ballot': [ballot.pk],
'center': [center.pk],
'office': [office.pk],
'tally_id': tally.id,
'station_number': station.station_number,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request, tally_id=tally.pk)
result_form.reload()
self.assertEqual(response.status_code, 200)
self.assertEqual(result_form.gender, Gender.MALE)
def test_create_result_form_valid(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
barcode = '12345'
ballot = create_ballot(tally=tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(code, tally=tally, sub_constituency=sc)
station = create_station(center)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': barcode,
'created_user': self.request.user.userprofile,
'gender': 1
}
form = CreateResultForm(form_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.instance.barcode, barcode)
form.save()
self.assertEqual(
ResultForm.objects.get(id=form.instance.id).barcode, barcode)
def test_forms_for_race(self):
ballot = create_ballot()
view = views.FormsForRaceView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, ballot=ballot.number)
self.assertContains(response, "Forms for Race %s" % ballot.number)
def test_edit_race_view_get(self):
tally = create_tally()
tally.users.add(self.user)
ballot = create_ballot(tally)
view = views.EditRaceView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, id=ballot.pk, tally_id=tally.pk)
self.assertContains(response, 'Edit Race')
self.assertContains(response, 'value="%s"' % ballot.number)
def test_forms_for_race(self):
tally = create_tally()
tally.users.add(self.user)
ballot = create_ballot(tally=tally)
view = views.FormsForRaceView.as_view()
request = self.factory.get('/')
request.user = self.user
response = view(request, ballot=ballot.number, tally_id=tally.pk)
self.assertContains(response, "Forms for Race %s" % ballot.number)
self.assertNotContains(response, "New Form")
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_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_process_results_form_row_post(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
row = [
str(ballot.number), center.code,
str(station.station_number), self.gender, self.name,
self.office_name, self.empty_string, self.barcode,
self.serial_number
]
process_results_form_row(tally=self.tally, row=row, logger=self.logger)
form = ResultForm.objects.get(barcode=self.barcode, tally=self.tally)
self.assertEqual(form.barcode, self.barcode)
def test_center_check_no_result_form_assigned_to_center_station(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(code='11111', tally=tally)
station = create_station(center)
ballot = create_ballot()
barcode = '123456789'
replacement_barcode = '012345678'
create_result_form(
barcode=barcode,
ballot=ballot,
form_state=FormState.ARCHIVED,
center=center,
station_number=station.station_number,
tally=tally,
)
replacement_result_form = create_result_form(
barcode=replacement_barcode,
ballot=ballot,
form_state=FormState.INTAKE,
serial_number=1,
tally=tally,
)
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,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': replacement_result_form.pk}
response = view(request, tally_id=tally.pk)
replacement_result_form.reload()
self.assertEqual(replacement_result_form.form_state,
FormState.CLEARANCE)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/clearance', response['location'])
def test_center_check_no_result_form_assigned_to_center_station(self):
self._create_and_login_user()
self._add_user_to_group(self.user, groups.INTAKE_CLERK)
tally = create_tally()
tally.users.add(self.user)
center = create_center(code='11111', tally=tally)
station = create_station(center)
ballot = create_ballot()
barcode = '123456789'
replacement_barcode = '012345678'
create_result_form(
barcode=barcode,
ballot=ballot,
form_state=FormState.ARCHIVED,
center=center,
station_number=station.station_number,
tally=tally,
)
replacement_result_form = create_result_form(
barcode=replacement_barcode,
ballot=ballot,
form_state=FormState.INTAKE,
serial_number=1,
tally=tally,
)
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,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': replacement_result_form.pk}
response = view(request, tally_id=tally.pk)
replacement_result_form.reload()
self.assertEqual(replacement_result_form.form_state,
FormState.CLEARANCE)
self.assertEqual(response.status_code, 302)
self.assertIn('/intake/clearance', response['location'])
def test_edit_result_form_valid(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
ballot = create_ballot(tally=tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(code, tally=tally, sub_constituency=sc)
station = create_station(center)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': 12345,
'gender': 1
}
form = EditResultForm(form_data)
self.assertTrue(form.is_valid())
def test_overview_report_get(self):
for i in xrange(1, 11):
center = create_center()
ballot = create_ballot()
create_result_form(
center=center, ballot=ballot,
station_number=i,
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)
self.assertContains(response, 'Per Office')
self.assertContains(response, 'Tally Center Progress Report')
self.assertContains(response, "<td>Not Received</td>")
def test_process_results_form_row_post(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station = create_station(center)
row = [
str(ballot.number),
center.code,
str(station.station_number),
self.gender,
self.name,
self.office_name,
self.empty_string,
self.barcode,
self.serial_number]
process_results_form_row(tally=self.tally, row=row, logger=self.logger)
form = ResultForm.objects.get(barcode=self.barcode, tally=self.tally)
self.assertEqual(form.barcode, self.barcode)
def test_create_result_form_station_not_active_error(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
center = create_center(code, tally=tally)
ballot = create_ballot(tally=tally)
station = create_station(center, active=False)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': 12345,
'created_user': self.request.user.userprofile,
'gender': 1
}
form = CreateResultForm(form_data)
self.assertIn("Selected station is disabled", form.errors['__all__'])
self.assertFalse(form.is_valid())
def test_process_results_form_row_station_does_not_exist_error(self):
ballot = create_ballot(tally=self.tally)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(self.number,
tally=self.tally,
sub_constituency=sc)
station_number = self.number
row = [
str(ballot.number), center.code,
str(station_number), self.gender, self.name, self.office_name,
self.empty_string, self.barcode, self.serial_number
]
with self.assertLogs(logger=self.logger, level='WARNING') as cm:
process_results_form_row(tally=self.tally,
row=row,
logger=self.logger)
self.assertIn(
str('WARNING:%s:Station "%s" does not exist for center "%s"') %
(self.logger.name, station_number, center.code), cm.output)
def test_edit_result_form_ballot_not_active_error(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
ballot = create_ballot(tally=tally, active=False)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(code, tally=tally, sub_constituency=sc)
station = create_station(center)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': 12345,
'gender': 1
}
form = EditResultForm(form_data)
self.assertIn("Race for ballot is disabled", form.errors['__all__'])
self.assertFalse(form.is_valid())
def test_disable_race_view_post(self):
tally = create_tally()
tally.users.add(self.user)
ballot = create_ballot(tally=tally)
comment_text = 'example comment text'
view = views.DisableRaceView.as_view()
data = {
'race_id_input': ballot.pk,
'comment_input': comment_text,
'tally_id': tally.pk,
'disable_reason': '2',
}
request = self.factory.post('/', data)
request.user = self.user
configure_messages(request)
response = view(request, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
self.assertIn('/data/races-list/%s/' % tally.pk, response['Location'])
ballot.reload()
self.assertEqual(ballot.disable_reason.value, 2)
self.assertEqual(ballot.comments.all()[0].text, comment_text)
def test_create_result_form_station_does_not_exist_error(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
station_number = 1
center = create_center(code, tally=tally)
ballot = create_ballot(tally=tally)
form_data = {
'center': center.pk,
'station_number': station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': 12345,
'created_user': self.request.user.userprofile,
'gender': 1
}
form = CreateResultForm(form_data)
self.assertIn("Station does not exist for the selected center",
form.errors['__all__'])
self.assertFalse(form.is_valid())
def test_auto_delete_document_function(self):
pre_save.disconnect(sender=Ballot, dispatch_uid="ballot_update")
file_size = settings.MAX_FILE_UPLOAD_SIZE
pdf_file_name = "file.pdf"
image_file_name = "image.jpg"
pdf_file = SimpleUploadedFile(
pdf_file_name, bytes(file_size), content_type="application/pdf")
image_file = SimpleUploadedFile(
image_file_name, bytes(file_size), content_type="image/jpeg")
tally = create_tally()
ballot = create_ballot(tally=tally, document=pdf_file)
self.assertIn(pdf_file_name, ballot.document.path)
ballot_instance = Ballot.objects.get(pk=ballot.pk)
ballot_instance.document = image_file
auto_delete_document(Ballot, ballot_instance)
ballot_instance.save()
ballot.refresh_from_db()
self.assertNotIn(pdf_file_name, ballot.document.path)
self.assertIn(image_file_name, ballot.document.path)
shutil.rmtree(os.path.dirname(ballot.document.path))
def setUp(self):
self.center = create_center()
self.center_2 = create_center(code=2, office_name='office2')
self._create_and_login_user()
self.tally = create_tally()
self.tally.users.add(self.user)
self.office = create_office(tally=self.tally)
ballot = create_ballot(tally=self.tally)
for i in range(1, 11):
create_result_form(
center=self.center if i >= 2 else self.center_2,
station_number=i,
tally=self.tally,
barcode=i,
serial_number=i,
office=self.office,
form_state=i - 1,
ballot=ballot)
self.assertEqual(ResultForm.objects.count(), 10)
def test_create_result_form_ballot_number_mis_match_error(self):
tally = create_tally()
tally.users.add(self.user)
code = '12345'
ballot = create_ballot(tally=tally, number=2)
sc, _ = SubConstituency.objects.get_or_create(code=1, field_office='1')
center = create_center(code, tally=tally, sub_constituency=sc)
station = create_station(center)
form_data = {
'center': center.pk,
'station_number': station.station_number,
'tally': tally.pk,
'form_state': 9,
'ballot': ballot.pk,
'barcode': 12345,
'created_user': self.request.user.userprofile,
'gender': 1
}
form = CreateResultForm(form_data)
self.assertIn("Ballot number do not match for center and station",
form.errors['__all__'])
self.assertFalse(form.is_valid())
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_edit_race_view_post(self):
tally = create_tally()
tally.users.add(self.user)
file_size = settings.MAX_FILE_UPLOAD_SIZE
pdf_file_name = "file.pdf"
image_file_name = "image.jpg"
pdf_file = SimpleUploadedFile(pdf_file_name,
bytes(file_size),
content_type="application/pdf")
image_file = SimpleUploadedFile(image_file_name,
bytes(file_size),
content_type="image/jpeg")
ballot = create_ballot(tally, document=pdf_file)
comment_text = 'jndfjs fsgfd'
view = views.EditRaceView.as_view()
data = {
'comment_input': comment_text,
'number': ballot.number,
'race_type': ballot.race_type.value,
'available_for_release': True,
'race_id': ballot.pk,
'tally_id': tally.pk,
'document': image_file,
}
request = self.factory.post('/', data)
request.user = self.user
configure_messages(request)
response = view(request, id=ballot.pk, tally_id=tally.pk)
self.assertEqual(response.status_code, 302)
ballot.reload()
ballot.refresh_from_db()
# testing auto_delete_document signal was called
self.assertNotIn(pdf_file_name, ballot.document.path)
self.assertIn(image_file_name, ballot.document.path)
self.assertEqual(ballot.available_for_release, True)
self.assertEqual(ballot.comments.first().text, comment_text)
shutil.rmtree(os.path.dirname(ballot.document.path))
def test_new_form_post(self):
# save clearance as clerk
result_form = create_result_form(
form_state=FormState.CLEARANCE,
force_ballot=False,
gender=None)
ballot = create_ballot()
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'],
'ballot': [ballot.pk]}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': result_form.pk}
response = view(request)
result_form.reload()
self.assertEqual(response.status_code, 302)
self.assertEqual(result_form.created_user, self.request.user)
self.assertEqual(result_form.gender, 0)
self.assertIn('clearance', response['location'])
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)
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_center_check_replaced_result_form_sent_to_clearance(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center(code='11111', tally=tally)
station = create_station(center)
ballot = create_ballot(tally=tally)
barcode = '123456789'
replacement_barcode = '012345678'
create_result_form(
barcode=barcode,
ballot=ballot,
form_state=FormState.DATA_ENTRY_1,
center=center,
station_number=station.station_number,
tally=tally,
)
replacement_result_form = create_result_form(
barcode=replacement_barcode,
ballot=ballot,
form_state=FormState.INTAKE,
serial_number=1,
tally=tally,
)
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,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': replacement_result_form.pk}
response = view(request, tally_id=tally.pk)
replacement_result_form.reload()
duplicated_forms = replacement_result_form.get_duplicated_forms()
for oneDuplicateForm in duplicated_forms:
if oneDuplicateForm.pk == 1:
self.assertEqual(oneDuplicateForm.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(oneDuplicateForm.form_state,
FormState.CLEARANCE)
self.assertEqual(response.status_code, 302)
self.assertEqual(replacement_result_form.previous_form_state,
FormState.INTAKE)
self.assertEqual(replacement_result_form.form_state,
FormState.CLEARANCE)
self.assertEqual(replacement_result_form.station_number,
station.station_number)
self.assertEqual(replacement_result_form.center, center)
self.assertIn(
reverse('intake-clearance', kwargs={'tally_id': tally.pk}),
response['location'])
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, 200)
result_form = ResultForm.objects.get(barcode=barcode)
duplicated_forms = result_form.get_duplicated_forms()
for oneDuplicateForm in duplicated_forms:
if oneDuplicateForm.pk == 1:
self.assertEqual(oneDuplicateForm.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(oneDuplicateForm.form_state,
FormState.CLEARANCE)
self.assertEqual(result_form.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
def test_center_check_replaced_result_form_sent_to_clearance(self):
self._create_and_login_user()
tally = create_tally()
tally.users.add(self.user)
center = create_center(code='11111', tally=tally)
station = create_station(center)
ballot = create_ballot(tally=tally)
barcode = '123456789'
replacement_barcode = '012345678'
create_result_form(
barcode=barcode,
ballot=ballot,
form_state=FormState.DATA_ENTRY_1,
center=center,
station_number=station.station_number,
tally=tally,
)
replacement_result_form = create_result_form(
barcode=replacement_barcode,
ballot=ballot,
form_state=FormState.INTAKE,
serial_number=1,
tally=tally,
)
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,
'tally_id': tally.pk,
}
request = self.factory.post('/', data=data)
request.user = self.user
request.session = {'result_form': replacement_result_form.pk}
response = view(request, tally_id=tally.pk)
replacement_result_form.reload()
duplicated_forms = replacement_result_form.get_duplicated_forms()
for oneDuplicateForm in duplicated_forms:
if oneDuplicateForm.pk == 1:
self.assertEqual(
oneDuplicateForm.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(
oneDuplicateForm.form_state,
FormState.CLEARANCE)
self.assertEqual(response.status_code, 302)
self.assertEqual(replacement_result_form.previous_form_state,
FormState.INTAKE)
self.assertEqual(replacement_result_form.form_state,
FormState.CLEARANCE)
self.assertEqual(replacement_result_form.station_number,
station.station_number)
self.assertEqual(replacement_result_form.center, center)
self.assertIn(reverse(
'intake-clearance', kwargs={'tally_id': tally.pk}),
response['location'])
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, 200)
result_form = ResultForm.objects.get(barcode=barcode)
duplicated_forms = result_form.get_duplicated_forms()
for oneDuplicateForm in duplicated_forms:
if oneDuplicateForm.pk == 1:
self.assertEqual(
oneDuplicateForm.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(
oneDuplicateForm.form_state,
FormState.CLEARANCE)
self.assertEqual(result_form.previous_form_state,
FormState.DATA_ENTRY_1)
self.assertEqual(result_form.form_state, FormState.CLEARANCE)
