def test_query_after_polling(self, mock_lookup):
# after polling is over, voters can still check their registrations
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
self.election.polling_end_time = PAST_DAY
self.election.save()
self.receive(self.msg, self.conn, fields=self.fields)
self.assertTrue(mock_lookup.called)
def setUp(self):
# Create an existing period. Then we'll try creating
# others around it.
self.reg_period = RegistrationPeriodFactory(
start_time=now() - datetime.timedelta(days=1),
end_time=now() + datetime.timedelta(days=1),
)
def test_yesterday_general(self):
today = now()
first_dt = today - datetime.timedelta(7)
input_strings = [(first_dt + datetime.timedelta(delta_days)).strftime('%Y-%m-%d')
for delta_days in range(7)]
# the behavior depends on the current datetime relative to registration end,
# so try it with registration end before and after the current time
reg_period = RegistrationPeriodFactory(start_time=today - datetime.timedelta(days=5),
end_time=today)
for fake_registration_end in [today - datetime.timedelta(days=1),
today + datetime.timedelta(days=1)]:
reg_period.end_time = fake_registration_end
reg_period.save()
if registration_in_progress(as_of=today.date()):
expected_str = input_strings[-2]
else:
expected_str = input_strings[-1]
expected_date = datetime.datetime.strptime(expected_str, '%Y-%m-%d').date()
date_and_string = calc_yesterday(input_strings)
self.assertEqual(date_and_string, (expected_date, expected_str))
# try again, providing the date objects
input_dates = [datetime.datetime.strptime(s, '%Y-%m-%d').date()
for s in input_strings]
date_and_string = calc_yesterday(input_strings, input_dates)
self.assertEqual(date_and_string, (expected_date, expected_str))
def test_two_empty_periods_at_same_time(self):
# Pathological case - two empty periods do not overlap,
# even if they start and end at the same time
RegistrationPeriod.objects.all().delete()
time = now()
RegistrationPeriodFactory(start_time=time, end_time=time)
self.should_work(start_time=time, end_time=time)
def test_query_after_reg_closes(self, mock_lookup):
# after reg closes but before polling is over
self.election.polling_start_time = FUTURE_DAY
self.election.save()
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
mock_lookup.return_value = Result('1', constants.VOTER_QUERY_NOT_FOUND)
self.receive(self.msg, self.conn, fields=self.fields)
self.assertTrue(mock_lookup.called)
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 setUp(self):
self.url = reverse('check_registration')
self.user = UserFactory(username='******', password='******')
self.client.login(username='******', password='******')
# captcha has 2 form fields, _0 is a key, _1 is the text entered by the user
self.captcha = {'captcha_0': 'dummy', 'captcha_1': 'PASSED'}
self.registration = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=PAST_DAY)
self.election = ElectionFactory(polling_start_time=FUTURE_DAY,
polling_end_time=FUTURE_DAY)
def setUp(self):
# lookup_connections takes any identity and creates connections.
# It's better than create_connection because it uses 'mockbackend'
# which keeps track of sent messages.
self.conn = self.lookup_connections(identities=['111'])[0]
self.good_nid = get_random_number_string(length=constants.NID_LENGTH)
self.good_center_id = get_random_number_string(
length=constants.CENTER_ID_LENGTH)
self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
self.reg_period = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=FUTURE_DAY)
self.election = ElectionFactory(polling_start_time=PAST_DAY,
polling_end_time=FUTURE_DAY)
def test_after_election(self, processor):
# can still query registration after election
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
ElectionFactory(polling_start_time=PAST_DAY, polling_end_time=PAST_DAY)
io_table = [
(self.garbage, constants.REGISTRATION_NOT_OPEN),
(unicode(self.bad_nid), constants.VOTER_QUERY_NID_WRONG_LENGTH),
(unicode(self.good_nid), constants.VOTER_QUERY_REGISTERED_AT),
]
result = Mock(message="success",
message_code=constants.VOTER_QUERY_REGISTERED_AT)
processor.return_value = result
for incoming_message, expected_code in io_table:
self.receive(incoming_message, self.conn, fields=self.fields)
self.assertEqual(self.get_last_response_code(), expected_code)
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_after_reopened_reg_period(self):
self.election.polling_end_time = PAST_DAY
self.election.save()
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
self.assertFalse(tool_1_enabled())
self.assertFalse(polling_reports_enabled())
def test_post_polling_reporting_period(self):
self.election.polling_end_time = FIFTEEN_HOURS_AGO
self.election.save()
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
self.assertFalse(tool_1_enabled())
self.assertTrue(polling_reports_enabled())
def test_polling_period(self):
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
self.assertFalse(tool_1_enabled())
self.assertTrue(polling_reports_enabled())
def test_after_registration_before_polling(self):
self.election.polling_start_time = FUTURE_DAY
self.election.save()
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=PAST_DAY)
self.assertFalse(tool_1_enabled())
self.assertFalse(polling_reports_enabled())
def test_query_during_reg(self, mock_lookup):
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=FUTURE_DAY)
mock_lookup.return_value = Result('1', constants.VOTER_QUERY_NOT_FOUND)
self.receive(self.msg, self.conn, fields=self.fields)
self.assertTrue(mock_lookup.called)
def setUp(self):
self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
RegistrationPeriodFactory(start_time=PAST_DAY, end_time=FUTURE_DAY)
def setUp(self):
self.fields = {'to_addr': settings.REGISTRATION_SHORT_CODE}
self.conn = self.create_connection()
self.reg_period = RegistrationPeriodFactory(start_time=PAST_DAY,
end_time=FUTURE_DAY)
def test_query_before_reg_opens(self, mock_lookup):
RegistrationPeriodFactory(start_time=FUTURE_DAY, end_time=FUTURE_DAY)
self.receive(self.msg, self.conn, fields=self.fields)
self.assertTrue(mock_lookup.called)
