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}