def test_filter_directing_department_null(self):
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
params = {'directing_department': 'null'}
result_ids = self._request_filter_signals(params)
self.assertEqual(1, len(result_ids))
def test_clean_up_reaction_request(self):
# Make sure that the Signals created in setUp() method do not affect
# this test:
status = StatusFactory.create(text='xyz',
state=workflow.BEHANDELING,
_signal=self.signal_reaction_requested)
self.signal_reaction_requested.status = status
self.signal_reaction_requested.save()
with freeze_time(now() -
timedelta(days=2 * REACTION_REQUEST_DAYS_OPEN)):
# Five signals that were in state REACTIE_GEVRAAGD and too old to
# still receive an update.
SignalFactory.create_batch(5,
status__state=workflow.REACTIE_GEVRAAGD)
with freeze_time(now() -
timedelta(days=REACTION_REQUEST_DAYS_OPEN // 2)):
# Five signals that were in state REACTIE_GEVRAAGD and may still
# get an update.
SignalFactory.create_batch(5,
status__state=workflow.REACTIE_GEVRAAGD)
self.assertEqual(Signal.objects.count(), 12)
n_updated = ReactionRequestService.clean_up_reaction_request()
self.assertEqual(n_updated, 5)
reactie_gevraagd = Signal.objects.filter(
status__state=workflow.REACTIE_GEVRAAGD)
reactie_ontvangen = Signal.objects.filter(
status__state=workflow.REACTIE_ONTVANGEN)
self.assertEqual(reactie_gevraagd.count(), 5)
self.assertEqual(reactie_ontvangen.count(), 5)
def test_retrieve_mixed_signals(self):
# A bunch of normal signals that should never be retrieved by this filter
SignalFactory.create_batch(5)
now = timezone.now()
with freeze_time(now - timedelta(hours=1)):
parents_with_changes = SignalFactory.create_batch(3)
parents_without_changes = SignalFactory.create_batch(2)
with freeze_time(now):
for parent_signal in parents_with_changes:
SignalFactory(parent=parent_signal)
for parent_signal in parents_without_changes:
SignalFactory(parent=parent_signal)
with freeze_time(now + timedelta(hours=1)):
for parent_signal in parents_without_changes:
parent_signal.save()
filter_params = {'has_changed_children': True}
ids = self._request_filter_signals(filter_params)
self.assertEqual(len(ids), len(parents_with_changes))
self.assertEqual(
set(ids),
set([parent_signal.id for parent_signal in parents_with_changes]))
filter_params = {'has_changed_children': False}
ids = self._request_filter_signals(filter_params)
self.assertEqual(len(ids), len(parents_without_changes))
self.assertEqual(
set(ids),
set([
parent_signal.id for parent_signal in parents_without_changes
]))
def test_status_data_success(self):
# We need two Signal objects.
SignalFactory.create_batch(2)
response = self.client.get('/status/data')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b'Data OK 2 Signal')
def setUp(self):
self.signal_count = 5
self.created_at = timezone.now() - timezone.timedelta(days=1)
self.point_cityhall = Point(52.367640, 4.899527, srid=4326)
with freeze_time(self.created_at):
SignalFactory.create_batch(size=self.signal_count,
status__state=workflow.GEMELD)
def setUp(self):
with freeze_time(now() - timedelta(days=2 * REACTION_REQUEST_DAYS_OPEN)):
# Five signals that were in state REACTIE_GEVRAAGD and too old to
# still receive an update.
SignalFactory.create_batch(5, status__state=workflow.REACTIE_GEVRAAGD)
with freeze_time(now() - timedelta(days=REACTION_REQUEST_DAYS_OPEN // 2)):
# Five signals that were in state REACTIE_GEVRAAGD and may still
# get an update.
SignalFactory.create_batch(5, status__state=workflow.REACTIE_GEVRAAGD)
def test_signals_open_per_category_signals_filtered(self):
self.client.force_authenticate(user=self.superuser)
self.assertEqual(Signal.objects.count(), 0)
start = timezone.now() - timezone.timedelta(weeks=5)
end = timezone.now() - timezone.timedelta(weeks=3)
response = self.client.get(f'{self.base_endpoint}/signals/open',
data={
'start': start,
'end': end
})
self.assertEqual(response.status_code, 200)
response_data = response.json()
self.assertEqual(response_data['total_signal_count'], 0)
self.assertEqual(len(response_data['results']), 0)
with freeze_time(timezone.now() - timezone.timedelta(weeks=4)):
SignalFactory.create_batch(
5,
status__state=GEMELD,
category_assignment__category=self.category_1)
# Should not show up
SignalFactory.create_batch(
5,
status__state=AFGEHANDELD,
category_assignment__category=self.category_1)
self.assertEqual(Signal.objects.count(), 10)
response = self.client.get(f'{self.base_endpoint}/signals/open',
data={
'start': start,
'end': end
})
self.assertEqual(response.status_code, 200)
response_data = response.json()
self.assertEqual(response_data['total_signal_count'], 5)
self.assertEqual(len(response_data['results']), 1)
self.assertEqual(response_data['results'][0]['signal_count'], 5)
self.assertEqual(response_data['results'][0]['category']['name'],
self.category_1.name)
self.assertEqual(
len(response_data['results'][0]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][0]['category']['departments'])
self.client.logout()
def test_filter_kind_exclude_parent_signal(self):
"""
We expect only "normal" and "child" Signals
"""
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
parent_two = SignalFactory.create()
SignalFactory.create_batch(2, parent=parent_two)
params = {'kind': 'exclude_parent_signal'}
result_ids = self._request_filter_signals(params)
self.assertEqual(23, len(result_ids))
def test_filter_kind_child_signal(self):
"""
Filter Signals that are a child Signal (3 child Signals are created so we expect 3)
"""
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
parent_two = SignalFactory.create()
SignalFactory.create_batch(2, parent=parent_two)
params = {'kind': 'child_signal'}
result_ids = self._request_filter_signals(params)
self.assertEqual(3, len(result_ids))
def test_filter_directing_department_null_empty_directing(self):
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
directing_departments = SignalDepartments.objects.create(
_signal=parent_one,
created_by='*****@*****.**',
relation_type='directing')
directing_departments.save()
parent_one.directing_departments_assignment = directing_departments
params = {'directing_department': 'null'}
result_ids = self._request_filter_signals(params)
self.assertEqual(1, len(result_ids))
def setUp(self):
now = timezone.now()
with (freeze_time(now)):
SignalFactory.create_batch(
5,
status__state=workflow.TE_VERZENDEN,
status__target_api=Status.TARGET_API_SIGMAX)
past = now - timedelta(hours=48)
with (freeze_time(past)):
SignalFactory.create_batch(
5,
status__state=workflow.TE_VERZENDEN,
status__target_api=Status.TARGET_API_SIGMAX)
def setUp(self):
self.signals = {
'SIG': SignalFactory.create_batch(5),
'REQ': SignalFactory.create_batch(3),
'QUE': SignalFactory.create_batch(1),
'COM': SignalFactory.create_batch(2),
'MAI': SignalFactory.create_batch(4),
}
hours = 1
for type_code in self.signals.keys():
with freeze_time(timezone.now() + timedelta(hours=hours)):
for signal in self.signals[type_code]:
TypeFactory.create(_signal=signal, name=type_code)
hours += 1
def test_signals_open_per_category_signals_no_filter(self):
self.client.force_authenticate(user=self.superuser)
with freeze_time(timezone.now() - timezone.timedelta(weeks=3)):
SignalFactory.create_batch(
5,
status__state=GEMELD,
category_assignment__category=self.category_1)
SignalFactory.create_batch(
3,
status__state=BEHANDELING,
category_assignment__category=self.category_2)
SignalFactory.create_batch(
2,
status__state=AFWACHTING,
category_assignment__category=self.category_3)
# Should not show up
SignalFactory.create_batch(
5,
status__state=AFGEHANDELD,
category_assignment__category=self.category_1)
self.assertEqual(Signal.objects.count(), 15)
response = self.client.get(f'{self.base_endpoint}/signals/open')
self.assertEqual(response.status_code, 200)
response_data = response.json()
self.assertEqual(response_data['total_signal_count'], 10)
self.assertEqual(len(response_data['results']), 3)
self.assertEqual(response_data['results'][0]['signal_count'], 5)
self.assertEqual(response_data['results'][0]['category']['name'],
self.category_1.name)
self.assertEqual(
len(response_data['results'][0]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][0]['category']['departments'])
self.assertEqual(response_data['results'][1]['signal_count'], 3)
self.assertEqual(response_data['results'][1]['category']['name'],
self.category_2.name)
self.assertEqual(
len(response_data['results'][1]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][1]['category']['departments'])
self.assertEqual(response_data['results'][2]['signal_count'], 2)
self.assertEqual(response_data['results'][2]['category']['name'],
self.category_3.name)
self.assertEqual(
len(response_data['results'][2]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][2]['category']['departments'])
self.client.logout()
def test_anonymize_reporters_not_in_correct_state(self):
with freeze_time(timezone.now() - timezone.timedelta(days=1)):
SignalFactory.create_batch(5, status__state=BEHANDELING)
self.assertEqual(Reporter.objects.count(), 5)
anonymize_reporters(days=1)
self.assertEqual(Reporter.objects.count(), 5)
self.assertEqual(Reporter.objects.filter(Q(email_anonymized=True) | Q(phone_anonymized=True)).count(), 0)
self.assertEqual(Reporter.objects.filter(email_anonymized=False, phone_anonymized=False).count(), 5)
for reporter in Reporter.objects.all():
self.assertIsNotNone(reporter.email)
self.assertIsNotNone(reporter.phone)
self.assertFalse(reporter.email_anonymized)
self.assertFalse(reporter.phone_anonymized)
def test_filter_source_multiple_sources(self):
acc_signals = SignalFactory.create_batch(5, source='ACC')
result_ids = self._request_filter_signals({'source': 'online'})
self.assertEqual(len(self.signals), len(result_ids))
result_ids = self._request_filter_signals({'source': 'ACC'})
self.assertEqual(len(acc_signals), len(result_ids))
def test_SIG_3390_filter_directing_department(self):
department = DepartmentFactory.create()
parent_one = SignalFactory.create()
SignalFactory.create_batch(1, parent=parent_one)
directing_departments = SignalDepartments.objects.create(
_signal=parent_one,
created_by='*****@*****.**',
relation_type='directing')
directing_departments.departments.add(department)
directing_departments.save()
parent_one.directing_departments_assignment = directing_departments
parent_one.save()
parent_two = SignalFactory.create()
SignalFactory.create_batch(2, parent=parent_two)
parent_three = SignalFactory.create()
directing_departments = SignalDepartments.objects.create(
_signal=parent_three,
created_by='*****@*****.**',
relation_type='directing')
parent_three.directing_departments_assignment = directing_departments
parent_three.save()
SignalFactory.create_batch(2, parent=parent_three)
params = {'directing_department': ['null', department.code]}
result_ids = self._request_filter_signals(params)
self.assertEqual(3, len(result_ids))
def test_retrieve_multiple(self):
now = timezone.now()
with freeze_time(now - timedelta(hours=1)):
parents_with_changes = SignalFactory.create_batch(3)
parents_without_changes = SignalFactory.create_batch(2)
with freeze_time(now):
for parent_signal in parents_with_changes:
SignalFactory(parent=parent_signal)
for parent_signal in parents_without_changes:
SignalFactory(parent=parent_signal)
with freeze_time(now + timedelta(hours=1)):
for parent_signal in parents_without_changes:
parent_signal.save()
filter_params = {'has_changed_children': ['true', 0]}
ids = self._request_filter_signals(filter_params)
self.assertEqual(
len(ids),
len(parents_with_changes) + len(parents_without_changes))
def test_signals_reopen_requested_per_category_no_filter(self):
self.client.force_authenticate(user=self.superuser)
with freeze_time(timezone.now() - timezone.timedelta(weeks=3)):
SignalFactory.create_batch(
5,
status__state=GEMELD,
category_assignment__category=self.category_1)
SignalFactory.create_batch(
3,
status__state=BEHANDELING,
category_assignment__category=self.category_2)
with freeze_time(timezone.now() - timezone.timedelta(weeks=1)):
for signal in Signal.objects.all():
status = StatusFactory.create(_signal=signal,
state=VERZOEK_TOT_HEROPENEN)
signal.status = status
signal.save()
# Should not show up
SignalFactory.create_batch(
2,
status__state=AFGEHANDELD,
category_assignment__category=self.category_3)
self.assertEqual(Signal.objects.count(), 10)
response = self.client.get(
f'{self.base_endpoint}/signals/reopen-requested')
self.assertEqual(response.status_code, 200)
response_data = response.json()
self.assertEqual(response_data['total_signal_count'], 8)
self.assertEqual(len(response_data['results']), 2)
self.assertEqual(response_data['results'][0]['signal_count'], 5)
self.assertEqual(response_data['results'][0]['category']['name'],
self.category_1.name)
self.assertEqual(
len(response_data['results'][0]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][0]['category']['departments'])
self.assertEqual(response_data['results'][1]['signal_count'], 3)
self.assertEqual(response_data['results'][1]['category']['name'],
self.category_2.name)
self.assertEqual(
len(response_data['results'][1]['category']['departments']), 1)
self.assertIn(self.department.code,
response_data['results'][1]['category']['departments'])
self.client.logout()
def setUp(self):
now = timezone.now()
self.reporter_1_email = '*****@*****.**'
self.reporter_2_email = '*****@*****.**'
self.test_category = CategoryFactory.create()
stadhuis_point = Point(STADHUIS['lon'], STADHUIS['lat'])
arena_point = Point(ARENA['lon'], ARENA['lat'])
filmhuis_eye_point = Point(FILMMUSEUM_EYE['lon'], FILMMUSEUM_EYE['lat'])
blauwe_theehuis_point = Point(BLAUWE_THEEHUIS['lon'], BLAUWE_THEEHUIS['lat'])
with freeze_time(now - timedelta(days=5)):
signal = SignalFactory.create(reporter__email=self.reporter_1_email,
status__state=workflow.BEHANDELING,
location__geometrie=stadhuis_point,
location__buurt_code=STADHUIS['buurt_code'],
category_assignment__category=self.test_category)
FeedbackFactory.create(_signal=signal, submitted_at=now, is_satisfied=False)
# Child signals ("deelmeldingen") should not show up in the reporter context, as they are used internally.
self.child_signals = SignalFactory.create_batch(size=2,
reporter__email=self.reporter_1_email,
parent=signal,
location__geometrie=stadhuis_point,
location__buurt_code=ARENA['buurt_code'],
category_assignment__category=self.test_category)
with freeze_time(now - timedelta(days=4)):
SignalFactory.create(reporter__email=self.reporter_1_email,
status__state=workflow.BEHANDELING,
location__geometrie=stadhuis_point,
location__buurt_code=STADHUIS['buurt_code'],
category_assignment__category=self.test_category)
with freeze_time(now - timedelta(days=3)):
signal = SignalFactory.create(reporter__email=self.reporter_1_email,
status__state=workflow.AFGEHANDELD,
location__geometrie=arena_point,
location__area_code='arena',
location__buurt_code=ARENA['buurt_code'],
category_assignment__category=self.test_category)
FeedbackFactory.create(_signal=signal, submitted_at=now, is_satisfied=False)
SignalFactory.create(reporter__email=self.reporter_1_email,
status__state=workflow.AFGEHANDELD,
location__geometrie=filmhuis_eye_point,
location__buurt_code=FILMMUSEUM_EYE['buurt_code'],
category_assignment__category=self.test_category)
signal = SignalFactory.create(reporter__email=self.reporter_1_email,
status__state=workflow.AFGEHANDELD,
location__geometrie=blauwe_theehuis_point,
location__buurt_code=BLAUWE_THEEHUIS['buurt_code'],
category_assignment__category=self.test_category)
FeedbackFactory.create(_signal=signal, submitted_at=now, is_satisfied=True)
self.reporter_1_signals = Signal.objects.filter(
(Q(parent__isnull=True) & Q(children__isnull=True)) | Q(children__isnull=False),
reporter__email=self.reporter_1_email
)
self.anonymous_signals = [
SignalFactory.create(reporter__email=None,
status__state=workflow.BEHANDELING,
location__geometrie=filmhuis_eye_point,
location__buurt_code=FILMMUSEUM_EYE['buurt_code'],
category_assignment__category=self.test_category),
SignalFactory.create(reporter__email='',
status__state=workflow.BEHANDELING,
location__geometrie=blauwe_theehuis_point,
location__buurt_code=BLAUWE_THEEHUIS['buurt_code'],
category_assignment__category=self.test_category)
]
self.reporter_2_signals = SignalFactory.create_batch(size=5,
reporter__email=self.reporter_2_email,
location__geometrie=filmhuis_eye_point,
location__buurt_code=FILMMUSEUM_EYE['buurt_code'],
category_assignment__category=self.test_category)
