def test_wms_ows_proxy(service_endpoint):
username = '******'
layername = 'test_wms_ows_proxy_layer'
authn_headers = get_authz_headers(username)
process_client.ensure_reserved_username(username, headers=authn_headers)
process_client.publish_workspace_layer(username,
layername,
headers=authn_headers)
wms_url = geoserver_client.get_wms_url(username, service_endpoint)
layer_info = process_client.get_workspace_layer(username,
layername,
headers=authn_headers)
tn_bbox = get_square_bbox(layer_info['bounding_box'])
from layman.layer.geoserver.wms import VERSION
response = get_layer_thumbnail(wms_url,
layername,
tn_bbox,
headers=authn_headers,
wms_version=VERSION)
response.raise_for_status()
assert 'image' in response.headers['content-type']
process_client.delete_workspace_layer(username,
layername,
headers=authn_headers)
def test_wms_workspace():
workspace = 'test_wms_workspace_workspace'
layername = 'test_wms_workspace_layer'
wms_url = f"http://localhost:8000/geoserver/test_wms_workspace_workspace{settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX}/ows"
wfs_url = f"http://localhost:8000/geoserver/test_wms_workspace_workspace/wfs"
process_client.publish_workspace_layer(workspace, layername)
r_json = process_client.get_workspace_layer(workspace, layername)
assert r_json['wms']['url'] == wms_url
assert r_json['wfs']['url'] == wfs_url
with app.app_context():
internal_wms_url = url_for('geoserver_proxy_bp.proxy', subpath=workspace + settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX + '/ows')
internal_wfs_url = url_for('geoserver_proxy_bp.proxy', subpath=workspace + '/wfs')
r_wms = requests.get(internal_wms_url, params={
'service': 'WMS',
'request': 'GetCapabilities',
'version': '1.3.0',
})
assert r_wms.status_code == 200
r_wfs = requests.get(internal_wfs_url, params={
'service': 'WFS',
'request': 'GetCapabilities',
'version': '2.0.0',
})
assert r_wfs.status_code == 200
process_client.delete_workspace_layer(workspace, layername)
def delete_layer_after_test():
def register_layer_to_delete(workspace, layername):
LAYERS_TO_DELETE_AFTER_TEST.append((workspace, layername))
yield register_layer_to_delete
for workspace, layername in LAYERS_TO_DELETE_AFTER_TEST:
process_client.delete_workspace_layer(workspace, layername)
def test_bbox():
workspace = 'test_bbox_workspace'
layer = 'test_bbox_layer'
process_client.publish_workspace_layer(
workspace,
layer,
)
with app.app_context():
info = util.get_layer_info(workspace, layer)
assert_util.assert_same_bboxes(info['bounding_box'],
test_data.SMALL_LAYER_BBOX, 0.00001)
process_client.patch_workspace_layer(
workspace,
layer,
file_paths=[
'test/data/bbox/layer_3_3-5_5.geojson',
])
with app.app_context():
info = util.get_layer_info(workspace, layer)
assert_util.assert_same_bboxes(info['bounding_box'],
[3000, 3000, 5000, 5000], 0.1)
process_client.delete_workspace_layer(workspace, layer)
def test_migrate_input_sld_directory_to_input_style(ensure_layer):
workspace = 'test_migrate_input_sld_directory_to_input_style_workspace'
layer = 'test_migrate_input_sld_directory_to_input_style_layer'
with app.app_context():
input_sld_dir = os.path.join(
layer_fs_util.get_layer_dir(workspace, layer), 'input_sld')
input_style_dir = os.path.join(
layer_fs_util.get_layer_dir(workspace, layer), 'input_style')
assert input_style_dir == input_style.get_layer_input_style_dir(
workspace, layer)
ensure_layer(workspace, layer)
assert os.path.exists(input_sld_dir)
assert not os.path.exists(input_style_dir)
assert os.path.exists(os.path.join(input_sld_dir, f'{layer}.xml'))
upgrade_v1_10.migrate_input_sld_directory_to_input_style()
assert not os.path.exists(input_sld_dir)
assert os.path.exists(input_style_dir)
assert os.path.exists(os.path.join(input_style_dir, f'{layer}.xml'))
process_client.delete_workspace_layer(workspace, layer)
def prepare_publications():
process_client.publish_workspace_layer(USERNAME, LAYERNAME)
process_client.publish_workspace_map(USERNAME, MAPNAME)
yield
process_client.delete_workspace_layer(USERNAME, LAYERNAME)
process_client.delete_workspace_map(USERNAME, MAPNAME)
with app.app_context():
pubs = pub_util.get_publication_infos(USERNAME)
assert len(pubs) == 0
def test_migrate_wms_workspace_metadata(ensure_layer):
def assert_md_keys(layer_info):
for key in ['comparison_url', 'csw_url', 'identifier', 'record_url']:
assert key in layer_info['metadata']
workspace = 'test_migrate_wms_workspace_metadata_workspace'
layer = 'test_migrate_wms_workspace_metadata_layer'
ensure_layer(workspace, layer)
with app.app_context():
upgrade_v1_10.migrate_layers_to_wms_workspace(workspace)
wms_workspace = wms.get_geoserver_workspace(workspace)
wms_old_prefix = f"http://localhost:8000/geoserver/{workspace}/ows"
wms_new_prefix = f"http://localhost:8000/geoserver/{wms_workspace}/ows"
csw_prefix = f"http://localhost:3080/csw"
layer_info = process_client.get_workspace_layer(workspace, layer)
assert_md_keys(layer_info)
md_comparison = process_client.get_workspace_layer_metadata_comparison(
workspace, layer)
md_props = md_comparison['metadata_properties']
csw_src_key = process_client.get_source_key_from_metadata_comparison(
md_comparison, csw_prefix)
assert csw_src_key is not None
assert md_props['wms_url']['equal'] is False
assert md_props['wms_url']['equal_or_null'] is False
assert md_props['wms_url']['values'][csw_src_key].startswith(
wms_old_prefix)
with app.app_context():
upgrade_v1_10.migrate_metadata_records(workspace)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert_md_keys(layer_info)
md_comparison = process_client.get_workspace_layer_metadata_comparison(
workspace, layer)
md_props = md_comparison['metadata_properties']
csw_src_key = process_client.get_source_key_from_metadata_comparison(
md_comparison, csw_prefix)
assert csw_src_key is not None
assert md_props['wms_url']['values'][csw_src_key].startswith(
wms_new_prefix)
for value in md_props['wms_url']['values'].values():
assert value.startswith(wms_new_prefix)
assert md_props['wms_url']['equal'] is True
assert md_props['wms_url']['equal_or_null'] is True
process_client.delete_workspace_layer(workspace, layer)
def test_wfs_proxy():
username = '******'
layername1 = 'ne_countries'
username2 = 'testproxy2'
authn_headers1 = get_authz_headers(username)
process_client.reserve_username(username, headers=authn_headers1)
process_client.publish_workspace_layer(username,
layername1,
headers=authn_headers1)
data_xml = data_wfs.get_wfs20_insert_points(username, layername1)
process_client.post_wfst(data_xml,
headers=authn_headers1,
workspace=username)
# Testing, that user1 is able to write his own layer through general WFS endpoint
process_client.post_wfst(data_xml, headers=authn_headers1)
# Testing, that user2 is not able to write to layer of user1
authn_headers2 = get_authz_headers(username2)
process_client.reserve_username(username2, headers=authn_headers2)
with pytest.raises(GS_Error) as exc:
process_client.post_wfst(data_xml,
headers=authn_headers2,
workspace=username)
assert exc.value.data['status_code'] == 400
# Testing, that user2 is not able to write user1's layer through general WFS endpoint
with pytest.raises(GS_Error) as exc:
process_client.post_wfst(data_xml, headers=authn_headers2)
assert exc.value.data['status_code'] == 400
# Test anonymous
with pytest.raises(GS_Error) as exc:
process_client.post_wfst(data_xml, workspace=username)
assert exc.value.data['status_code'] == 400
# Test fraud header
headers_fraud = {
settings.LAYMAN_GS_AUTHN_HTTP_HEADER_ATTRIBUTE: username,
}
with pytest.raises(GS_Error) as exc:
process_client.post_wfst(data_xml, headers=headers_fraud)
assert exc.value.data['status_code'] == 400
process_client.delete_workspace_layer(username,
layername1,
headers=authn_headers1)
def test_rest_get():
username = '******'
layername = 'layer_wfs_proxy_test'
process_client.publish_workspace_layer(username, layername)
data_xml = data_wfs.get_wfs20_insert_points(username, layername)
process_client.post_wfst(data_xml, workspace=username)
process_client.post_wfst(data_xml)
process_client.delete_workspace_layer(username, layername)
def test_access_rights(access_rights_and_expected_list, use_file):
owner_authn_headers = client_util.get_authz_headers(USERNAME)
other_authn_headers = client_util.get_authz_headers(USERNAME2)
post_method = client_util.publish_workspace_layer
patch_method = client_util.patch_workspace_layer
full_access_rights = {
'read': access_rights_and_expected_list[0]['read'],
'write': access_rights_and_expected_list[0]['write'],
}
roles_to_test = full_access_rights.copy()
for idx, access_rights_and_expected in enumerate(
access_rights_and_expected_list):
write_method = patch_method if idx > 0 else post_method
access_rights = {}
for right_type in ['read', 'write']:
if access_rights_and_expected.get(right_type):
roles_to_test[right_type] = access_rights_and_expected[
right_type]
access_rights[right_type] = access_rights_and_expected[
right_type]
write_method(
USERNAME,
LAYERNAME,
access_rights={
key: ','.join(value)
for key, value in access_rights.items()
},
headers=owner_authn_headers,
file_paths=[
'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson'
] if use_file else None)
client_util.assert_workspace_layers(USERNAME, [LAYERNAME],
owner_authn_headers)
assert_gs_user_and_roles(USERNAME)
assert_gs_layer_data_security(USERNAME, LAYERNAME, roles_to_test)
assert_layman_layer_access_rights(USERNAME, LAYERNAME, roles_to_test)
assert_wms_access(USERNAME, owner_authn_headers, [LAYERNAME])
assert_wms_access(
USERNAME, other_authn_headers,
access_rights_and_expected['expected_other_user_layers'])
assert_wms_access(
USERNAME, None,
access_rights_and_expected['expected_anonymous_layers'])
client_util.delete_workspace_layer(USERNAME,
LAYERNAME,
headers=owner_authn_headers)
def provide_data(self):
for workspace, layer in self.layers:
process_client.publish_workspace_layer(workspace, layer)
for file in os.listdir(self.directory):
mapname = os.path.splitext(file)[0]
file_path = os.path.join(self.directory, file)
process_client.publish_workspace_map(self.workspace,
mapname,
file_paths=[file_path])
self.maps.add((self.workspace, mapname))
yield
for map_workspace, map_name in self.maps:
process_client.delete_workspace_map(map_workspace, map_name)
for workspace, layer in self.layers:
process_client.delete_workspace_layer(workspace, layer)
def test_geometry_types(layer, exp_db_types, qml_geometry_dict):
def get_qml_style_path(style_name):
return f'/code/sample/data/geometry-types/{style_name}.qml' if style_name else None
workspace = 'test_geometry_types_workspace'
process_client.publish_workspace_layer(
workspace,
layer,
file_paths=[f'/code/sample/data/geometry-types/{layer}.geojson'],
)
with app.app_context():
db_types = db.get_geometry_types(workspace, layer)
assert set(db_types) == exp_db_types
qgis_geometries = ['Point', 'Line', 'Polygon', 'Unknown geometry']
old_qml_style_name = None
for qml_geometry in qgis_geometries:
exp_source_type, new_qml_style_name = qml_geometry_dict.get(
qml_geometry, (None, None))
if exp_source_type is None:
with pytest.raises(LaymanError) as excinfo:
util.get_source_type(db_types, qml_geometry)
assert excinfo.value.code == 47, f"qml_geometry={qml_geometry}, exp_source_type={exp_source_type}"
else:
source_type = util.get_source_type(db_types, qml_geometry)
assert source_type == exp_source_type, f"qml_geometry={qml_geometry}, exp_source_type={exp_source_type}, " \
f"source_type={source_type}, db_types={db_types}"
if new_qml_style_name:
if new_qml_style_name != old_qml_style_name:
process_client.patch_workspace_layer(
workspace,
layer,
style_file=get_qml_style_path(new_qml_style_name))
old_qml_style_name = new_qml_style_name
with app.app_context():
qml = util.get_original_style_xml(workspace, layer)
found_qml_geometry = util.get_qml_geometry_from_qml(qml)
assert found_qml_geometry == qml_geometry
exp_file_path = f'/code/sample/data/geometry-types/{new_qml_style_name}.png'
with app.app_context():
thumbnail_path = thumbnail.get_layer_thumbnail_path(
workspace, layer)
diff_pixels = test_util.compare_images(thumbnail_path,
exp_file_path)
assert diff_pixels == 0
process_client.delete_workspace_layer(workspace, layer)
def prep_test_get_publication_info():
auth_header_owner = process_client.get_authz_headers(USER_OWNER)
auth_header_without = process_client.get_authz_headers(USER_WITHOUT_RIGHTS)
process_client.ensure_reserved_username(USER_OWNER, headers=auth_header_owner)
process_client.ensure_reserved_username(USER_WITHOUT_RIGHTS, headers=auth_header_without)
access_rights = {'read': USER_OWNER,
'write': USER_OWNER}
process_client.publish_workspace_layer(USER_OWNER, LAYER, headers=auth_header_owner, access_rights=access_rights)
process_client.publish_workspace_map(USER_OWNER, MAP, headers=auth_header_owner, access_rights=access_rights)
yield
process_client.delete_workspace_map(USER_OWNER, MAP, headers=auth_header_owner)
process_client.delete_workspace_layer(USER_OWNER, LAYER, headers=auth_header_owner)
def test_geoserver_everyone_rights_repair():
workspace = 'test_geoserver_everyone_rights_repair_workspace'
layer = 'test_geoserver_everyone_rights_repair_layer'
expected_roles1 = {'ROLE_ANONYMOUS'}
expected_roles2 = {'ROLE_ANONYMOUS', 'ROLE_AUTHENTICATED'}
process_client.publish_workspace_layer(workspace, layer)
for right_type in ['read', 'write']:
gs_util.ensure_layer_security_roles(workspace, layer, expected_roles1,
right_type[0], auth)
assert_roles(workspace, layer, expected_roles1)
with app.app_context():
upgrade_v1_9.geoserver_everyone_rights_repair()
assert_roles(workspace, layer, expected_roles2)
process_client.delete_workspace_layer(workspace, layer)
def test_map_refresh_after_layer_change():
workspace = 'test_map_refresh_after_layer_change_workspace'
layer = 'test_map_refresh_after_layer_change_layer'
map = 'test_map_refresh_after_layer_change_map'
bbox = (1571000.0, 6268800.0, 1572590.8542062, 6269876.33561699)
process_client.publish_workspace_layer(workspace, layer)
map_file = map_data.create_map_with_internal_layers_file(
[(workspace, layer)], extent_3857=bbox)
process_client.publish_workspace_map(workspace, map, file_paths=[map_file])
assert_map_thumbnail(
workspace, map,
f'/code/test/data/thumbnail/map_with_internal_layer_basic.png')
# Test refresh map thumbnail after layer WFS-T query
data_xml = data_wfs.get_wfs20_insert_points(
workspace,
layer,
)
process_client.post_wfst(data_xml)
process_client.wait_for_publication_status(workspace,
process_client.LAYER_TYPE,
layer)
assert_map_thumbnail(
workspace, map,
f'/code/test/data/thumbnail/map_with_internal_layer_basic_after_wfst.png'
)
# Test refresh map thumbnail after patch layer
process_client.patch_workspace_layer(
workspace,
layer,
file_paths=['sample/layman.layer/small_layer.geojson'])
process_client.wait_for_publication_status(workspace,
process_client.LAYER_TYPE,
layer)
assert_map_thumbnail(
workspace, map,
f'/code/test/data/thumbnail/map_with_internal_layer_basic.png')
process_client.delete_workspace_map(workspace, map)
process_client.delete_workspace_layer(workspace, layer)
def test_adjust_prime_db_schema_for_bbox_search():
workspace = 'test_adjust_prime_db_schema_for_bbox_search_workspace'
layer = 'test_adjust_prime_db_schema_for_bbox_search_layer'
map = 'test_adjust_prime_db_schema_for_bbox_search_map'
expected_bbox_layer = test_data.SMALL_LAYER_BBOX
expected_bbox_map = test_data.SMALL_MAP_BBOX
process_client.publish_workspace_layer(workspace, layer)
process_client.publish_workspace_map(workspace, map)
with app.app_context():
statement = f'ALTER TABLE {db_schema}.publications ALTER COLUMN bbox DROP NOT NULL;'
db_util.run_statement(statement)
statement = f'update {db_schema}.publications set bbox = null;'
db_util.run_statement(statement)
query = f'select p.id from {db_schema}.publications p where p.bbox is not null;'
results = db_util.run_query(query)
assert not results, results
upgrade_v1_12.adjust_data_for_bbox_search()
for publication_type, publication, expected_bbox in [
('layman.layer', layer, expected_bbox_layer),
('layman.map', map, expected_bbox_map)
]:
query = f'''
select ST_XMIN(p.bbox),
ST_YMIN(p.bbox),
ST_XMAX(p.bbox),
ST_YMAX(p.bbox)
from {db_schema}.publications p inner join
{db_schema}.workspaces w on p.id_workspace = w.id
where w.name = %s
and p.type = %s
and p.name = %s
;'''
results = db_util.run_query(
query, (workspace, publication_type, publication))
assert len(results) == 1 and len(results[0]) == 4, results
bbox = results[0]
assert_util.assert_same_bboxes(bbox, expected_bbox, 0.000001)
process_client.delete_workspace_layer(workspace, layer)
def test_migrate_layer_metadata(ensure_layer):
def assert_md_keys(layer_info):
for key in ['comparison_url', 'csw_url', 'identifier', 'record_url']:
assert key in layer_info['metadata']
def assert_csw_value(md_comparison, prop_key, exp_value):
csw_prefix = f"http://localhost:3080/csw"
csw_src_key = process_client.get_source_key_from_metadata_comparison(
md_comparison, csw_prefix)
assert csw_src_key is not None
md_props = md_comparison['metadata_properties']
assert md_props[prop_key]['equal'] is True
assert md_props[prop_key]['equal_or_null'] is True
assert md_props[prop_key]['values'][csw_src_key] == exp_value
workspace = 'test_migrate_layer_metadata_workspace'
layer = 'test_migrate_layer_metadata_layer'
ensure_layer(workspace, layer)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert_md_keys(layer_info)
md_comparison = process_client.get_workspace_layer_metadata_comparison(
workspace, layer)
exp_wms_url = f"http://localhost:8000/geoserver/{workspace}_wms/ows?SERVICE=WMS&REQUEST=GetCapabilities&VERSION=1.3.0"
assert_csw_value(md_comparison, 'wms_url', exp_wms_url)
exp_wfs_url = f"http://localhost:8000/geoserver/{workspace}/wfs?SERVICE=WFS&REQUEST=GetCapabilities&VERSION=2.0.0"
assert_csw_value(md_comparison, 'wfs_url', exp_wfs_url)
with app.app_context():
upgrade_v1_12.migrate_layer_metadata(workspace)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert_md_keys(layer_info)
md_comparison = process_client.get_workspace_layer_metadata_comparison(
workspace, layer)
exp_wms_url = f"{exp_wms_url}&LAYERS={layer}"
assert_csw_value(md_comparison, 'wms_url', exp_wms_url)
exp_wfs_url = f"{exp_wfs_url}&LAYERS={layer}"
assert_csw_value(md_comparison, 'wfs_url', exp_wfs_url)
process_client.delete_workspace_layer(workspace, layer)
def test_wfs_bbox(style_file, thumbnail_style_postfix):
workspace = 'test_wfs_bbox_workspace'
layer = 'test_wfs_bbox_layer'
process_client.publish_workspace_layer(
workspace,
layer,
style_file=style_file,
)
assert_util.assert_all_sources_bbox(workspace, layer, SMALL_LAYER_BBOX)
expected_bbox = (1571000.0, 6268800.0, 1572590.8542062, 6269876.33561699)
method_bbox_thumbnail_tuples = [
(data_wfs.get_wfs20_insert_points, expected_bbox, '_bigger'),
(data_wfs.get_wfs20_delete_point, SMALL_LAYER_BBOX, ''),
]
for wfs_method, exp_bbox, thumbnail_bbox_postfix in method_bbox_thumbnail_tuples:
data_xml = wfs_method(
workspace,
layer,
)
process_client.post_wfst(data_xml, workspace=workspace)
process_client.wait_for_publication_status(workspace,
process_client.LAYER_TYPE,
layer)
assert_util.assert_all_sources_bbox(workspace, layer, exp_bbox)
expected_thumbnail_path = f'/code/sample/style/{layer}{thumbnail_style_postfix}{thumbnail_bbox_postfix}.png'
with app.app_context():
thumbnail_path = thumbnail.get_layer_thumbnail_path(
workspace, layer)
diffs = test_util.compare_images(expected_thumbnail_path,
thumbnail_path)
assert diffs < 100, expected_thumbnail_path
process_client.delete_workspace_layer(
workspace,
layer,
)
def test_adjust_prime_db_schema_for_last_change_search():
workspace = 'test_adjust_prime_db_schema_for_last_change_search_workspace'
layer = 'test_adjust_prime_db_schema_for_last_change_search_layer'
map = 'test_adjust_prime_db_schema_for_last_change_search_map'
timestamp1 = datetime.datetime.now(datetime.timezone.utc)
process_client.publish_workspace_layer(workspace, layer)
process_client.publish_workspace_map(workspace, map)
timestamp2 = datetime.datetime.now(datetime.timezone.utc)
with app.app_context():
statement = f'ALTER TABLE {db_schema}.publications ALTER COLUMN updated_at DROP NOT NULL;'
db_util.run_statement(statement)
statement = f'update {db_schema}.publications set updated_at = null;'
db_util.run_statement(statement)
query = f'select p.id from {db_schema}.publications p where p.updated_at is not null;'
results = db_util.run_query(query)
assert not results, results
upgrade_v1_12.adjust_data_for_last_change_search()
query = f'''
select p.updated_at
from {db_schema}.publications p inner join
{db_schema}.workspaces w on p.id_workspace = w.id
where w.name = %s
and p.type = %s
and p.name = %s
;'''
results = db_util.run_query(query, (workspace, 'layman.layer', layer))
assert len(results) == 1 and len(results[0]) == 1, results
layer_updated_at = results[0][0]
assert timestamp1 < layer_updated_at < timestamp2
results = db_util.run_query(query, (workspace, 'layman.map', map))
assert len(results) == 1 and len(results[0]) == 1, results
map_updated_at = results[0][0]
assert timestamp1 < map_updated_at < timestamp2
assert layer_updated_at < map_updated_at
process_client.delete_workspace_layer(workspace, layer)
process_client.delete_workspace_map(workspace, map)
def provide_publications(self):
username = self.username
authz_headers = self.authz_headers
layername = self.layername
mapname = self.mapname
process_client.ensure_reserved_username(username,
headers=authz_headers)
process_client.publish_workspace_layer(username,
layername,
headers=authz_headers)
process_client.publish_workspace_map(username,
mapname,
headers=authz_headers)
yield
process_client.delete_workspace_layer(username,
layername,
headers=authz_headers)
process_client.delete_workspace_map(username,
mapname,
headers=authz_headers)
def test_sld_style_applied_in_wms():
workspace = 'test_sld_style_wms_workspace'
layer = 'test_sld_style_wms_layer'
geojson_file = [
'/code/tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson'
]
style_file = 'sample/style/generic-blue_sld.xml'
expected_file = 'sample/style/countries_wms_blue.png'
obtained_file = 'tmp/artifacts/test_sld_style_applied_in_wms.png'
process_client.publish_workspace_layer(workspace,
layer,
file_paths=geojson_file,
style_file=style_file)
url = f"http://{settings.LAYMAN_SERVER_NAME}/geoserver/{workspace}_wms/wms?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&FORMAT=image/png&TRANSPARENT=true&STYLES=&LAYERS={workspace}:{layer}&SRS=EPSG:3857&WIDTH=768&HEIGHT=752&BBOX=-30022616.05686392,-30569903.32873383,30022616.05686392,28224386.44929134"
assert_util.assert_same_images(url, obtained_file, expected_file, 2000)
process_client.delete_workspace_layer(workspace, layer)
def test_get_layer_style_sld():
username = '******'
layername = 'test_get_layer_style_sld_layer'
process_client.publish_workspace_layer(
username,
layername,
)
with app.app_context():
rest_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
response = requests.get(rest_url)
assert response.status_code == 200, response.text
# lxml does not support importing from utf8 string
xml_tree = ET.fromstring(bytes(response.text, encoding='utf8'))
assert ET.QName(
xml_tree
) == "{http://www.opengis.net/sld}StyledLayerDescriptor", response.text
process_client.delete_workspace_layer(username, layername)
def test_publications_same_name():
publ_name = 'test_publications_same_name_publ'
username = '******'
username2 = 'test_publications_same_name_user2'
process_client.publish_workspace_layer(username, publ_name)
process_client.publish_workspace_map(username, publ_name)
process_client.publish_workspace_layer(username2, publ_name)
process_client.publish_workspace_map(username2, publ_name)
with app.app_context():
pubs = publications.get_publication_infos(username)
assert len(pubs) == 2
pubs = publications.get_publication_infos(username2)
assert len(pubs) == 2
pubs = publications.get_publication_infos()
assert len(pubs) >= 4
process_client.delete_workspace_layer(username, publ_name)
process_client.delete_workspace_map(username, publ_name)
process_client.delete_workspace_layer(username2, publ_name)
process_client.delete_workspace_map(username2, publ_name)
def test_sld_style_applied_in_thumbnail():
workspace = 'test_sld_style_applied_in_thumbnail_workspace'
layer = 'test_sld_style_applied_in_thumbnail_layer'
geojson_file = [
'/code/tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson'
]
style_file = 'sample/style/generic-blue_sld.xml'
expected_file = 'sample/style/test_sld_style_applied_in_thumbnail_layer.png'
process_client.publish_workspace_layer(workspace,
layer,
file_paths=geojson_file,
style_file=style_file)
with app.app_context():
thumbnail_path = thumbnail.get_layer_thumbnail_path(workspace, layer)
diffs = util.compare_images(expected_file, thumbnail_path)
assert diffs < 1000
process_client.delete_workspace_layer(workspace, layer)
def test_get_layer_style_qml():
username = '******'
layername = 'test_get_layer_style_sld_layer'
qml_file = 'sample/style/small_layer.qml'
process_client.publish_workspace_layer(username,
layername,
style_file=qml_file)
with app.app_context():
rest_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
response = requests.get(rest_url)
assert response.status_code == 200, response.text
# lxml does not support importing from utf8 string
xml_el = ET.fromstring(bytes(response.text, encoding='utf8'))
assert ET.QName(xml_el), response.text
assert ET.QName(xml_el) == "qgis", response.text
assert len(xml_el.xpath('/qgis/renderer-v2')) == 1, response.text
assert xml_el.attrib, response.text
process_client.delete_workspace_layer(username, layername)
def test_qgis_rest():
workspace = 'test_qgis_rest_workspace'
layer = 'test_qgis_rest_workspace_layer'
source_style_file_path = 'sample/style/small_layer.qml'
workspace_directory = f'{settings.LAYMAN_QGIS_DATA_DIR}/workspaces/{workspace}'
layer_directory = f'{workspace_directory}/layers/{layer}'
assert not os.path.exists(workspace_directory)
assert not os.path.exists(layer_directory)
process_client.publish_workspace_layer(workspace,
layer,
style_file=source_style_file_path)
assert os.path.exists(workspace_directory)
assert os.path.exists(layer_directory)
with app.app_context():
url = url_for('rest_workspace_layer_style.get',
workspace=workspace,
layername=layer,
internal=False)
assert wms.get_layer_info(workspace, layer) == {
'name': layer,
'style': {
'type': 'qml',
'url': url
},
'_wms': {
'qgis_capabilities_url':
f'{settings.LAYMAN_QGIS_URL}?SERVICE=WMS&REQUEST=GetCapabilities&VERSION=1.1.1&map=/qgis/data/test/workspaces/{workspace}/layers/{layer}/{layer}.qgis'
}
}
assert workspace in qgis.get_workspaces()
process_client.delete_workspace_layer(workspace, layer)
assert os.path.exists(workspace_directory)
assert not os.path.exists(layer_directory)
with app.app_context():
assert wms.get_layer_info(workspace, layer) == {}
assert workspace in qgis.get_workspaces()
def test_style_value():
username = '******'
layername = 'test_style_value_layer'
process_client.publish_workspace_layer(username, layername)
with app.app_context():
layer_url = url_for('rest_workspace_layer.get',
workspace=username,
layername=layername)
expected_style_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername,
internal=False)
response = requests.get(layer_url)
assert response.status_code == 200, response.text
resp_json = json.loads(response.text)
assert 'style' in resp_json, response.text
assert 'url' in resp_json['style'], response.text
assert 'status' not in resp_json['style'], response.text
external_style_url = resp_json['style']['url']
assert external_style_url == expected_style_url, (response.text,
external_style_url)
with app.app_context():
style_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
r_get = requests.get(style_url)
assert r_get.status_code == 200, (r_get.text, style_url)
r_del = requests.delete(style_url)
assert r_del.status_code >= 400, (r_del.text, style_url)
process_client.delete_workspace_layer(username, layername)
def test_sld_style_in_wms_workspace():
workspace = 'test_sld_style_file_workspace'
layer = 'test_sld_style_file_layer'
geojson_file = [
'/code/tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson'
]
style_file = 'sample/style/generic-blue_sld.xml'
process_client.publish_workspace_layer(workspace,
layer,
file_paths=geojson_file,
style_file=style_file)
url = urljoin(GS_REST, f'workspaces/{workspace}_wms/styles/{layer}')
response = requests.get(
url,
auth=GS_AUTH,
headers=headers_sld,
timeout=5,
)
response.raise_for_status()
process_client.delete_workspace_layer(workspace, layer)
def test_empty_shapefile(layername, file_paths):
workspace = 'test_empty_bbox_workspace'
title = layername
process_client.publish_workspace_layer(workspace,
layername,
file_paths=file_paths)
wms_layer = assert_wms_layer(workspace, layername, title)
native_bbox = wms_layer.boundingBox
wgs_bbox = wms_layer.boundingBoxWGS84
title = 'new title'
process_client.patch_workspace_layer(workspace, layername, title=title)
wms_layer = assert_wms_layer(workspace, layername, title)
assert wms_layer.boundingBox == native_bbox
assert wms_layer.boundingBoxWGS84 == wgs_bbox
wfs_t_insert_point(workspace, layername)
wms_layer = assert_wms_layer(workspace, layername, title)
assert wms_layer.boundingBox == native_bbox
assert wms_layer.boundingBoxWGS84 == wgs_bbox
process_client.delete_workspace_layer(workspace, layername)
def test_wrong_sld_causes_no_thumbnail():
workspace = 'test_wrong_sld_causes_no_thumbnail_workspace'
layer = 'test_wrong_sld_causes_no_thumbnail_layer'
geojson_file = ['/code/sample/layman.layer/sample_point_cz.geojson']
style_file = '/code/sample/layman.layer/sample_point_cz_wrong_literal.sld'
def wait_for_thumbnail_error(response):
ok_keys = ['db_table', 'wms', 'wfs', 'file']
if response.status_code == 200:
r_json = response.json()
result = response.status_code == 200 and all(
'status' not in r_json[k]
for k in ok_keys) and 'status' in r_json[
'thumbnail'] and r_json['thumbnail']['status'] in [
'FAILURE'
]
else:
result = False
return result
process_client.publish_workspace_layer(
workspace,
layer,
file_paths=geojson_file,
style_file=style_file,
check_response_fn=wait_for_thumbnail_error,
)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert 'error' in layer_info['thumbnail']
assert layer_info['thumbnail']['error'][
'message'] == 'Thumbnail rendering failed'
assert layer_info['thumbnail']['error']['code'] == -1
process_client.delete_workspace_layer(workspace, layer)
