예제 #1
0
 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))
예제 #2
0
 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))
예제 #3
0
 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())
예제 #4
0
 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)
예제 #5
0
 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())
예제 #6
0
 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)
예제 #7
0
    def setUp(self):
        # these should be blocked during the changeset
        self.citizen1 = CitizenFactory()
        self.citizen2 = CitizenFactory()
        # citizen3 already blocked
        self.citizen3 = CitizenFactory()
        self.citizen3.block()
        # citizen4 won't be included
        self.citizen4 = CitizenFactory()

        self.changeset = ChangesetFactory(
            status=Changeset.STATUS_APPROVED,
            change=Changeset.CHANGE_BLOCK,
        )
예제 #8
0
 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)
예제 #9
0
 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))
예제 #10
0
 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())
예제 #11
0
 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())
예제 #12
0
 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)
예제 #13
0
 def setUp(self):
     self.number = "919-999-9999"
     self.center = RegistrationCenterFactory()
     self.conn = self.create_connection(data={'identity': self.number})
     self.citizen = CitizenFactory()
     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.good_center_id = self.center.center_id
     self.bad_center_id = get_random_number_string(
         length=constants.CENTER_ID_LENGTH)
     self.long_center_id = get_random_number_string(
         length=constants.CENTER_ID_LENGTH + 1)
     self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
     RegistrationPeriodFactory(start_time=PAST_DAY, end_time=FUTURE_DAY)
예제 #14
0
    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())
예제 #15
0
 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')
예제 #16
0
    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]))
예제 #17
0
 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)
예제 #18
0
 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)
예제 #19
0
 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)
예제 #20
0
 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()
예제 #21
0
 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)
예제 #22
0
 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)
예제 #23
0
    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)
예제 #24
0
 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())
예제 #25
0
 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)
예제 #26
0
 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)
예제 #27
0
 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))
예제 #28
0
 def test_temp_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())
     self.assertFalse(TempCitizen.objects.exists())
     with patch('civil_registry.utils.delete_all'):
         with patch('civil_registry.utils.mirror_database') as mirror_database:
             mirror_database.return_value = MirrorStats()
             stats = import_citizen_dump(input_filename=None)
     # We mocked mirror_database, so nothing actually got copied to Citizen
     # but it should have "read" the data into TempCitizen, and we
     # mocked delete_all, so it should still be there.
     self.assertFalse(Citizen.objects.exists())
     self.assertEqual(1, stats.records_read)
     mirror_database.assert_called()
     temp_cit = TempCitizen.objects.get()
     self.assertEqual(data, model_to_dict(temp_cit))
예제 #29
0
 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)
예제 #30
0
 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)
예제 #31
0
 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)
예제 #32
0
 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)
예제 #33
0
 def test_temp_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())
     self.assertFalse(TempCitizen.objects.exists())
     with patch('civil_registry.utils.delete_all'):
         with patch(
                 'civil_registry.utils.mirror_database') as mirror_database:
             mirror_database.return_value = MirrorStats()
             stats = import_citizen_dump(input_filename=None)
     # We mocked mirror_database, so nothing actually got copied to Citizen
     # but it should have "read" the data into TempCitizen, and we
     # mocked delete_all, so it should still be there.
     self.assertFalse(Citizen.objects.exists())
     self.assertEqual(1, stats.records_read)
     mirror_database.assert_called()
     temp_cit = TempCitizen.objects.get()
     self.assertEqual(data, model_to_dict(temp_cit))
예제 #34
0
 def setUp(self):
     self.number = "919-999-9999"
     self.center = RegistrationCenterFactory()
     self.conn = self.create_connection(data={'identity': self.number})
     self.citizen = CitizenFactory()
     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.good_center_id = self.center.center_id
     self.bad_center_id = get_random_number_string(length=constants.CENTER_ID_LENGTH)
     self.long_center_id = get_random_number_string(length=constants.CENTER_ID_LENGTH + 1)
     self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
     RegistrationPeriodFactory(start_time=PAST_DAY, end_time=FUTURE_DAY)
