def test_anonymize_reporters_less_than_x_days_ago(self): allowed_states = [ AFGEHANDELD, GEANNULEERD, GESPLITST, VERZOEK_TOT_AFHANDELING ] with freeze_time(timezone.now() - timezone.timedelta(days=1)): for allowed_state in allowed_states: SignalFactory.create(status__state=allowed_state) self.assertEqual(Reporter.objects.count(), 4) anonymize_reporters(days=2) self.assertEqual(Reporter.objects.count(), 4) 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(), 4) 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 setUp(self): self.signal = SignalFactory.create(reporter__email='*****@*****.**') self.signal_no_email = SignalFactory.create(reporter__email='') self.parent_signal = SignalFactory.create( reporter__email='*****@*****.**') self.child_signal = SignalFactory.create(reporter__email='*****@*****.**', parent=self.parent_signal)
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, 'signals.csv') locations_csv = path.join(self.file_backend_tmp_dir, 'locations.csv') reporters_csv = path.join(self.file_backend_tmp_dir, 'reporters.csv') categories_csv = path.join(self.file_backend_tmp_dir, 'categories.csv') statuses_csv = path.join(self.file_backend_tmp_dir, 'statuses.csv') sla_csv = path.join(self.file_backend_tmp_dir, 'sla.csv') 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))
def setUp(self): self.parent_signal = SignalFactory.create( status__state=workflow.GESPLITST, parent=None, reporter__email='*****@*****.**') self.child_signal_1 = SignalFactory.create( status__state=workflow.GEMELD, parent=self.parent_signal) self.child_signal_2 = SignalFactory.create( status__state=workflow.GEMELD, parent=self.parent_signal)
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 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): 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 setUp(self): self.signal = SignalFactory() self.category = CategoryFactory() self.category_assignment = CategoryAssignment.objects.create( category=self.category, _signal_id=self.signal.id) self.link_category = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format( self.category.parent.slug, self.category.slug)
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): 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): # Forcing authentication self.client.force_authenticate(user=self.superuser) SignalFactory.create(id=1) SignalFactory.create(id=2) SignalFactory.create(id=3, priority__priority=Priority.PRIORITY_HIGH) SignalFactory.create(id=4) SignalFactory.create(id=5, priority__priority=Priority.PRIORITY_HIGH)
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 test_status_data_success(self): # We need two Signal objects. SignalFactory.create() SignalFactory.create() 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.main_cat_1 = ParentCategoryFactory.create() self.main_cat_2 = ParentCategoryFactory.create() self.s1 = SignalFactory.create(category_assignment__category__parent=self.main_cat_1) self.s2 = SignalFactory.create(category_assignment__category__parent=self.main_cat_2) # We are testing the authenticated part of the API, hence: self.client.force_authenticate(user=self.superuser)
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 test_filter_maincategory_and_category_slugs_not_a_unique_slug(self): parent_category = ParentCategoryFactory.create(name='not_unique') category = CategoryFactory.create(name='not_unique', parent=parent_category) SignalFactory.create(category_assignment__category=category) params = { 'maincategory_slug': [parent_category.slug, ], 'category_slug': [category.slug, ] } result_ids = self._request_filter_signals(params) self.assertEqual(1, len(result_ids))
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 setUp(self): self.signal = SignalFactory() self.category = CategoryFactory() self.category_assignment = CategoryAssignment.objects.create(category=self.category, _signal_id=self.signal.id) self.link_category = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format( self.category.parent.slug, self.category.slug ) geometry = MultiPolygon([Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])], srid=4326) self.pt_in_center = Point(4.88, 52.36) self.pt_out_center = Point(6, 53) self.area = AreaFactory.create(geometry=geometry, name='Centrum', code='centrum', _type__code='district')
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_filter_directing_department(self): department = DepartmentFactory.create() parent_one = SignalFactory.create() SignalFactory.create_batch(1, parent=parent_one) directing_departments = DirectingDepartments.objects.create( _signal=parent_one, created_by='*****@*****.**') directing_departments.departments.add(department) parent_one.directing_departments_assignment = directing_departments parent_one.save() params = {'directing_department': department.code} result_ids = self._request_filter_signals(params) self.assertEqual(1, len(result_ids))
def setUp(self): self.signal = SignalFactory.create() self.user = UserFactory.create() self.location = self.signal.location self.location.created_by = self.user.username self.location.save()
def setUp(self): self.signal = SignalFactory.create() self.user = UserFactory.create() self.category_assignment = self.signal.category_assignment self.category_assignment.created_by = self.user.username self.category_assignment.save()
def test_create_category_assignments_csv(self): signal = SignalFactory.create() category_assignment = signal.category_assignment csv_file = datawarehouse._create_category_assignments_csv( self.csv_tmp_dir) self.assertEqual(path.join(self.csv_tmp_dir, 'categories.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(category_assignment.id)) self.assertEqual(row['_signal_id'], str(category_assignment._signal_id)) self.assertEqual(row['main'], str(category_assignment.category.parent.name)) self.assertEqual(row['sub'], str(category_assignment.category.name)) self.assertEqual( row['departments'], ', '.join( category_assignment.category.departments.values_list( 'name', flat=True))) self.assertEqual(row['created_at'], str(category_assignment.created_at)) self.assertEqual(row['updated_at'], str(category_assignment.updated_at)) self.assertEqual(json.loads(row['extra_properties']), None)
def test_create_locations_csv(self): signal = SignalFactory.create() location = signal.location csv_file = datawarehouse._create_locations_csv(self.csv_tmp_dir) self.assertEqual(path.join(self.csv_tmp_dir, 'locations.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(location.id)) self.assertEqual(row['_signal_id'], str(location._signal_id)) self.assertEqual(row['lat'], str(location.geometrie.x)) self.assertEqual(row['lng'], str(location.geometrie.y)) self.assertEqual(row['stadsdeel'], str(location.get_stadsdeel_display())) self.assertEqual(row['buurt_code'], str(location.buurt_code)) self.assertDictEqual(json.loads(row['address']), location.address) self.assertEqual(row['address_text'], str(location.address_text)) self.assertEqual(row['created_at'], str(location.created_at)) self.assertEqual(row['updated_at'], str(location.updated_at)) self.assertEqual(json.loads(row['extra_properties']), None)
def _create_signals(cls): """ Creates SIGNALS_DISTRIBUTE_DAYS_CNT signals. One per day backwards starting from yesterday current time. Creates SIGNALS_DISTRIBUTE_HOURS_CNT signals every hour backwards from now If today is Friday 16:00, and SIGNALS_DISTRIBUTE_DAYS_CNT and SIGNALS_DISTRIBUTE_HOURS_CNT are both set to 3, we will generate the following signals: - Per day: Thursday (yesterday) 16:00, Wednesday (day before yesterday) 16:00, Tuesday 16:00 - Per hour: Friday 16:00 (now), Friday 15:00 (now minus 1 hour), Friday 14:00 (now minus 2h) """ now = datetime.utcnow() # Generate created/updated times for new signals. times = [now - timedelta(days=idx + 1) for idx in range(cls.SIGNALS_DISTRIBUTE_DAYS_CNT)] + \ [now - timedelta(hours=idx) for idx in range(cls.SIGNALS_DISTRIBUTE_HOURS_CNT)] cls.states = 3 * [BEHANDELING] + 2 * [ON_HOLD] + (len(times) - 3 - 2) * [GEMELD] shuffle(cls.states) cls.sub_categories = [CategoryFactory.create() for _ in range(cls.SUBCATEGORY_CNT)] for idx, time in enumerate(times): with freeze_time(time): signal = SignalFactory.create() StatusFactory(_signal=signal, state=cls.states[idx]) category_assignment = CategoryAssignmentFactory(_signal=signal, category=cls.sub_categories[ idx % len(cls.sub_categories)]) signal.category_assignment = category_assignment signal.save() cls.signals.append(signal)
def test_cannot_access_attachments(self): # SIA must not publicly expose attachments signal = SignalFactory.create() uuid = signal.signal_id response = self.client.get(self.attachment_endpoint.format(uuid=uuid)) self.assertEqual(response.status_code, 405)
def test_create_signals_csv(self): signal = SignalFactory.create() csv_file = datawarehouse._create_signals_csv(self.csv_tmp_dir) self.assertEqual(path.join(self.csv_tmp_dir, 'signals.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(signal.id)) self.assertEqual(row['signal_uuid'], str(signal.signal_id)) self.assertEqual(row['source'], str(signal.source)) self.assertEqual(row['text'], str(signal.text)) self.assertEqual(row['text_extra'], str(signal.text_extra)) self.assertEqual(row['location_id'], str(signal.location_id)) self.assertEqual(row['status_id'], str(signal.status_id)) self.assertEqual(row['category_assignment_id'], str(signal.category_assignment_id)) self.assertEqual(row['reporter_id'], str(signal.reporter_id)) self.assertEqual(row['incident_date_start'], str(signal.incident_date_start)) self.assertEqual(row['incident_date_end'], str(signal.incident_date_end)) self.assertEqual(row['created_at'], str(signal.created_at)) self.assertEqual(row['updated_at'], str(signal.updated_at)) self.assertEqual(row['operational_date'], '') self.assertEqual(row['expire_date'], '') self.assertEqual(row['image'], str(signal.image)) self.assertEqual(row['upload'], '') self.assertDictEqual(json.loads(row['extra_properties']), signal.extra_properties)
def test_create_default_notification_message_integration_test(self): signal = SignalFactory.create() message = create_default_notification_message(signal) self.assertIn(str(signal.id), message) self.assertIn(signal.text, message)