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_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_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_check_workspace_wms(): workspace = 'test_check_workspace_wms_user' + settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX layer = 'test_check_workspace_wms_layer' with pytest.raises(LaymanError) as exc_info: process_client.publish_workspace_layer(workspace, layer) assert exc_info.value.http_code == 400 assert exc_info.value.code == 45 assert exc_info.value.data['workspace_name'] == workspace
def setup_user_layer(username, layername, authn_headers): process_client.reserve_username(username, headers=authn_headers) process_client.publish_workspace_layer( username, layername, file_paths=[ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ], headers=authn_headers)
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_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 ensure_layer_internal(workspace, layername, file_paths=None, style_file=None): if (workspace, layername) not in LAYERS_TO_DELETE_AFTER_TEST: process_client.publish_workspace_layer(workspace, layername, file_paths=file_paths, style_file=style_file) delete_layer_after_test(workspace, layername) else: process_client.patch_workspace_layer(workspace, layername, file_paths=file_paths, style_file=style_file)
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_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 ensure_map_internal(workspace, map, layer_workspace, layer): geojson_files = [ '/code/tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson' ] style_file = 'sample/style/generic-blue_sld.xml' source_map_file_path = '/code/src/layman/upgrade/upgrade_v1_10_test_map.json' process_client.publish_workspace_layer(layer_workspace, layer, file_paths=geojson_files, style_file=style_file) process_client.publish_workspace_map( workspace, map, ) with app.app_context(): input_file.ensure_map_input_file_dir(workspace, map) map_file_path = input_file.get_map_file(workspace, map) shutil.copyfile(source_map_file_path, map_file_path) thumbnail.generate_map_thumbnail(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_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_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_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_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_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)
def test_geoserver_remove_users_for_public_workspaces(): workspace = 'test_geoserver_remove_users_for_public_workspaces_workspace' user = '******' auth_headers = process_client.get_authz_headers(user) layer = 'test_geoserver_remove_users_for_public_workspaces_layer' gs_rolename = gs_util.username_to_rolename(workspace) gs_rolename2 = gs_util.username_to_rolename(user) process_client.publish_workspace_layer(workspace, layer) process_client.ensure_reserved_username(user, auth_headers) with app.app_context(): gs_provider.ensure_whole_user(workspace, auth) usernames = gs_util.get_usernames(auth) assert workspace in usernames assert user in usernames roles = gs_util.get_roles(auth) assert gs_rolename in roles assert gs_rolename2 in roles workspaces = gs_util.get_all_workspaces(auth) assert workspace in workspaces assert user in workspaces upgrade_v1_9.geoserver_remove_users_for_public_workspaces() usernames = gs_util.get_usernames(auth) assert workspace not in usernames, usernames assert user in usernames roles = gs_util.get_roles(auth) assert gs_rolename not in roles, roles assert gs_rolename2 in roles workspaces = gs_util.get_all_workspaces(auth) assert workspace in workspaces, workspaces assert user in workspaces process_client.delete_workspace_layer(workspace, layer) process_client.publish_workspace_layer(workspace, layer) process_client.delete_workspace_layer(workspace, layer) process_client.publish_workspace_layer(workspace, layer + '2') process_client.delete_workspace_layer(workspace, layer + '2')