def test_make_email_context_for_category_with_or_without_public_name(self):
# Check categories with public names.
main_cat_with_public_name = ParentCategoryFactory.create(
parent=None, name='PRIVATE_MAIN_I', public_name='PUBLIC_MAIN_I')
sub_cat_with_public_name = CategoryFactory.create(
parent=main_cat_with_public_name,
name='PRIVATE_SUB',
public_name='PUBLIC_SUB_I')
signal_with_public_name = SignalFactory.create(
category_assignment__category=sub_cat_with_public_name)
context_with = make_email_context(signal=signal_with_public_name)
self.assertEqual(context_with['main_category_public_name'],
'PUBLIC_MAIN_I')
self.assertEqual(context_with['sub_category_public_name'],
'PUBLIC_SUB_I')
# Check categories without public names.
main_cat_no_public_name = ParentCategoryFactory.create(
parent=None, name='PRIVATE_MAIN_II', public_name=None)
sub_cat_no_public_name = CategoryFactory.create(
parent=main_cat_no_public_name,
name='PRIVATE_SUB_II',
public_name=None)
signal_no_public_name = SignalFactory.create(
category_assignment__category=sub_cat_no_public_name)
context_without = make_email_context(signal=signal_no_public_name)
self.assertEqual(context_without['main_category_public_name'],
'PRIVATE_MAIN_II')
self.assertEqual(context_without['sub_category_public_name'],
'PRIVATE_SUB_II')
def test_create_initial_child_signals_max_exceeded(self, validate_address):
parent_signal = SignalFactory.create()
SignalFactory.create(parent=parent_signal)
SignalFactory.create(parent=parent_signal)
signal_count = Signal.objects.count()
parent_signal_count = Signal.objects.filter(
parent_id__isnull=True).count()
child_signal_count = Signal.objects.filter(
parent_id__isnull=False).count()
self.assertEqual(signal_count, 3)
self.assertEqual(parent_signal_count, 1)
self.assertEqual(child_signal_count, 2)
initial_data = []
for _ in range(2):
data = copy.deepcopy(self.initial_data_base)
data['parent'] = parent_signal.pk
initial_data.append(data)
response = self.client.post(self.list_endpoint,
initial_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(Signal.objects.count(), 3)
self.assertEqual(
Signal.objects.filter(parent_id__isnull=True).count(), 1)
self.assertEqual(
Signal.objects.filter(parent_id__isnull=False).count(), 2)
def setUp(self):
# We use a category without no deadlines to create signals/complaints that
# will have deadline set to None.
test_cat = CategoryFactory.create(name='testcategory')
with freeze_time(self.NOW - datetime.timedelta(days=4 * 7)):
self.signal_late_open = SignalFactory.create(
status__state=workflow.GEMELD,
category_assignment__category=test_cat)
self.signal_late_closed = SignalFactory.create(
status__state=workflow.AFGEHANDELD,
category_assignment__category=test_cat)
# We now set a Service Level Objective for the category, so that we can
# create some signals/complaints with a deadline set to some value other
# than None.
ServiceLevelObjectiveFactory.create(
category=test_cat,
n_days=5,
use_calendar_days=False,
)
with freeze_time(self.NOW - datetime.timedelta(hours=1)):
self.signal_punctual_open = SignalFactory.create(
status__state=workflow.GEMELD,
category_assignment__category=test_cat)
self.signal_punctual_closed = SignalFactory.create(
status__state=workflow.AFGEHANDELD,
category_assignment__category=test_cat)
def test_create_initial_child_signals_parent_is_child_not_allowed(
self, validate_address):
parent_signal = SignalFactory.create()
child_signal = SignalFactory.create(parent=parent_signal)
signal_count = Signal.objects.count()
parent_signal_count = Signal.objects.filter(
parent_id__isnull=True).count()
child_signal_count = Signal.objects.filter(
parent_id__isnull=False).count()
self.assertEqual(signal_count, 2)
self.assertEqual(parent_signal_count, 1)
self.assertEqual(child_signal_count, 1)
initial_data = [
copy.deepcopy(self.initial_data_base),
copy.deepcopy(self.initial_data_base),
]
initial_data[0]['parent'] = child_signal.pk
initial_data[1]['parent'] = child_signal.pk
response = self.client.post(self.list_endpoint,
initial_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(Signal.objects.count(), 2)
self.assertEqual(
Signal.objects.filter(parent_id__isnull=True).count(), 1)
self.assertEqual(
Signal.objects.filter(parent_id__isnull=False).count(), 1)
def setUp(self):
self.priority_low = SignalFactory.create(
priority__priority=Priority.PRIORITY_LOW)
self.priority_high = SignalFactory.create(
priority__priority=Priority.PRIORITY_HIGH)
self.priority_normal = SignalFactory.create(
priority__priority=Priority.PRIORITY_NORMAL)
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_get_group_by(self):
"""
Return the GEOJson containing the first created_at in a BBOX grouped by a category
"""
parent_category = ParentCategoryFactory.create()
child_category = CategoryFactory.create(
parent=parent_category,
public_name='Public category for testing',
is_public_accessible=True)
now = timezone.now()
for x in range(5):
with (freeze_time(now - timedelta(days=x))):
# Should appear in the response
SignalFactory.create(
location__geometrie=Point(STADHUIS['lon'],
STADHUIS['lat']),
location__buurt_code=STADHUIS['buurt_code'],
category_assignment__category=child_category)
response = self.client.get(
f'{self.geography_endpoint}/?maincategory_slug={parent_category.slug}'
f'&category_slug={child_category.slug}&bbox=4.875759,52.360656,4.921221,52.37942'
'&group_by=category')
self.assertEqual(200, response.status_code)
self.assertEqual(1, int(response.headers['X-Total-Count']))
data = response.json()
self.assertEqual(1, len(data['features']))
self.assertEqual(data['features'][0]['properties']['category']['name'],
child_category.public_name)
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_routing(self):
# test signal outside center
signal_outside = SignalFactory.create(
location__geometrie=geos.Point(1.0, 1.0)
)
signal_outside.refresh_from_db()
self.assertIsNone(signal_outside.routing_assignment)
# simulate apply routing rules
self.dsl_service.process_routing_rules(signal_outside)
signal_outside.refresh_from_db()
self.assertIsNone(signal_outside.routing_assignment)
# test signal inside center
signal_inside = SignalFactory.create(
location__geometrie=geos.Point(4.88, 52.36)
)
signal_inside.refresh_from_db()
self.assertIsNone(signal_inside.routing_assignment)
# simulate apply routing rules
self.dsl_service.process_routing_rules(signal_inside)
signal_inside.refresh_from_db()
self.assertIsNotNone(signal_inside.routing_assignment)
self.assertEqual(len(signal_inside.routing_assignment.departments.all()), 1)
routing_dep = signal_inside.routing_assignment.departments.first()
self.assertEqual(routing_dep.id, self.department.id)
def test_save_csv_files_datawarehouse(self, mocked_get_storage_backend):
# Mocking the storage backend to local file system with tmp directory.
# In this test case we don't want to make usage of the remote Object
# Store.
mocked_get_storage_backend.return_value = FileSystemStorage(location=self.file_backend_tmp_dir)
# Creating a few objects in the database.
for i in range(3):
SignalFactory.create()
datawarehouse.save_csv_files_datawarehouse()
# Checking if we have files on the correct locations and that they
# do have some content.
signals_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_signals.csv')
locations_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_locations.csv')
reporters_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_reporters.csv')
categories_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_categories.csv')
statuses_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_statuses.csv')
sla_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_sla.csv')
directing_departments_csv = path.join(self.file_backend_tmp_dir, '2020/09/10', '120000UTC_directing_departments.csv') # noqa
self.assertTrue(path.exists(signals_csv))
self.assertTrue(path.getsize(signals_csv))
self.assertTrue(path.exists(locations_csv))
self.assertTrue(path.getsize(locations_csv))
self.assertTrue(path.exists(reporters_csv))
self.assertTrue(path.getsize(reporters_csv))
self.assertTrue(path.exists(categories_csv))
self.assertTrue(path.getsize(categories_csv))
self.assertTrue(path.exists(statuses_csv))
self.assertTrue(path.getsize(statuses_csv))
self.assertTrue(path.getsize(sla_csv))
self.assertTrue(path.getsize(directing_departments_csv))
def test_apply_for_parent_signals(self):
status_text = FuzzyText(length=400)
parent_signal = SignalFactory.create(
status__state=self.prev_state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email='*****@*****.**',
parent=parent_signal)
# create the new current state
status = StatusFactory.create(_signal=parent_signal, state=self.state)
parent_signal.status = status
parent_signal.save()
feedback = FeedbackFactory.create(
allows_contact=True,
_signal=parent_signal,
)
feedback.save()
self.assertTrue(self.rule(parent_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 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_anonymous = SignalFactory.create(reporter__phone='',
reporter__email='')
self.signal_has_email = SignalFactory.create(
reporter__phone='', reporter__email='*****@*****.**')
self.signal_has_phone = SignalFactory.create(
reporter__phone='0123456789', reporter__email='')
self.signal_has_both = SignalFactory.create(
reporter__phone='0123456789', reporter__email='*****@*****.**')
def setUp(self):
def get_email():
return f'{uuid.uuid4()}@example.com'
self.signal = SignalFactory.create(reporter__email=get_email())
self.signal_no_email = SignalFactory.create(reporter__email='')
self.parent_signal = SignalFactory.create(reporter__email=get_email())
self.child_signal = SignalFactory.create(reporter__email=get_email(),
parent=self.parent_signal)
def setUp(self):
self.signal = SignalFactory.create(
category_assignment__category__parent__name='Overlast Bedrijven en Horeca',
category_assignment__category__name='Geluidsoverlast muziek'
)
self.signal_other_category = SignalFactory.create(
category_assignment__category__parent__name='Some other main category',
category_assignment__category__name='Some other category'
)
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_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 setUp(self):
email = '*****@*****.**'
self.department_yes = DepartmentFactory.create(name='department_yes')
self.department_no = DepartmentFactory.create(name='department_no')
self.category_yes = CategoryFactory.create(departments=[self.department_yes])
self.category_no = CategoryFactory.create(departments=[self.department_no])
self.signal_yes = SignalFactory.create(category_assignment__category=self.category_yes, reporter__email=email)
self.signal_no = SignalFactory.create(category_assignment__category=self.category_no, reporter__email=email)
self.sia_read_write_user.profile.departments.add(self.department_yes)
def test_retrieve_all_parents_with_changes_in_children(self):
now = timezone.now()
with freeze_time(now - timedelta(hours=1)):
parent_signal = SignalFactory()
with freeze_time(now):
SignalFactory(parent=parent_signal)
filter_params = {'has_changed_children': True}
ids = self._request_filter_signals(filter_params)
self.assertEqual(len(ids), 1)
self.assertEqual(ids, [parent_signal.id])
def test_anonymous_reporter(self):
status_text = FuzzyText(length=400)
signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email='')
self.assertFalse(self.rule(signal))
signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email=None)
self.assertFalse(self.rule(signal))
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 setUp(self):
self.keyword = 'KEYWORD'
text_no_keyword = 'blah blah blah'
text_with_keyword = f'blah blah blah {self.keyword} blah blah blah'
self.signal_with_keyword = SignalFactory()
NoteFactory(_signal=self.signal_with_keyword, text=text_no_keyword)
NoteFactory(_signal=self.signal_with_keyword, text=text_no_keyword)
NoteFactory(_signal=self.signal_with_keyword, text=text_with_keyword)
NoteFactory(_signal=self.signal_with_keyword, text=text_with_keyword)
self.signal_no_keyword = SignalFactory()
NoteFactory(_signal=self.signal_with_keyword, text=text_no_keyword)
def test_do_not_apply_for_child_signals(self):
status_text = FuzzyText(length=400)
parent_signal = SignalFactory.create(
status__state=self.state,
status__text=status_text,
reporter__email='*****@*****.**')
child_signal = SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email='*****@*****.**',
parent=parent_signal)
self.assertFalse(self.rule(child_signal))
def test_delete_parent_signal_attachments(self):
"""
Check that "sia_delete_attachment_of_parent_signal" is needed to delete a
parent signal's attachments. Note: test uses the same user that uploaded
to delete the attachments, so "sia_delete_attachment_of_anonymous_user" and
"sia_delete_attachment_of_other_user" are not needed.
"""
self.assertEqual(
Attachment.objects.filter(_signal=self.signal).count(), 1)
self.client.force_authenticate(user=self.sia_read_write_user)
self.sia_read_write_user.profile.departments.add(self.department)
# Turn the signal into a parent signal, let's pretend our test
# user uploaded its attachment.
SignalFactory.create(parent=self.signal,
category_assignment__category=self.category)
self.attachment.created_by = self.sia_read_write_user.email
self.attachment.save()
att_filename = os.path.basename(self.attachment.file.name)
# Try to delete without "sia_delete_attachment_of_parent_signal"
parent_signal = self.signal
parent_attachment = self.attachment
parent_attachment_url = self.attachments_endpoint_detail.format(
parent_signal.pk, parent_attachment.pk)
response = self.client.delete(parent_attachment_url)
self.assertEqual(response.status_code, 403)
self.assertEqual(
Attachment.objects.filter(_signal=parent_signal).count(), 1)
self.assertEqual(Note.objects.filter(_signal=parent_signal).count(), 0)
self.assertIn('sia_delete_attachment_of_parent_signal',
response.json()['detail'])
# Try to delete with "delete_attachment_of_parent_signal"
self.sia_read_write_user.user_permissions.set(
[self.permission_delete_parent])
self.sia_read_write_user.save()
self.sia_read_write_user.refresh_from_db()
self.client.force_authenticate(user=self.sia_read_write_user)
self.assertEqual(Note.objects.filter(_signal=parent_signal).count(), 0)
response = self.client.delete(parent_attachment_url)
self.assertEqual(response.status_code, 204)
self.assertEqual(
Attachment.objects.filter(_signal=parent_signal).count(), 0)
self.assertEqual(Note.objects.filter(_signal=parent_signal).count(), 1)
n = Note.objects.all().first()
self.assertEqual(n.text, f'Bijlage {att_filename} is verwijderd.')
self.assertEqual(n.created_by, self.sia_read_write_user.email)
def test_apply_for_parent_signals(self):
status_text = FuzzyText(length=400)
parent_signal = SignalFactory.create(
status__state=self.state,
status__text=status_text,
status__send_email=self.send_email,
reporter__email='*****@*****.**')
SignalFactory.create(status__state=self.state,
status__text=status_text,
reporter__email='*****@*****.**',
parent=parent_signal)
self.assertTrue(self.rule(parent_signal))
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_create_directing_departments_csv(self):
signal = SignalFactory.create()
departments = DepartmentFactory.create_batch(2)
directing_department = SignalDepartments.objects.create(
relation_type=SignalDepartments.REL_DIRECTING, _signal=signal)
directing_department.departments.add(*departments)
directing_department.save()
signal.refresh_from_db()
csv_file = datawarehouse.create_directing_departments_csv(
self.csv_tmp_dir)
self.assertEqual(
path.join(self.csv_tmp_dir, 'directing_departments.csv'), csv_file)
with open(csv_file) as opened_csv_file:
reader = csv.DictReader(opened_csv_file)
for row in reader:
self.assertEqual(row['id'], str(directing_department.id))
self.assertEqual(row['_signal_id'],
str(directing_department._signal_id))
for department in departments:
self.assertIn(department.name,
row['departments'].split(', '))
