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)