예제 #35
0
class ResponseTest(TranslationTest, LibyaRapidTest):
    # Test response messages (Arabic)

    def setUp(self):
        self.number = "919-999-9999"
        self.center = RegistrationCenterFactory()
        self.conn = self.create_connection(data={'identity': self.number})
        self.citizen = CitizenFactory()
        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.good_center_id = self.center.center_id
        self.bad_center_id = get_random_number_string(length=constants.CENTER_ID_LENGTH)
        self.long_center_id = get_random_number_string(length=constants.CENTER_ID_LENGTH + 1)
        self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
        RegistrationPeriodFactory(start_time=PAST_DAY, end_time=FUTURE_DAY)

    def test_garbage(self, registration_open):
        self.receive("PING", self.conn, fields=self.fields)
        expected = self.translate(constants.MESSAGE_INCORRECT)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_garbage_enhanced(self, registration_open):
        for i in range(1, 5):
            # last iteration should get an enhanced message
            self.receive("PING", self.conn, fields=self.fields)
        expected = self.translate(constants.MESSAGE_INCORRECT, enhanced=True)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_wrong_length_nid(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.short_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_NID_WRONG_LENGTH)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_wrong_length_nid_enhanced(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.short_nid, center=self.good_center_id)
        for i in range(1, 5):
            # last iteration should get an enhanced message
            self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_NID_WRONG_LENGTH, enhanced=True)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_wrong_length_center_id(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.long_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_CENTER_ID_WRONG_LENGTH)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_wrong_length_center_id_enhanced(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.long_center_id)
        for i in range(1, 5):
            # last iteration should get an enhanced message
            self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_CENTER_ID_WRONG_LENGTH, enhanced=True)
        self.assertEqual(self.get_last_response_message(), expected)

    def test_wrong_length_nid_query(self, registration_open):
        msg = "{nid}".format(nid=self.short_nid)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.VOTER_QUERY_NID_WRONG_LENGTH)
        self.assertEqual(self.get_last_response_message(), expected)

    def test_citizen_under_18(self, registration_open):
        self.citizen.birth_date = datetime.datetime.today()
        self.citizen.save()
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_NID_INVALID)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_center_does_not_exist(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.bad_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_CENTER_ID_INVALID)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_nid_does_not_exist(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.bad_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        expected = self.translate(constants.RESPONSE_NID_INVALID)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_good_registration(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)
        context = {'person': unicode(self.citizen), 'centre': self.center.name,
                   'code': self.center.center_id}
        expected = self.translate(constants.MESSAGE_1, context=context)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_good_registration_enhanced(self, registration_open):
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.good_center_id)
        for i in range(1, 5):
            # last iteration should get an enhanced message
            self.receive(msg, self.conn, fields=self.fields)
        context = {'person': unicode(self.citizen), 'centre': self.center.name,
                   'code': self.center.center_id}
        expected = self.translate(constants.MESSAGE_1, context=context, enhanced=True)  # arabic
        self.assertEqual(self.get_last_response_code(), constants.MESSAGE_1)
        self.assertEqual(self.get_last_response_message(), expected)

    def test_good_update(self, registration_open):
        new_center = RegistrationCenterFactory()
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)  # registers
        msg = "{nid}#{center}".format(nid=self.good_nid, center=new_center.center_id)
        self.receive(msg, self.conn, fields=self.fields)  # updates
        context = {'person': unicode(self.citizen), 'centre': new_center.name,
                   'code': new_center.center_id}
        # 1st update - message 1
        expected = self.translate(constants.MESSAGE_1, context=context)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

        # 2nd update - message 4
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.good_center_id)
        self.receive(msg, self.conn, fields=self.fields)  # updates again
        context = {'person': unicode(self.citizen), 'centre': new_center.name,
                   'code': self.good_center_id}
        expected = self.translate(constants.MESSAGE_4, context=context)  # arabic

        # 3rd and final update - message 5
        msg = "{nid}#{center}".format(nid=self.good_nid, center=new_center.center_id)
        self.receive(msg, self.conn, fields=self.fields)  # updates
        context = {'person': unicode(self.citizen), 'centre': new_center.name,
                   'code': new_center.center_id}
        expected = self.translate(constants.MESSAGE_5, context=context)  # arabic

    def test_attempt_update_wrong_from_number(self, registration_open):
        # create a valid registration
        sms = SMSFactory(from_number=self.number, citizen=self.citizen)
        RegistrationFactory(
            citizen=self.citizen,
            registration_center=self.center,
            archive_time=None,
            sms=sms)
        # try to register at a new center with a new number
        new_center = RegistrationCenterFactory()
        new_number = '919-888-8888'
        msg = "{nid}#{center}".format(nid=self.good_nid, center=new_center.center_id)
        new_conn = self.create_connection(data={'identity': new_number})
        self.receive(msg, new_conn, fields=self.fields)
        # message should have the existing number in it (not new_number)
        context = {'centre': self.center.name,
                   'number': self.number[-4:]}
        expected = self.translate(constants.MESSAGE_2, context=context)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)

    def test_attempt_update_wrong_from_number_same_center(self, registration_open):
        # create a valid registration
        sms = SMSFactory(from_number=self.number, citizen=self.citizen)
        RegistrationFactory(
            citizen=self.citizen,
            registration_center=self.center,
            archive_time=None,
            sms=sms)
        # try to register at same center with a new number
        new_number = '919-888-8888'
        msg = "{nid}#{center}".format(nid=self.good_nid, center=self.center.center_id)
        new_conn = self.create_connection(data={'identity': new_number})
        self.receive(msg, new_conn, fields=self.fields)
        # message should have the existing number in it (not new_number)
        context = {'centre': self.center.name,
                   'number': self.number[-4:]}
        expected = self.translate(constants.MESSAGE_2, context=context)  # arabic
        self.assertEqual(self.get_last_response_message(), expected)
