class LayerExportGeometryTestCase(TestCase): def setUp(self): self.layer = LayerFactory() self.fake_geometry = {"type": "Point", "coordinates": [2., 45.]} def test_to_geojson(self): # Create at least one feature in the layer, so it's not empty FeatureFactory(layer=self.layer) FeatureFactory( layer=self.layer, geom=GEOSGeometry(json.dumps(self.fake_geometry)), properties={ 'number': 1, 'digit': 34 }, ) self.assertEqual( str(self.layer.to_geojson()['features'][0]['geometry']), "{'type': 'Point', 'coordinates': [2.4609375, 45.583289756006316]}" ) self.assertEqual( str(self.layer.to_geojson()['features'][1]['geometry']), "{'type': 'Point', 'coordinates': [2.0, 45.0]}") self.assertEqual( str(self.layer.to_geojson()['features'][1]['properties']), "{'digit': 34, 'number': 1}")
def setUp(self): self.layer = LayerFactory(group=self.group_name, name="layerLine") self.layer.from_geojson(geojson_data=''' { "type": "FeatureCollection", "features": [ { "type": "Feature", "properties": { "foo": "bar", "baba": "fifi" }, "geometry": { "type": "LineString", "coordinates": [ [ 1.3700294494628906, 43.603640347220924 ], [ 1.2984466552734375, 43.57902295875415 ] ] } } ] } ''')
def setUp(self): settings = {'metadata': {'attribution': 'plop'}} self.layer = LayerFactory(group=self.group_name, name="layerLine", settings=settings) self.layer.from_geojson(geojson_data=''' { "type": "FeatureCollection", "features": [ { "type": "Feature", "properties": { "foo": "bar", "baba": "fifi" }, "geometry": { "type": "LineString", "coordinates": [ [ 1.3700294494628906, 43.603640347220924 ], [ 1.2984466552734375, 43.57902295875415 ] ] } } ] } ''') self.layerPoint = LayerFactory(group="yourgroup", name="layerPoint", settings=settings) self.layerPoint.from_geojson(geojson_data=''' { "type": "FeatureCollection", "features": [ { "type": "Feature", "properties": { "foo": "bar" }, "geometry": { "type": "Point", "coordinates": [ 1.3700294494628906, 43.603640347220924 ] } } ] } ''')
def test_shapefile_import(self): layer = LayerFactory() shapefile_path = get_files_tests('shapefile-WGS84.zip') with open(shapefile_path, 'rb') as shapefile: layer.from_shapefile(shapefile) self.assertEqual(8, layer.features.all().count())
def test_zoom_update(self): self.layer = LayerFactory() with self.assertRaises(KeyError): self.layer.layer_settings('tiles', 'maxzoom') # Call the decorator manualy on nop lambda self.layer.beta_lambda = lambda *args, **kargs: False zoom_update(self.layer.beta_lambda)(self.layer) self.assertEqual( self.layer.layer_settings('tiles', 'maxzoom') is not None, True)
def test_layer_processing_make_valid_fail_multiple_pk_ins(self): layer_1 = LayerFactory() layer_2 = LayerFactory() with self.assertRaises(ValueError) as error: call_command('layer_processing', f'--layer-name-ins={layer_1.name}', f'--layer-name-ins={layer_2.name}', f'--make-valid', verbosity=0) self.assertEqual(str(error.exception), 'Exactly one input layer required')
class FillTilesCacheTestCase(TestCase): group_name = 'mygroup' def setUp(self): self.layer = LayerFactory(group=self.group_name, name="layerLine") self.layer.from_geojson(geojson_data=''' { "type": "FeatureCollection", "features": [ { "type": "Feature", "properties": { "foo": "bar", "baba": "fifi" }, "geometry": { "type": "LineString", "coordinates": [ [ 1.3700294494628906, 43.603640347220924 ], [ 1.2984466552734375, 43.57902295875415 ] ] } } ] } ''') def test_update_topology_routing_fail(self): output = StringIO() features = self.layer.features.all() query_count_before = len(connection.queries) call_command('fill_tiles_cache', verbosity=1, stdout=output) query_count_after = len(connection.queries) self.assertLess(query_count_before, query_count_after) tile = VectorTile(self.layer) x, y, z = 515, 373, 10 pixel_buffer, features_filter, properties_filter, features_limit = \ 4, None, None, 10000 tile.get_tile(x, y, z, pixel_buffer, features_filter, properties_filter, features_limit, features) self.assertIsNotNone( cache.get( tile.get_tile_cache_key(x, y, z, pixel_buffer, features_filter, properties_filter, features_limit))) self.assertEqual(len(connection.queries), query_count_after)
def test_properties_serializations(self): layer = LayerFactory() test_properties = { 'int': 42, 'str': 'test string', 'dict': { 'a': 'b', } } serialized_properties = layer._get_serialized_properties( test_properties) self.assertEqual(serialized_properties['str'], test_properties['str']) self.assertIsInstance(serialized_properties['int'], str) self.assertIsInstance(serialized_properties['dict'], str)
def setUp(self): # Same as default with properties filter not None settings = { 'metadata': { 'attribution': 'plop' }, 'tiles': { 'minzoom': 0, 'maxzoom': 22, 'pixel_buffer': 4, 'features_filter': None, # Json 'properties_filter': 'Test', # Array of string 'features_limit': 10000, } } self.layer = LayerFactory(group=self.group_name, name="layerLine", settings=settings) self.geojson_data = ''' { "type": "FeatureCollection", "features": [ { "type": "Feature", "properties": { "foo": "bar", "baba": "fifi" }, "geometry": { "type": "LineString", "coordinates": [ [ 1.3700294494628906, 43.603640347220924 ], [ 1.2984466552734375, 43.57902295875415 ] ] } } ] } ''' self.layer.from_geojson(geojson_data=self.geojson_data)
def test_shapefile_same_import_export(self): self.user.user_permissions.add( Permission.objects.get(codename='can_import_layers')) self.user.user_permissions.add( Permission.objects.get(codename='can_export_layers')) FeatureFactory(layer=self.layer, properties={'key1': [{ 'key3': 'hello world', }]}) shape_url = reverse('terra:layer-shapefile', args=[ self.layer.pk, ]) response = self.client.get(shape_url) self.assertEqual(HTTP_200_OK, response.status_code) shapefile = SimpleUploadedFile('shapefile-WGS84.zip', response.content) new_layer = LayerFactory() response = self.client.post( reverse('terra:layer-shapefile', args=[ new_layer.pk, ]), { 'shapefile': shapefile, }) self.assertEqual(HTTP_200_OK, response.status_code) self.assertEqual(self.layer.features.first().properties, new_layer.features.first().properties)
def test_features_intersections(self): layer = LayerFactory(group=self.group_name) FeatureFactory(layer=layer, geom=GEOSGeometry( json.dumps(self.intersect_ref_geometry))) """The layer below must intersect""" response = self.client.post( reverse('terra:layer-intersects', args=[ layer.pk, ]), {'geom': json.dumps(self.intersect_geometry)}) self.assertEqual(HTTP_200_OK, response.status_code) response = response.json().get('results', {}) self.assertEqual(1, len(response.get('features'))) self.assertDictEqual(self.intersect_ref_geometry, response.get('features')[0].get('geometry')) """The layer below must NOT intersect""" response = self.client.post( reverse('terra:layer-intersects', args=[ layer.name, ]), {'geom': json.dumps(self.fake_geometry)}) self.assertEqual(HTTP_200_OK, response.status_code) response = response.json().get('results', {}) self.assertEqual(0, len(response.get('features'))) """Tests that the intersects view throw an error if geometry is invalid """ response = self.client.post( reverse('terra:layer-intersects', args=[ layer.pk, ]), {'geom': '''Invalid geometry'''}) self.assertEqual(HTTP_400_BAD_REQUEST, response.status_code)
def test_retrieve_related_document(self): layer = LayerFactory() userrequest = UserRequest.objects.create( owner=self.user, layer=layer, properties={}, ) img = os.path.join(os.path.dirname(__file__), 'files', 'img.png') with open(img, 'rb') as f: RelatedDocument.objects.create( key='document_to_test', object_id=userrequest.pk, content_type=ContentType.objects.get_for_model(userrequest.__class__), document=File(f) ) self._set_permissions([ 'can_read_self_requests', 'can_create_requests', ]) response = self.client.get( resolve_url('trrequests:request-detail', pk=userrequest.pk), ) self.assertEqual(status.HTTP_200_OK, response.status_code) json_reponse = response.json() self.assertIn( f'data:{magic.from_file(img, mime=True)};base64,', json_reponse['documents'][0]['document'] ) self._clean_permissions()
def test_returned_document_are_base64(self): layer = LayerFactory() userrequest = UserRequest.objects.create( owner=self.user, layer=layer, properties={}, ) img = os.path.join(os.path.dirname(__file__), 'files', 'img.png') with open(img, 'rb') as f: self._set_permissions([ 'can_read_self_requests', 'can_create_requests', ]) document = (f'data:image/png;base64,' f'{(base64.b64encode(f.read())).decode("utf-8")}') response = self.client.patch( resolve_url('trrequests:request-detail', pk=userrequest.pk), { 'geojson': self.geojson, 'documents': [{ 'key': 'doctest', 'document': document, }], } ) self.assertEqual(response.status_code, status.HTTP_200_OK) json_response = response.json() self.assertEqual( document, json_response['documents'][0]['document'] ) self._clean_permissions()
def test_update_userrequest_with_wrong_document_format(self): layer = LayerFactory() userrequest = UserRequest.objects.create( owner=self.user, layer=layer, properties={}, ) self._set_permissions(['can_read_self_requests', ]) response = self.client.put( resolve_url('trrequests:request-detail', pk=userrequest.pk), { 'properties': {'noupdate': 'tada'}, 'geojson': {}, 'documents': [{ "key": "activity-0", "document": ("documents/trrequests_userrequest/" f"{userrequest.pk}/activity-0") }], } ) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self._clean_permissions() self.assertFalse(UserRequest.objects .filter(properties__noupdate='tada') .exists()) self.assertFalse(UserRequest.objects .filter(documents__key="activity-0") .exists())
def test_userrequest_patched(self): self._set_permissions(['can_read_self_requests', ]) old_properties = {'property': ''} userrequest = UserRequest.objects.create(owner=self.user, layer=LayerFactory(), properties=old_properties) receiver_callback = MagicMock() event.connect(receiver_callback) response = self.client.patch(reverse('trrequests:request-detail', kwargs={'pk': userrequest.pk}), {'properties': {'property': 'value'}}, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) receiver_callback.assert_called_with( sender=UserRequestSerializer, signal=event, action='USERREQUEST_PROPERTIES_CHANGED', user=self.user, instance=userrequest, old_properties=old_properties ) event.disconnect(receiver_callback) self._clean_permissions()
def setUp(self): self.fake_geometry = {"type": "Point", "coordinates": [2., 45.]} self.intersect_geometry = { "type": "LineString", "coordinates": [[1.3839340209960938, 43.602521593464054], [1.4869308471679688, 43.60376465190968]] } self.intersect_ref_geometry = { "type": "LineString", "coordinates": [[1.440925598144531, 43.64750394449096], [1.440582275390625, 43.574421623084234]] } self.fake_linestring = { "type": "LineString", "coordinates": [ [1.3839340209960938, 43.602521593464054], ] } self.fake_polygon = { "type": "Polygon", "coordinates": [[[1.3839340209960938, 43.602521593464054], [1.440582275390625, 43.574421623084234]]] } self.group_name = 'mygroup' self.layer = LayerFactory.create(group=self.group_name, add_features=5) self.user = UserFactory() self.client.force_login(self.user)
def test_features_filter_by_properties_with_several_string_field(self): layer = LayerFactory() FeatureFactory( layer=layer, geom=GEOSGeometry(json.dumps(self.fake_geometry)), properties={ 'text': 'foobar', 'sentence': 'foobar is here' }, ) FeatureFactory( layer=layer, geom=GEOSGeometry(json.dumps(self.fake_geometry)), properties={ 'text': 'foo', 'sentence': 'foobar is missing' }, ) FeatureFactory( layer=layer, geom=GEOSGeometry(json.dumps(self.fake_geometry)), properties={ 'text': 'foobar', 'sentence': 'foobar is here' }, ) response = self.client.get( reverse('terra:feature-list', kwargs={'layer': layer.pk}), { 'properties__text': 'foobar', 'properties__sentence': 'foobar is here' }) self.assertEqual(response.status_code, HTTP_200_OK) json_response = response.json() self.assertEqual(json_response['count'], 2) self.assertEqual(len(json_response['results']), 2)
def test_update_topology_routing_fail(self): layer = LayerFactory() with self.assertRaises(CommandError) as error: call_command('update_topology', f'--layer-pk={layer.pk}', verbosity=0) self.assertEqual('An error occuring during topology update', str(error.exception))
def test_layer_processing_sql_like_simple_sql(self): layer = LayerFactory() call_command( 'layer_processing', f'--layer-name-ins={layer.name}', f'--sql=SELECT identifier, properties, ST_MakeValid(geom::geometry) AS geom FROM in0', verbosity=0) self.assertEqual(len(Layer.objects.all()), 2)
def test_layer_processing_python_raise(self): layer = LayerFactory() with self.assertRaises(Exception): call_command( 'layer_processing', f'--layer-name-ins={layer.name}', f'--python=terracommon.terra.tests.test_commands.test_layer_processing.python_function_raise', verbosity=0)
def test_layer_processing_python(self): layer = LayerFactory() call_command( 'layer_processing', f'--layer-name-ins={layer.name}', f'--python=terracommon.terra.tests.test_commands.test_layer_processing.python_function', verbosity=0) self.assertTrue(Layer.objects.filter(name="New_name").exists())
def test_import_geojson_layer_with_pk_layer(self): layer = LayerFactory() self.assertEqual(len(layer.features.all()), 0) geojson_sample = get_files_tests('toulouse.geojson') call_command('import_geojson', f'--layer-pk={layer.pk}', geojson_sample, verbosity=0) self.assertEqual(len(layer.features.all()), 838)
def setUp(self): self.client = APIClient() self.user = UserFactory() self.client.force_authenticate(user=self.user) self.no_schema_layer = LayerFactory(name="no schema") self.valid_schema = { "properties": { "name": { "type": "string" }, "age": { "type": "integer" } } } self.property_schema_layer = LayerFactory(name="tree", schema=self.valid_schema)
def test_layer_processing_fail_wrong_pk_out(self): layer = LayerFactory() with self.assertRaises(CommandError) as error: call_command('layer_processing', f'--layer-pk-ins={layer.pk}', f'--layer-pk-out=999', f'--sql-centroid', verbosity=0) self.assertIn("Layer with pk 999 doesn't exist", str(error.exception))
def test_empty_shapefile_export(self): # Create en ampty layer to test its behavior LayerFactory() self.user.user_permissions.add( Permission.objects.get(codename='can_export_layers')) shape_url = reverse('terra:layer-shapefile', args=[ self.layer.pk, ]) response = self.client.get(shape_url) self.assertEqual(HTTP_204_NO_CONTENT, response.status_code)
def test_no_shapefile_import(self): self.user.user_permissions.add( Permission.objects.get(codename='can_import_layers')) layer = LayerFactory() response = self.client.post( reverse('terra:layer-shapefile', args=[ layer.pk, ]), ) self.assertEqual(HTTP_400_BAD_REQUEST, response.status_code)
def test_layer_processing_make_valid_polygon(self): layer = LayerFactory() output = StringIO() call_command('layer_processing', f'--layer-pk-ins={layer.id}', f'--make-valid', verbosity=1, stdout=output) self.assertIn('The created layer pk is', output.getvalue()) self.assertEqual(len(Layer.objects.all()), 2)
def test_import_shapefile_layer_with_pk_layer(self): # Sample ShapeFile layer = LayerFactory() self.assertEqual(len(layer.features.all()), 0) shapefile_path = get_files_tests('shapefile-WGS84.zip') sample_shapefile = open(shapefile_path, 'rb') call_command( 'import_shapefile', f'--layer-pk={layer.pk}', '-iID_PG', '-gs', sample_shapefile.name, verbosity=0 ) self.assertEqual(len(layer.features.all()), 8)
def test_good_query_on_existing_layer(self, mocked_get): layer = LayerFactory() type_feature = 'points' mocked_get.return_value.status_code = 200 mocked_get.return_value.content = self.get_good_data() query = 'good query' output = StringIO() call_command( 'import_osm', f'{query}', f'-pk={layer.pk}', f'-t{type_feature}', '-v 1', stderr=output) self.assertIn("Warning 1", output.getvalue()) self.assertEqual(layer.features.count(), 2)
def test_feature_from_layer_name(self): layer = LayerFactory() feature = FeatureFactory( layer=layer, geom=GEOSGeometry(json.dumps(self.fake_geometry)), properties={ 'text': 'foobar', 'sentence': 'foobar is here' }, ) response = self.client.get( reverse('terra:feature-detail', kwargs={ 'layer': str(layer.name), 'identifier': str(feature.identifier) }), ) self.assertEqual(response.status_code, HTTP_200_OK)