def test_get_citizens_to_change_by_upload(self):
changeset = ChangesetFactory(
how_to_select=Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
citizen3 = CitizenFactory()
changeset.selected_citizens.add(citizen1, citizen2)
self.assertIn(citizen1, changeset.get_citizens_to_change())
self.assertIn(citizen2, changeset.get_citizens_to_change())
self.assertNotIn(citizen3, changeset.get_citizens_to_change())
def test_upload_file_invalid_line(self):
# We notice a file with too short a line
data = self.data
data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
filetext = "1{nid1}\n{nid2}\n".format(nid1=citizen1.national_id, nid2=citizen2.national_id)
upload_file = SimpleUploadedFile('my_filename', filetext)
form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
self.assertFalse(form.is_valid())
self.assertIn('upload_file', form.errors)
def test_upload_file_invalid_nid(self):
# We catch invalid NIDs in the upload file
data = self.data
data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
nid1 = str(citizen1.national_id)
nid1 = '3' + nid1[1:]
filetext = "{nid1}\n{nid2}\n".format(nid1=nid1, nid2=citizen2.national_id)
upload_file = SimpleUploadedFile('my_filename', filetext)
form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
self.assertFalse(form.is_valid())
self.assertIn('upload_file', form.errors)
def test_record_gone_do_not_delete_with_existing(self):
existing = CitizenFactory(pk=1)
TempCitizenFactory(pk=1, **model_to_dict(existing))
cit = CitizenFactory(pk=2)
existing2 = CitizenFactory(pk=3)
TempCitizenFactory(pk=3, **model_to_dict(existing2))
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(2, stats.unchanged_count)
self.assertEqual(0, stats.modified_record_count)
self.assertEqual(0, stats.new_record_count)
self.assertEqual(1, stats.not_there_anymore_count)
# NOT deleted
self.assertTrue(Citizen.objects.filter(pk=cit.pk).exists())
def test_upload_file_no_such_citizen(self):
# We catch non-existent citizens in the upload file
data = self.data
data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
filetext = "{nid1}\n{nid2}\n".format(nid1=citizen1.national_id + 27,
nid2=citizen2.national_id)
upload_file = SimpleUploadedFile('my_filename', filetext)
with patch('changesets.forms.get_citizen_by_national_id') as mock_get_citizen:
mock_get_citizen.return_value = None # No such citizen
form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
self.assertFalse(form.is_valid())
self.assertIn('upload_file', form.errors)
def test_upload_file(self):
# We can successfully upload a file of NIDs and look up the citizens
# and blank lines are okay
data = self.data
data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
citizen1 = CitizenFactory()
citizen2 = CitizenFactory()
filetext = "{nid1}\n\n{nid2}\n".format(nid1=citizen1.national_id, nid2=citizen2.national_id)
upload_file = SimpleUploadedFile('my_filename', filetext)
mock_request = MagicMock(user=UserFactory())
form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=mock_request)
self.assertTrue(form.is_valid(), msg=str(form.errors))
changeset = form.save()
self.assertIn(citizen1, changeset.selected_citizens.all())
self.assertIn(citizen2, changeset.selected_citizens.all())
def test_citizen_updated(self, get_records, open):
cit1 = CitizenFactory()
cit2 = CitizenFactory()
citizen = CitizenFactory()
data = model_to_dict(citizen)
new_name = 'Jim Bob'
data['first_name'] = new_name
get_records.return_value = [
model_to_dict(cit1),
model_to_dict(cit2), data
]
stats = import_citizen_dump(input_filename=None, max_change_percent=34)
self.assertEqual(3, stats.records_read)
updated_cit = Citizen.objects.get(pk=citizen.pk)
self.assertEqual(new_name, updated_cit.first_name)
def test_new_record_with_existing(self):
nid = 100000000000
existing = CitizenFactory(pk=1, national_id=nid)
TempCitizenFactory(pk=1, **model_to_dict(existing))
nid += 1
cit = TempCitizenFactory(pk=2, national_id=nid)
nid += 1
existing2 = CitizenFactory(pk=3, national_id=nid)
TempCitizenFactory(pk=3, **model_to_dict(existing2))
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(2, stats.unchanged_count)
self.assertEqual(0, stats.modified_record_count)
self.assertEqual(1, stats.new_record_count)
self.assertEqual(0, stats.not_there_anymore_count)
self.assertTrue(Citizen.objects.filter(pk=cit.pk).exists())
def test_case_detail_view(self):
citizen = CitizenFactory(family_name='Doe', first_name='John') # factory
case = CaseFactory(citizen=citizen)
rsp = self.client.get(reverse('case_detail', kwargs={'pk': case.pk}), follow=False)
if rsp.status_code == 302:
self.fail("Redirected to %s" % rsp['Location'])
self.assertContains(rsp, 'John')
def test_can_repeat_reg(self):
# User can send multiple messages from the same phone number for the
# same voting center.
citizen = CitizenFactory()
center1 = RegistrationCenterFactory()
# Message #1 - original registration
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(center1, reg.registration_center)
self.assertEqual(constants.RESPONSE_VALID_REGISTRATION,
self.get_last_response_code())
# Repeat - message 2
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
# Citizen should be registered
reg = models.Registration.objects.get(citizen=citizen)
self.assertEqual(center1, reg.registration_center)
# Repeated reg
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
self.receive("%s %s" % (citizen.national_id, center1.center_id),
self.conn,
fields=self.fields)
self.assertEqual(constants.MESSAGE_1, self.get_last_response_code())
def test_view_view(self):
self.center2 = RegistrationCenterFactory(name='Centra Dua')
changeset = ChangesetFactory(
name='My Changeset',
change=Changeset.CHANGE_CENTER,
how_to_select=Changeset.SELECT_UPLOADED_NIDS,
target_center=self.center2,
justification='Just because',
)
per_page = UploadedCitizenBrowse.paginate_by
self.assertIsNotNone(per_page)
citizens = [CitizenFactory() for i in range(per_page + 2)]
changeset.selected_citizens.add(*citizens)
citizens = sorted(citizens, key=attrgetter('national_id'))
# Get citizens affected by this changeset, sorted ascending by national ID
url = reverse(
'browse_uploadedcitizens') + "?changeset=%s&o=0" % changeset.pk
rsp = self.client.get(url)
self.assertEqual(OK, rsp.status_code)
context = rsp.context
object_list = context['object_list']
self.assertLessEqual(len(object_list), per_page)
# Should be on first page
self.assertContains(rsp, citizens[0].national_id)
self.assertContains(rsp, str(citizens[0]))
# Last citizen ought to be on the next page
self.assertNotContains(rsp, citizens[-1].national_id)
self.assertNotContains(rsp, str(citizens[-1]))
def test_missing_captcha_causes_failure(self):
CitizenFactory(national_id=123456789012, fbr_number=1234)
data = {'national_id': '123456789012', 'fbr_number': '1234'}
# no captcha, so skip the call -> data.update(self.captcha)
rsp = self.client.post(self.url, data=data)
errors = rsp.context['form'].errors
self.assertTrue(errors)
self.assertTrue('captcha' in errors)
def setUp(self):
self.citizen = CitizenFactory()
self.good_nid = self.citizen.national_id
self.bad_nid = long(
get_random_number_string(length=constants.NID_LENGTH))
self.nid_without_citizen = long(
get_random_number_string(length=constants.NID_LENGTH))
self.sms = SMSFactory()
def test_not_born_yet(self):
tomorrow = (now() + timedelta(hours=24)).date()
citizen = CitizenFactory(birth_date=tomorrow)
data = model_to_dict(citizen)
data = stringize(data)
form = CitizenRecordForm(data)
self.assertFalse(form.is_valid())
self.assertIn('birth_date', form.errors)
def test_is_eligible_blocked(self):
# Blocked citizen is not eligible
TODAY = datetime.datetime(2000, 6, 2)
citizen = CitizenFactory(birth_date=datetime.date(1982, 6, 1))
self.assertTrue(citizen.is_eligible(as_of=TODAY))
citizen.block()
citizen.save()
self.assertFalse(citizen.is_eligible(as_of=TODAY))
def test_too_many_changes(self, get_records, open):
cit1 = CitizenFactory()
cit2 = CitizenFactory()
citizen = CitizenFactory()
data = model_to_dict(citizen)
new_name = 'Jim Bob'
data['first_name'] = new_name
get_records.return_value = [
model_to_dict(cit1),
model_to_dict(cit2), data
]
# Import raises an exception:
with self.assertRaises(TooManyChanges):
import_citizen_dump(input_filename=None, max_change_percent=10)
# Citizen is unchanged:
new_citizen = refresh_model(citizen)
self.assertEqual(citizen.first_name, new_citizen.first_name)
def test_record_gone_do_not_delete(self):
cit = CitizenFactory()
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(0, stats.unchanged_count)
self.assertEqual(0, stats.modified_record_count)
self.assertEqual(0, stats.new_record_count)
self.assertEqual(1, stats.not_there_anymore_count)
# NOT deleted
self.assertTrue(Citizen.objects.filter(pk=cit.pk).exists())
def test_unchanged_record(self):
cit = CitizenFactory()
TempCitizenFactory(**model_to_dict(cit))
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(1, stats.unchanged_count)
self.assertEqual(0, stats.modified_record_count)
self.assertEqual(0, stats.new_record_count)
self.assertEqual(0, stats.not_there_anymore_count)
def setUp(self):
self.sms = SMSFactory()
self.citizen = CitizenFactory(national_id=219782058018)
self.center = RegistrationCenterFactory()
RegistrationCenterFactory(center_id=self.center.center_id,
deleted=True)
self.mock_response = Mock()
self.reg_period = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=FUTURE_DAY)
def test_new_citizen(self):
CitizenFactory(national_id=123456789012, fbr_number=1234)
data = {'national_id': '123456789012', 'fbr_number': '1234'}
data.update(self.captcha)
rsp = self.client.post(self.url, data=data)
self.assertEqual(200, rsp.status_code)
context = rsp.context
self.assertIn('citizen', context)
self.assertNotIn('center', context)
def test_changed_record_with_existing(self):
nid = 100000000000
existing = CitizenFactory(pk=1, national_id=nid)
nid += 1
TempCitizenFactory(pk=existing.pk, **model_to_dict(existing))
nid += 1
cit = CitizenFactory(pk=2, national_id=nid)
temp_cit = TempCitizenFactory(pk=cit.pk,
national_id=nid,
first_name=cit.first_name + '_CHANGED')
existing2 = CitizenFactory(pk=3)
TempCitizenFactory(pk=existing2.pk, **model_to_dict(existing2))
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(2, stats.unchanged_count)
self.assertEqual(1, stats.modified_record_count)
self.assertEqual(0, stats.new_record_count)
self.assertEqual(0, stats.not_there_anymore_count)
c = Citizen.objects.get(pk=cit.pk)
self.assertEqual(temp_cit.first_name, c.first_name)
def test_unique_registration(self):
# Undeleted, confirmed registrations must be unique on citizen
citizen = CitizenFactory()
RegistrationFactory(citizen=citizen, deleted=False, archive_time=None)
RegistrationFactory(citizen=citizen, deleted=True)
RegistrationFactory(citizen=citizen, archive_time=now())
with self.assertRaises(IntegrityError):
RegistrationFactory(citizen=citizen,
deleted=False,
archive_time=None)
def test_case_list_number(self):
citizen = CitizenFactory(family_name='Doe', first_name='John') # factory
target = CaseFactory(citizen=citizen)
for i in range(4):
# 4 more
CaseFactory()
rsp = self.client.get(reverse('report_cases') + "?q=%d" % target.citizen.national_id)
self.assertEqual(1, len(rsp.context['object_list']))
obj = rsp.context['object_list'][0]
self.assertEqual(target, obj)
def test_citizen_created(self, get_records, open):
citizen = CitizenFactory()
data = model_to_dict(citizen)
citizen.delete()
get_records.return_value = [data]
self.assertFalse(Citizen.objects.exists())
stats = import_citizen_dump(input_filename=None)
self.assertEqual(1, stats.records_read)
new_cit = Citizen.objects.get()
self.assertEqual(data, model_to_dict(new_cit))
def test_wrong_gender_for_national_id(self):
citizen = CitizenFactory(
gender=FEMALE,
national_id=123456789012, # expecting male gender
)
data = model_to_dict(citizen)
data = stringize(data)
form = CitizenRecordForm(data)
self.assertFalse(form.is_valid())
self.assertIn("does not match gender", str(form.errors))
def test_citizen_not_registered(self):
# let's query for the registration
citizen2 = CitizenFactory() # unregistered
msg = u"{nid}".format(nid=citizen2.national_id)
self.receive(msg, self.conn, fields=self.fields)
self.assertEqual(self.get_last_response_code(),
constants.VOTER_QUERY_NOT_REGISTERED)
context = {'person': unicode(citizen2)}
expected = self.translate(constants.VOTER_QUERY_NOT_REGISTERED,
context) # Arabic
self.assertEqual(self.get_last_response_message(), expected)
def setUp(self):
self.conn = self.create_connection()
self.fields = {'to_addr': settings.VOTER_QUERY_SHORT_CODE}
self.bad_nid = get_random_number_string(length=constants.NID_LENGTH)
self.bad_length_nid = get_random_number_string(
length=constants.NID_LENGTH + 1)
self.nid_without_person = get_random_number_string(
length=constants.NID_LENGTH)
self.garbage = u"PING"
self.citizen = CitizenFactory()
self.good_nid = unicode(self.citizen.national_id)
def test_changed_record(self):
cit = CitizenFactory()
temp_cit = TempCitizenFactory(pk=cit.pk,
first_name=cit.first_name + '_CHANGED')
stats = mirror_database(from_model=TempCitizen, to_model=Citizen)
self.assertEqual(0, stats.unchanged_count)
self.assertEqual(1, stats.modified_record_count)
self.assertEqual(0, stats.new_record_count)
self.assertEqual(0, stats.not_there_anymore_count)
c = Citizen.objects.get(pk=cit.pk)
self.assertEqual(temp_cit.first_name, c.first_name)
def test_eastern_arabic_in_fbrn(self):
"""
Query site should accept Eastern arabic numerals for FBRN.
"""
CitizenFactory(fbr_number=1234, national_id=123456789012)
data = {'national_id': '١٢٣٤٥٦٧٨٩٠12', 'fbr_number': '١٢34'}
data.update(self.captcha)
rsp = self.client.post(self.url, data=data)
self.assertEqual(200, rsp.status_code)
context = rsp.context
self.assertIn('citizen', context)
def setUp(self):
self.number = get_random_phone_number()
self.center = RegistrationCenterFactory()
self.citizen = CitizenFactory()
self.staffphone = StaffPhone.objects.create(
phone_number=self.number, registration_center=self.center)
self.conn = self.create_connection(data={'identity': self.number})
self.good_nid = self.citizen.national_id
self.bad_nid = get_random_number_string(length=constants.NID_LENGTH)
self.short_nid = get_random_number_string(length=constants.NID_LENGTH -
1)
self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
