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(', '))