예제 #36
0
class ExecuteUnblockTest(TestCase):
    """
    Test executeing unblocking changesets.

    Each test will set up a change in a different way but that ought to have the same
    results. Then we'll try to roll back the change, after changing one voter, and check
    those results.
    """
    def setUp(self):
        # these should be unblocked during the changeset
        self.citizen1 = CitizenFactory()
        self.citizen1.block()
        self.citizen2 = CitizenFactory()
        self.citizen2.block()
        # citizen3 already unblocked
        self.citizen3 = CitizenFactory()
        # citizen4 won't be included
        self.citizen4 = CitizenFactory()
        self.citizen4.block()

        self.changeset = ChangesetFactory(
            status=Changeset.STATUS_APPROVED,
            change=Changeset.CHANGE_UNBLOCK,
        )

    def doit(self):
        self.changeset.full_clean()
        citizens = list(self.changeset.get_citizens_to_change())
        self.assertIn(self.citizen1, citizens)
        self.assertIn(self.citizen2, citizens)
        self.assertIn(self.citizen3, citizens)  # In the list, but will not be changed
        self.assertNotIn(self.citizen4, citizens)

        self.changeset.execute()
        self.citizen1 = refresh_model(self.citizen1)
        self.citizen2 = refresh_model(self.citizen2)
        self.citizen3 = refresh_model(self.citizen3)
        self.citizen4 = refresh_model(self.citizen4)
        self.assertFalse(self.citizen1.blocked)
        self.assertFalse(self.citizen2.blocked)
        self.assertFalse(self.citizen3.blocked)
        self.assertTrue(self.citizen4.blocked)

        changes = self.changeset.change_records.all()
        self.assertTrue(changes.filter(citizen=self.citizen1, changed=True).exists())
        self.assertTrue(changes.filter(citizen=self.citizen2, changed=True).exists())
        self.assertTrue(changes.filter(citizen=self.citizen3, changed=False).exists())
        self.assertFalse(changes.filter(citizen=self.citizen4).exists())

        self.assertEqual(Changeset.STATUS_PARTIALLY_SUCCESSFUL, self.changeset.status)

        # Now block citizen 2
        self.citizen2.block()

        rollback = ChangesetFactory(
            status=Changeset.STATUS_APPROVED,
            change=Changeset.CHANGE_ROLLBACK,
            how_to_select=Changeset.SELECT_OTHER_CHANGESET,
            other_changeset=self.changeset,
        )
        citizens = list(rollback.get_citizens_to_change())
        self.assertIn(self.citizen1, citizens)
        self.assertIn(self.citizen2, citizens)
        self.assertNotIn(self.citizen3, citizens)  # not changed before, so not in list this time
        self.assertNotIn(self.citizen4, citizens)

        rollback.execute()
        self.changeset = refresh_model(self.changeset)
        self.assertEqual(Changeset.STATUS_ROLLED_BACK, self.changeset.status)

        self.citizen1 = refresh_model(self.citizen1)
        self.citizen2 = refresh_model(self.citizen2)
        self.citizen3 = refresh_model(self.citizen3)
        self.citizen4 = refresh_model(self.citizen4)
        self.assertTrue(self.citizen1.blocked)
        self.assertTrue(self.citizen2.blocked)
        self.assertFalse(self.citizen3.blocked)
        self.assertTrue(self.citizen4.blocked)

        changes = rollback.change_records.all()
        self.assertTrue(changes.filter(citizen=self.citizen1, changed=True).exists())
        self.assertTrue(changes.filter(citizen=self.citizen2, changed=False).exists())
        # reg 3 not in the list because they were changed previously
        self.assertFalse(changes.filter(citizen=self.citizen3).exists())
        self.assertFalse(changes.filter(citizen=self.citizen4).exists())
        self.assertEqual(Changeset.STATUS_PARTIALLY_SUCCESSFUL, rollback.status)

    def test_unblock_by_uploaded_citizens(self):
        self.changeset.how_to_select = Changeset.SELECT_UPLOADED_NIDS
        self.changeset.save()
        self.changeset.selected_citizens.add(self.citizen1, self.citizen2, self.citizen3)
        self.doit()

    def test_unblock_by_selected_centers(self):
        center1 = RegistrationCenterFactory()
        center2 = RegistrationCenterFactory()
        RegistrationCenterFactory()
        RegistrationFactory(citizen=self.citizen1, registration_center=center1,
                            archive_time=None)
        RegistrationFactory(citizen=self.citizen2, registration_center=center1,
                            archive_time=None)
        RegistrationFactory(citizen=self.citizen3, registration_center=center2,
                            archive_time=None)
        self.changeset.how_to_select = Changeset.SELECT_CENTERS
        self.changeset.save()
        self.changeset.selected_centers.add(center1, center2)
        self.doit()

    def test_unblock_by_other_changeset(self):
        other = ChangesetFactory(status=Changeset.STATUS_SUCCESSFUL)
        self.changeset.how_to_select = Changeset.SELECT_OTHER_CHANGESET
        self.changeset.other_changeset = other
        self.changeset.save()
        ChangeRecordFactory(citizen=self.citizen1, changeset=other, changed=True)
        ChangeRecordFactory(citizen=self.citizen2, changeset=other, changed=True)
        ChangeRecordFactory(citizen=self.citizen3, changeset=other, changed=True)
        ChangeRecordFactory(citizen=self.citizen4, changeset=other, changed=False)
        self.doit()
예제 #37
0
 def test_block_citizen(self):
     citizen = CitizenFactory()
     RegistrationFactory(citizen=citizen, archive_time=None)
     self.assertIsNotNone(citizen.registration)
     citizen.block()
     self.assertIsNone(citizen.registration)