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)