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_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 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_http_header():
username = '******'
workspace = 'test_http_header_workspace'
layername = 'test_http_header_layer'
http_authn_headers = {
settings.LAYMAN_AUTHN_HTTP_HEADER_NAME: username,
}
with pytest.raises(LaymanError) as exc_info:
process_client.get_workspace_layer(workspace,
layername,
headers=http_authn_headers)
assert exc_info.value.http_code == 403
assert exc_info.value.code == 44
assert exc_info.value.message == 'Unsuccessful HTTP Header authentication.'
assert exc_info.value.data == 'Username test_http_header_user not recognized.'
# reserve the username in prime DB schema
with app.app_context():
prime_db_schema.ensure_whole_user(
username, {
'issuer_id': 'test_http_header_issuer',
'sub': username,
'claims': {
'preferred_username': username,
'given_name': username,
'family_name': username,
'middle_name': username,
'name': username,
'email': f"{username}@example.com",
}
})
with pytest.raises(LaymanError) as exc_info:
process_client.get_workspace_layer(workspace,
layername,
headers=http_authn_headers)
assert exc_info.value.http_code == 404
assert exc_info.value.code == 40
assert exc_info.value.message == 'Workspace does not exist.'
with app.app_context():
prime_db_schema.delete_whole_user(username)
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)
def test_migrate_layers_to_wms_workspace(ensure_layer):
workspace = 'test_migrate_layers_to_wms_workspace_workspace'
layer = 'test_migrate_layers_to_wms_workspace_layer'
expected_file = 'sample/style/countries_wms_blue.png'
ensure_layer(workspace, layer)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert layer_info['wms']['status'] == 'NOT_AVAILABLE'
assert layer_info['wfs'][
'url'] == f'http://localhost:8000/geoserver/{workspace}/wfs'
assert layer_info['db_table']['name'] == layer
all_workspaces = gs_util.get_all_workspaces(settings.LAYMAN_GS_AUTH)
assert workspace in all_workspaces
wms_workspace = wms.get_geoserver_workspace(workspace)
assert wms_workspace not in all_workspaces
sld_wfs_r = gs_util.get_workspace_style_response(
workspace, layer, auth=settings.LAYMAN_GS_AUTH)
assert sld_wfs_r.status_code == 200
old_wms_url = f"http://{settings.LAYMAN_SERVER_NAME}/geoserver/" \
f"{workspace}/wms?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&FORMAT=image/png&TRANSPARENT=true&STYLES=&" \
f"LAYERS={workspace}:{layer}&SRS=EPSG:3857&WIDTH=768&HEIGHT=752&" \
f"BBOX=-30022616.05686392,-30569903.32873383,30022616.05686392,28224386.44929134"
obtained_file = 'tmp/artifacts/test_migrate_layers_to_wms_workspace_before_migration.png'
assert_util.assert_same_images(old_wms_url, obtained_file, expected_file,
2000)
with app.app_context():
upgrade_v1_10.migrate_layers_to_wms_workspace(workspace)
layer_info = process_client.get_workspace_layer(workspace, layer)
assert layer_info['wms'][
'url'] == f'http://localhost:8000/geoserver/{wms_workspace}/ows'
assert layer_info['wfs'][
'url'] == f'http://localhost:8000/geoserver/{workspace}/wfs'
with app.app_context():
assert layer_info['style']['url'] == url_for(
'rest_workspace_layer_style.get',
workspace=workspace,
layername=layer,
internal=False)
all_workspaces = gs_util.get_all_workspaces(settings.LAYMAN_GS_AUTH)
assert workspace in all_workspaces
assert wms_workspace in all_workspaces
sld_wfs_r = gs_util.get_workspace_style_response(
workspace, layer, auth=settings.LAYMAN_GS_AUTH)
assert sld_wfs_r.status_code == 404
sld_wms_r = gs_util.get_workspace_style_response(
wms_workspace, layer, auth=settings.LAYMAN_GS_AUTH)
assert sld_wms_r.status_code == 200
sld_stream = process_client.get_workspace_layer_style(workspace, layer)
assert sld_stream
new_wms_url = f"http://{settings.LAYMAN_SERVER_NAME}/geoserver/" \
f"{wms_workspace}/wms?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&FORMAT=image/png&TRANSPARENT=true&STYLES=&" \
f"LAYERS={wms_workspace}:{layer}&SRS=EPSG:3857&WIDTH=768&HEIGHT=752&" \
f"BBOX=-30022616.05686392,-30569903.32873383,30022616.05686392,28224386.44929134"
obtained_file2 = 'tmp/artifacts/test_migrate_layers_to_wms_workspace_after_migration.png'
assert_util.assert_same_images(new_wms_url, obtained_file2, expected_file,
2000)
process_client.delete_workspace_layer(workspace, layer)
def test_map_with_unauthorized_layer():
username1 = 'test_map_with_unauthorized_layer_user1'
layername1 = 'test_map_with_unauthorized_layer_layer1'
mapname1 = 'test_map_with_unauthorized_layer_map1'
username2 = 'test_map_with_unauthorized_layer_user2'
layername2 = 'test_map_with_unauthorized_layer_layer2'
user1_authz_headers = process_client.get_authz_headers(username1)
user2_authz_headers = process_client.get_authz_headers(username2)
process_client.reserve_username(username1, headers=user1_authz_headers)
process_client.reserve_username(username2, headers=user2_authz_headers)
process_client.publish_workspace_layer(username1,
layername1,
headers=user1_authz_headers)
process_client.publish_workspace_layer(username2,
layername2,
headers=user2_authz_headers)
# assert users have access only to their own layer
process_client.assert_workspace_layers(username1, [layername1],
headers=user1_authz_headers)
process_client.assert_workspace_layers(username1, [],
headers=user2_authz_headers)
process_client.assert_workspace_layers(username2, [layername2],
headers=user2_authz_headers)
process_client.assert_workspace_layers(username2, [],
headers=user1_authz_headers)
# publish map composed of layers of both users, read for everyone
process_client.publish_workspace_map(
username1,
mapname1,
file_paths=['sample/layman.map/internal_url_unauthorized_layer.json'],
access_rights={
'read': 'EVERYONE',
'write': f"{username1},{username2}",
},
headers=user1_authz_headers,
)
process_client.assert_workspace_maps(username1, [mapname1],
headers=user1_authz_headers)
process_client.assert_workspace_maps(username1, [mapname1],
headers=user2_authz_headers)
layer1_uuid = process_client.get_workspace_layer(
username1, layername1, headers=user1_authz_headers)['uuid']
layer2_uuid = process_client.get_workspace_layer(
username2, layername2, headers=user2_authz_headers)['uuid']
# assert that metadata property operates_on contains only layers visible to publisher, whoever is asking and has read access to the map
assert_operates_on(username1,
mapname1, [(layer1_uuid, layername1)],
authz_headers=user1_authz_headers)
assert_operates_on(username1,
mapname1, [(layer1_uuid, layername1)],
authz_headers=user2_authz_headers)
process_client.patch_workspace_map(username1,
mapname1,
headers=user2_authz_headers)
# assert that metadata property operates_on contains only layers visible to last publisher, whoever is asking and has read access to the map
assert_operates_on(username1,
mapname1, [(layer2_uuid, layername2)],
authz_headers=user1_authz_headers)
assert_operates_on(username1,
mapname1, [(layer2_uuid, layername2)],
authz_headers=user2_authz_headers)
# clean up
process_client.delete_workspace_map(username1,
mapname1,
headers=user1_authz_headers)
process_client.delete_workspace_layer(username1,
layername1,
headers=user1_authz_headers)
process_client.delete_workspace_layer(username2,
layername2,
headers=user2_authz_headers)