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