def test_reconciliation_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_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/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_corrections_general_post_reject(self):
view = views.CorrectionRequiredView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION)
create_recon_forms(result_form, self.user)
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,
'reject_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.assertEqual(result.active, False)
for recon in updated_result_form.reconciliationform_set.all():
self.assertEqual(recon.active, False)
self.assertEqual(updated_result_form.form_state,
FormState.DATA_ENTRY_1)
def test_corrections_num_results_anomaly_reset_to_data_entry_one(self):
barcode = '123456789'
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, vote2=3)
create_results(result_form, vote1=3, vote2=None)
self._add_user_to_group(self.user, groups.CORRECTIONS_CLERK)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
view = views.CorrectionView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': self.tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
with self.assertRaises(SuspiciousOperation):
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.DATA_ENTRY_1)
def test_corrections_match_pass_to_quality_control(self):
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, 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}
data = {'result_form': result_form.pk,
'pass_to_quality_control': 'true'}
request = self.factory.post('/', data=data)
request.session = session
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
self.assertEqual(
Result.objects.filter(result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
def test_corrections_general_post_reject(self):
view = views.CorrectionRequiredView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
create_recon_forms(result_form, self.user)
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}
candidate_pk = result_form.results.all()[0].candidate.pk
post_data = {
f'candidate_{candidate_pk}': 2,
'result_form': result_form.pk,
'reject_submit': 'reject'
}
request = self.factory.post('/', post_data)
request.session = session
request.user = self.user
response = view(request, tally_id=self.tally.pk)
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.assertEqual(result.active, False)
for recon in updated_result_form.reconciliationform_set.all():
self.assertEqual(recon.active, False)
self.assertEqual(updated_result_form.form_state,
FormState.DATA_ENTRY_1)
def test_corrections_num_results_anomaly_reset_to_data_entry_one(self):
barcode = '123456789'
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, vote2=3)
create_results(result_form, vote1=3, vote2=None)
self._add_user_to_group(self.user, groups.CORRECTIONS_CLERK)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
view = views.CorrectionView.as_view()
barcode_data = {
'barcode': barcode,
'barcode_copy': barcode,
'tally_id': self.tally.pk,
}
request = self.factory.post('/', data=barcode_data)
request.user = self.user
request.session = {}
with self.assertRaises(SuspiciousOperation):
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.DATA_ENTRY_1)
def test_corrections_match_pass_to_quality_control(self):
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, 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}
data = {
'result_form': result_form.pk,
'pass_to_quality_control': 'true',
'tally_id': self.tally.pk,
}
request = self.factory.post('/', data=data)
request.session = session
request.user = self.user
response = view(request, tally_id=self.tally.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
self.assertEqual(
Result.objects.filter(result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
def test_reconciliation_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_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/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_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_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_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_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_recon_get(self):
view = views.CorrectionRequiredView.as_view()
center = create_center()
result_form = create_result_form(form_state=FormState.CORRECTION,
center=center)
create_results(result_form, vote1=2, vote2=3, race_type=RaceType.WOMEN)
create_recon_forms(result_form, self.user)
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}
request = self.factory.get('/')
request.session = session
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Reconciliation')
def test_recon_get(self):
view = views.CorrectionRequiredView.as_view()
center = create_center()
result_form = create_result_form(form_state=FormState.CORRECTION,
center=center)
create_results(result_form, vote1=2, vote2=3, race_type=RaceType.WOMEN)
create_recon_forms(result_form, self.user)
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}
request = self.factory.get('/')
request.session = session
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Reconciliation')
def test_reconciliation_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_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_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)
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_reconciliation_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_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_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)
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_corrections_twice(self):
"""
Checks that results when passed through corrections, and sent to
Quality Control and rejected in QA then new corrections matching
does not create more than one record of active results.
"""
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, 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}
data = {'result_form': result_form.pk,
'pass_to_quality_control': 'true'}
request = self.factory.post('/', data=data)
request.session = session
request.user = self.user
response = view(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
self.assertEqual(
Result.objects.filter(result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
# reject result in QA
updated_result_form.reject()
# reset form to corrections
updated_result_form.form_state = FormState.DATA_ENTRY_2
updated_result_form.save()
updated_result_form.form_state = FormState.CORRECTION
updated_result_form.save()
# none of the results is active
self.assertEqual(
Result.objects.filter(
result_form=result_form, active=True).count(), 0)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 0)
# create new results
create_recon_forms(result_form, self.user)
create_results(updated_result_form, vote1=2, vote2=2)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 5)
self.assertEqual(
Result.objects.filter(
result_form=result_form, active=True).count(), 2)
request.session = {'result_form': result_form.pk}
# pass to quality control
response = view(request)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 6)
self.assertEqual(
Result.objects.filter(
result_form=result_form, active=True).count(), 3)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
def test_corrections_twice(self):
"""
Checks that results when passed through corrections, and sent to
Quality Control and rejected in QA then new corrections matching
does not create more than one record of active results.
"""
view = views.CorrectionMatchView.as_view()
result_form = create_result_form(form_state=FormState.CORRECTION,
tally=self.tally)
create_recon_forms(result_form, self.user)
create_results(result_form, vote1=3, 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}
data = {
'result_form': result_form.pk,
'pass_to_quality_control': 'true',
'tally_id': self.tally.pk,
}
request = self.factory.post('/', data=data)
request.session = session
request.session['encoded_result_form_corrections_start_time'] =\
self.encoded_result_form_corrections_start_time
request.user = self.user
response = view(request, tally_id=self.tally.pk)
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)
self.assertEqual(response.status_code, 302)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 3)
self.assertEqual(
Result.objects.filter(result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
updated_result_form = ResultForm.objects.get(pk=result_form.pk)
self.assertEqual(updated_result_form.form_state,
FormState.QUALITY_CONTROL)
# reject result in QA
updated_result_form.reject()
# reset form to corrections
updated_result_form.form_state = FormState.DATA_ENTRY_2
updated_result_form.save()
updated_result_form.form_state = FormState.CORRECTION
updated_result_form.save()
# none of the results is active
self.assertEqual(
Result.objects.filter(result_form=result_form,
active=True).count(), 0)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 0)
# create new results
create_recon_forms(result_form, self.user)
create_results(updated_result_form, vote1=2, vote2=2)
self.assertEqual(
Result.objects.filter(result_form=result_form).count(), 5)
self.assertEqual(
Result.objects.filter(result_form=result_form,
active=True).count(), 2)
request.session = {'result_form': result_form.pk}
request.session['encoded_result_form_corrections_start_time'] =\
self.encoded_result_form_corrections_start_time
# pass to quality control
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(
Result.objects.filter(result_form=result_form).count(), 6)
self.assertEqual(
Result.objects.filter(result_form=result_form,
active=True).count(), 3)
self.assertEqual(
ReconciliationForm.objects.filter(
active=True,
result_form=result_form,
entry_version=EntryVersion.FINAL).count(), 1)
result_form_stat = ResultFormStats.objects.get(
result_form=updated_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)
