def test_create_child_signal_transform_source(self, validate_address): parent_signal = SignalFactory.create() signal_count = Signal.objects.count() source, *_ = SourceFactory.create_batch(4) SourceFactory.create( name=settings.API_TRANSFORM_SOURCE_OF_CHILD_SIGNAL_TO) initial_data = copy.deepcopy(self.initial_data_base) initial_data['source'] = source.name initial_data['parent'] = parent_signal.pk with self.settings(FEATURE_FLAGS={ 'API_TRANSFORM_SOURCE_IF_A_SIGNAL_IS_A_CHILD': True }): response = self.client.post(self.list_endpoint, initial_data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Signal.objects.count(), signal_count + 1) response_data = response.json() self.assertNotEqual(response_data['source'], source.name) self.assertEqual(response_data['source'], settings.API_TRANSFORM_SOURCE_OF_CHILD_SIGNAL_TO) signal = Signal.objects.get(pk=response_data['id']) self.assertNotEqual(signal.source, source.name) self.assertEqual(signal.source, settings.API_TRANSFORM_SOURCE_OF_CHILD_SIGNAL_TO)
def test_create_initial_child_signals_validate_source_online(self, validate_address): # Validating a valid source for child Signals causes a HTTP 500 in # SIA production, this testcase reproduces the problem. SourceFactory.create(name='online', description='online') with self.settings(FEATURE_FLAGS=self.prod_feature_flags_settings): parent_signal = SignalFactory.create() 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, 1) self.assertEqual(parent_signal_count, 1) self.assertEqual(child_signal_count, 0) initial_data = [] for i in range(2): data = copy.deepcopy(self.initial_data_base) data['parent'] = parent_signal.pk data['source'] = 'online' initial_data.append(data) response = self.client.post(self.list_endpoint, initial_data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Signal.objects.count(), signal_count + len(initial_data)) self.assertEqual(Signal.objects.filter(parent_id__isnull=True).count(), parent_signal_count) self.assertEqual(Signal.objects.filter(parent_id__isnull=False).count(), len(initial_data))
def setUp(self): SourceFactory.create(name='online', is_active=True) SourceFactory.create(name='Telefoon – ASC', is_active=True) self.main_category = ParentCategoryFactory.create(name='main', slug='main') self.link_main_category = '/signals/v1/public/terms/categories/main' self.sub_category_1 = CategoryFactory.create(name='sub1', slug='sub1', parent=self.main_category) self.link_sub_category_1 = f'{self.link_main_category}/sub_categories/sub1' self.sub_category_2 = CategoryFactory.create(name='sub2', slug='sub2', parent=self.main_category) self.link_sub_category_2 = f'{self.link_main_category}/sub_categories/sub2' self.sia_read_write_user.user_permissions.add( Permission.objects.get(codename='sia_can_view_all_categories')) self.client.force_authenticate(user=self.sia_read_write_user) self.initial_data_base = dict( text='Mensen in het cafe maken erg veel herrie', location=dict(geometrie=dict( type='point', coordinates=[4.90022563, 52.36768424])), category=dict(category_url=self.link_sub_category_1), reporter=dict(email='*****@*****.**'), incident_date_start=timezone.now().strftime('%Y-%m-%dT%H:%M'), source='Telefoon – ASC', ) self.retrieve_signal_schema = self.load_json_schema( os.path.join(THIS_DIR, 'json_schema', 'get_signals_v1_private_signals_{pk}.json'))
def test_signal_ids_cannot_be_skipped(self, validate_address): SourceFactory.create(name='online', description='online') with self.settings(FEATURE_FLAGS=self.prod_feature_flags_settings): parent_signal = SignalFactory.create() 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, 1) self.assertEqual(parent_signal_count, 1) self.assertEqual(child_signal_count, 0) # bad data initial_data = [] for _ in range(2): data = copy.deepcopy(self.initial_data_base) data['parent'] = parent_signal.pk data['source'] = 'online' data['category'] = { 'subcategory': data['category']['category_url'] } initial_data.append(data) with self.assertRaises(IntegrityError): response = self.client.post(self.list_endpoint, initial_data, format='json') # good data initial_data = [] for _ in range(2): data = copy.deepcopy(self.initial_data_base) data['parent'] = parent_signal.pk data['source'] = 'online' initial_data.append(data) response = self.client.post(self.list_endpoint, initial_data, format='json') response_json = response.json() self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Signal.objects.count(), signal_count + len(initial_data)) self.assertEqual( Signal.objects.filter(parent_id__isnull=True).count(), parent_signal_count) self.assertEqual( Signal.objects.filter(parent_id__isnull=False).count(), len(initial_data)) # check that we did not skip signal ids ids = [entry['id'] for entry in response_json] self.assertEqual(ids[0] - parent_signal.id, 1) self.assertEqual(ids[1] - parent_signal.id, 2)
def test_get_list(self): SourceFactory.create_batch(5) self.assertEqual(Source.objects.count(), 5) response = self.client.get(f'{self.list_endpoint}') self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertEqual(5, data['count']) self.assertEqual(5, len(data['results'])) self.assertJsonSchema(self.list_sources_schema, data)
def handle(self, *args, **options): to_create = int(options['to_create'] or self.default_to_create) if not self.min_to_create <= to_create <= self.max_to_create: self.stderr.write( f'The to create option must be an integer from {self.min_to_create} to ' f'{self.max_to_create}, {to_create} given') else: for _ in range(to_create): SourceFactory.create(name=slugify(fake.words()), description=fake.sentence(nb_words=10)) self.stdout.write(f'Created {to_create} random Source(s)')
def test_create_initial_signal_invalid_source(self, validate_address): signal_count = Signal.objects.count() SourceFactory.create_batch(5) initial_data = copy.deepcopy(self.initial_data_base) initial_data['source'] = 'this-source-does-not-exists-so-the-create-should-fail' with self.settings(FEATURE_FLAGS={'API_VALIDATE_SOURCE_AGAINST_SOURCE_MODEL': True}): 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(), signal_count)
def test_create_initial_signal_invalid_source(self, validate_address): signal_count = Signal.objects.count() SourceFactory.create_batch(5) initial_data = copy.deepcopy(self.initial_data_base) initial_data[ 'source'] = 'this-source-does-not-exists-so-the-create-should-fail' 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(), signal_count)
def setUp(self): super().setUp() self.client.force_authenticate(user=self.sia_read_write_user) self.sources = SourceFactory.create_batch(5) self.list_sources_schema = self.load_json_schema( os.path.join(THIS_DIR, 'json_schema', 'get_signals_v1_private_sources.json'))
def test_get_list_can_be_selected_filter(self): # setup can_be_selected_sources = SourceFactory.create_batch( 3, can_be_selected=True, is_active=True) can_not_be_selected_sources = SourceFactory.create_batch( 2, can_be_selected=False, is_active=True) self.assertEqual(Source.objects.count(), 5) self.assertEqual( Source.objects.filter(can_be_selected=True).count(), 3) self.assertEqual( Source.objects.filter(can_be_selected=False).count(), 2) # can_be_selected = true response = self.client.get( f'{self.list_endpoint}?can_be_selected=true') self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertJsonSchema(self.list_sources_schema, data) self.assertEqual(3, data['count']) self.assertEqual(3, len(data['results'])) source_ids = [source.id for source in can_be_selected_sources] result_ids = [result['id'] for result in data['results']] self.assertEqual(set(source_ids), set(result_ids)) # can_be_selected = false response = self.client.get( f'{self.list_endpoint}?can_be_selected=false') self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertJsonSchema(self.list_sources_schema, data) self.assertEqual(2, data['count']) self.assertEqual(2, len(data['results'])) source_ids = [source.id for source in can_not_be_selected_sources] result_ids = [result['id'] for result in data['results']] self.assertEqual(set(source_ids), set(result_ids))
def test_get_list_is_active_filter(self): # setup active_sources = SourceFactory.create_batch(3) inactive_sources = SourceFactory.create_batch(2, is_active=False) self.assertEqual(Source.objects.count(), 5) self.assertEqual(Source.objects.filter(is_active=True).count(), 3) self.assertEqual(Source.objects.filter(is_active=False).count(), 2) # is_active = true response = self.client.get(f'{self.list_endpoint}?is_active=true') self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertJsonSchema(self.list_sources_schema, data) self.assertEqual(3, data['count']) self.assertEqual(3, len(data['results'])) active_source_ids = [ active_source.id for active_source in active_sources ] result_ids = [result['id'] for result in data['results']] self.assertEqual(set(active_source_ids), set(result_ids)) # is_active = false response = self.client.get(f'{self.list_endpoint}?is_active=false') self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertJsonSchema(self.list_sources_schema, data) self.assertEqual(2, data['count']) self.assertEqual(2, len(data['results'])) inactive_source_ids = [ inactive_source.id for inactive_source in inactive_sources ] result_ids = [result['id'] for result in data['results']] self.assertEqual(set(inactive_source_ids), set(result_ids))
def test_create_initial_signal_public_source(self, validate_address): public_source = SourceFactory.create(name='app', is_public=True, is_active=True) signal_count = Signal.objects.count() initial_data = copy.deepcopy(self.initial_data_base) initial_data['source'] = public_source.name 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(), signal_count)
def test_create_with_source_with_is_public_property_set_to_true( self, validate_address): public_source = SourceFactory.create(is_public=True) create_initial_data = copy.deepcopy(self.create_initial_data) create_initial_data.update({'source': public_source.name}) response = self.client.post(self.list_endpoint, create_initial_data, format='json') self.assertEqual(201, response.status_code) self.assertJsonSchema(self.create_schema, response.json()) self.assertEqual(1, Signal.objects.count()) signal = Signal.objects.last() self.assertEqual(signal.source, public_source.name)
def test_create_with_source_with_is_public_property_set_to_false( self, validate_address): private_source = SourceFactory.create(is_public=False) create_initial_data = copy.deepcopy(self.create_initial_data) create_initial_data.update({'source': private_source.name}) response = self.client.post(self.list_endpoint, create_initial_data, format='json') self.assertEqual(400, response.status_code) self.assertEqual(0, Signal.objects.count()) response_json = response.json() self.assertEqual(len(response_json['source']), 1) self.assertEqual(response_json['source'][0], 'Invalid source given, value not known')
def test_create_initial_signal_valid_source(self, validate_address): signal_count = Signal.objects.count() source, *_ = SourceFactory.create_batch(5) initial_data = copy.deepcopy(self.initial_data_base) initial_data['source'] = source.name with self.settings(FEATURE_FLAGS={'API_VALIDATE_SOURCE_AGAINST_SOURCE_MODEL': True}): response = self.client.post(self.list_endpoint, initial_data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Signal.objects.count(), signal_count + 1) response_data = response.json() self.assertEqual(response_data['source'], source.name) signal = Signal.objects.get(pk=response_data['id']) self.assertEqual(signal.source, source.name)
def test_create_initial_signal_valid_source(self, validate_address): signal_count = Signal.objects.count() source, *_ = SourceFactory.create_batch(5) initial_data = copy.deepcopy(self.initial_data_base) initial_data['source'] = source.name response = self.client.post(self.list_endpoint, initial_data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Signal.objects.count(), signal_count + 1) response_data = response.json() self.assertEqual(response_data['source'], source.name) signal = Signal.objects.get(pk=response_data['id']) self.assertEqual(signal.source, source.name)