def setUp(self): self.layer = LayerFactory(name="layerLine") self.group = LayerGroup.objects.create(name='mygroup', slug='mygroup') self.group.layers.add(self.layer) 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 ] ] } } ] } ''')
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 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 setUp(self): self.client = APIClient() self.user = UserFactory(permissions=['geostore.can_manage_layers', ]) self.client.force_authenticate(user=self.user) self.point_layer = LayerFactory(name="no schema point geom", geom_type=GeometryTypes.Point) self.null_layer = LayerFactory(name="no schema null geom", geom_type=None)
class FillTilesCacheTestCase(TestCase): def setUp(self): self.layer = LayerFactory(name="layerLine") self.group = LayerGroup.objects.create(name='mygroup', slug='mygroup') self.group.layers.add(self.layer) 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_cache_filled(self): tile = VectorTile(self.layer) cache_version = get_cache_version(self.layer) x, y, z = 515, 373, 10 query_count_before = len(connection.queries) call_command('fill_tiles_cache', stdout=StringIO()) query_count_after = len(connection.queries) self.assertLess(query_count_before, query_count_after) tile.get_tile(x, y, z) self.assertIsNotNone( cache.get( tile.get_tile_cache_key(x, y, z), version=cache_version, ) ) self.assertEqual(len(connection.queries), query_count_after + 1)
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')
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 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(name="layerLine", settings=settings) self.group = LayerGroup.objects.create(name='mygroup', slug='mygroup') self.group.layers.add(self.layer) 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_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 test_relations_featuredetail_no_crud_view_boths(self): layer_destination = LayerFactory.create() layer_origin = LayerFactory.create() LayerRelation.objects.create(name='layer_layer', relation_type='distance', origin=layer_origin, destination=layer_destination, settings={"distance": 100}) response = self.client.get(reverse('feature-detail', args=(self.crud_view.layer_id, self.feature.identifier)), format="json") self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.json()['relations']), 0)
def test_layer_not_routable(self): layer = LayerFactory(routable=False) setting = RoutingSettingsFactory.create(provider="geostore", layer=layer, crud_view=self.crud_view) with self.assertRaises(ValidationError): setting.clean()
def setUp(self): self.layer = LayerFactory.create() self.client = APIClient() self.user = UserFactory(permissions=[ 'geostore.can_manage_layers', ]) self.client.force_authenticate(user=self.user)
def setUp(self): self.user = SuperUserFactory() self.client.force_authenticate(user=self.user) factory.random.reseed_random(42) self.layer = LayerFactory.create(add_random_features=20)
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('layer-shapefile', args=[self.layer.pk, ]) response = self.client.get(shape_url) self.assertEqual(HTTP_204_NO_CONTENT, response.status_code)
def test_extended_serializer_is_used(self): self.layer = LayerFactory() response = self.client.get( reverse('layer-detail', args=(self.layer.pk, ))) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() self.assertEqual(data['extended'], True)
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.layer = LayerFactory.create(add_features=5) self.group = LayerGroup.objects.create(name='mygroup', slug='mygroup') self.group.layers.add(self.layer) self.user = UserFactory() self.client.force_authenticate(self.user)
def test_shapefile_same_import_export(self): FeatureFactory(layer=self.layer, properties={'key1': [{ 'key3': 'hello world', }]}) shape_url = reverse('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('layer-shapefile', args=[ new_layer.pk, ]), { 'shapefile': shapefile, }, format="multipart") self.assertEqual(HTTP_200_OK, response.status_code) self.assertEqual(self.layer.features.first().properties, new_layer.features.first().properties)
def test_layer_processing_clear_output(self): geojson = get_files_tests('toulouse.geojson') call_command( 'import_geojson', f'{geojson}', verbosity=0) # Retrieve the layer in_layer = Layer.objects.first() out_layer = LayerFactory(name='out') FeatureFactory(layer=out_layer, properties="Test") self.assertEqual(out_layer.features.count(), 1) call_command( 'layer_processing', f'--layer-name-ins={in_layer.name}', f'--layer-pk-out={out_layer.pk}', f'--sql-centroid', f'-co', verbosity=0) out_layer = Layer.objects.get(name='out') self.assertTrue(out_layer.features.count() > 1) self.assertNotIn('Test', [feature.properties for feature in out_layer.features.all()])
def test_features_filter_by_properties_with_several_string_field(self): layer = LayerFactory() FeatureFactory( layer=layer, geom=self.fake_geometry, properties={ 'text': 'foobar', 'sentence': 'foobar is here' }, ) FeatureFactory( layer=layer, geom=self.fake_geometry, properties={ 'text': 'foo', 'sentence': 'foobar is missing' }, ) FeatureFactory( layer=layer, geom=self.fake_geometry, properties={ 'text': 'foobar', 'sentence': 'foobar is here' }, ) response = self.client.get( reverse('feature-list', kwargs={'layer': layer.pk}), { 'properties__text': 'foobar', 'properties__sentence': 'foobar is here' }) self.assertEqual(response.status_code, status.HTTP_200_OK) json_response = response.json() self.assertEqual(len(json_response), 2)
def setUp(self): self.user = UserFactory(permissions=['geostore.can_manage_layers', ]) self.client.force_authenticate(user=self.user) self.valid_schema = { "properties": { "name": { "type": "string" }, "age": { "type": "integer" } } } self.property_schema_layer = LayerFactory( name="tree", schema=self.valid_schema ) Feature.objects.bulk_create([ Feature(layer=self.property_schema_layer, properties={'name': '1', 'age': 1}, geom='POINT(0 0)'), Feature(layer=self.property_schema_layer, properties={'name': '2', 'age': 2}, geom='POINT(0 0)'), Feature(layer=self.property_schema_layer, properties={'name': '10', 'age': 10}, geom='POINT(0 0)') ])
def test_relations_featurelist_crud_view_do_not_show(self, mocked): mocked.return_value = True layer_destination = LayerFactory.create() crud_view = factories.CrudViewFactory() LayerRelation.objects.create(name='layer_view', relation_type='distance', origin=self.crud_view.layer, destination=layer_destination, settings={"distance": 100}) layer_rel = LayerRelation.objects.create(name='view_view', relation_type='distance', origin=self.crud_view.layer, destination=crud_view.layer, settings={"distance": 100}) response = self.client.get(reverse('feature-list', args=(self.crud_view.layer_id, )), data={}, format="json") url_relation = reverse('feature-relation', args=(self.crud_view.layer_id, self.feature.identifier, layer_rel.pk)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.json()[0]['relations']['view_view'], url_relation) self.assertEqual(len(response.json()[0]['relations']), 1)
def setUpTestData(cls): # create a geometry undefined layer with all kind of geometry as features props = {"name": "test", "label": "Test"} cls.layer = LayerFactory() cls.point = FeatureFactory(layer=cls.layer, geom="POINT(0 0)", properties=props) cls.line = FeatureFactory(layer=cls.layer, geom="LINESTRING(0 0, 1 1)", properties=props) cls.polygon = FeatureFactory( layer=cls.layer, geom= "POLYGON((0 0, 1 0, 1 1, 0 1, 0 0), (0.4 0.4, 0.5 0.4, 0.5 0.5, 0.4 0.5, 0.4 0.4 ))", properties=props) cls.multipoint = FeatureFactory(layer=cls.layer, geom="MULTIPOINT((0 0), (1 0))", properties=props) cls.multilinestring = FeatureFactory( layer=cls.layer, geom="MULTILINESTRING((3 4,10 50,20 25),(-5 -8,-10 -8,-15 -4))", properties=props) cls.multipolygon = FeatureFactory( layer=cls.layer, geom= "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),((6 3,9 2,9 4,6 3)))", properties=props) cls.geometrycollection = FeatureFactory( layer=cls.layer, geom="GEOMETRYCOLLECTION(POINT(4 6),LINESTRING(4 6,7 10))", properties=props)
def test_relations_featuredetail_crud_view_do_not_show(self, mocked): mocked.return_value = True layer_destination = LayerFactory.create() crud_view = factories.CrudViewFactory() LayerRelation.objects.create(name='layer_view', relation_type='distance', origin=self.crud_view.layer, destination=layer_destination, settings={"distance": 100}) layer_rel = LayerRelation.objects.create(name='view_view', relation_type='distance', origin=self.crud_view.layer, destination=crud_view.layer, settings={"distance": 100}) response = self.client.get(reverse('feature-detail', args=(self.crud_view.layer_id, self.feature.identifier)), format="json") url_relation = reverse('feature-relation', args=(self.crud_view.layer_id, self.feature.identifier, layer_rel.pk)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.json()['relations'][0]['label'], "view_view") self.assertEqual(response.json()['relations'][0]['url'], url_relation) self.assertEqual(response.json()['relations'][0]['empty'], True) self.assertEqual(len(response.json()['relations']), 1) Feature.objects.create(geom=Point(0, 0, srid=4326), layer=crud_view.layer) self.feature.sync_relations(layer_rel.pk) response = self.client.get(reverse('feature-detail', args=(self.crud_view.layer_id, self.feature.identifier)), format="json") self.assertEqual(response.json()['relations'][0]['empty'], False)
def test_features_intersections(self): layer = LayerFactory() FeatureFactory(layer=layer, geom=GEOSGeometry( json.dumps(self.intersect_ref_geometry))) """The layer below must intersect""" response = self.client.post( reverse('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('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('layer-intersects', args=[ layer.pk, ]), {'geom': '''Invalid geometry'''}) self.assertEqual(HTTP_400_BAD_REQUEST, response.status_code)
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=geostore.tests.test_commands.test_layer_processing.python_function_raise', verbosity=0)
def test_import_geojson_layer_with_pk_layer(self): layer = LayerFactory() self.assertEqual(len(layer.features.all()), 0) call_command('import_geojson', get_files_tests('toulouse.geojson'), layer_pk=layer.pk, verbosity=0) self.assertEqual(len(layer.features.all()), 838)
def test_update_topology_routing_fail(self): layer = LayerFactory(geom_type=GeometryTypes.Point) 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_python(self): layer = LayerFactory() call_command( 'layer_processing', f'--layer-name-ins={layer.name}', f'--python=geostore.tests.test_commands.test_layer_processing.python_function', verbosity=0) self.assertTrue(Layer.objects.filter(name="New_name").exists())
def test_provider_with_layer_and_transit(self): layer = LayerFactory(routable=True) setting = RoutingSettingsFactory.create(provider="geostore", mapbox_transit='cycling', layer=layer, crud_view=self.crud_view) with self.assertRaises(ValidationError): setting.clean()