def test_info(workspace, publ_type, publication): ensure_publication(workspace, publ_type, publication) wms_url = f"http://localhost:8000/geoserver/{workspace}{settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX}/ows" wfs_url = f"http://localhost:8000/geoserver/{workspace}/wfs" headers = data.HEADERS.get(data.PUBLICATIONS[(workspace, publ_type, publication)][data.TEST_DATA].get('users_can_write', [None])[0]) style = data.PUBLICATIONS[(workspace, publ_type, publication)][data.TEST_DATA]['style_type'] info = process_client.get_workspace_publication(publ_type, workspace, publication, headers=headers) with app.app_context(): info_internal = layer_util.get_layer_info(workspace, publication) expected_style_url = url_for('rest_workspace_layer_style.get', workspace=workspace, layername=publication, internal=False) file_type = info_internal['file']['file_type'] item_keys = get_layer_info_keys(file_type) assert set(info.keys()) == item_keys, f'info={info}' assert info['wms'].get('url') == wms_url, f'r_json={info}, wms_url={wms_url}' assert 'url' in info['wms'], f'info={info}' assert info.get('file', dict()).get('file_type') == data.PUBLICATIONS[(workspace, publ_type, publication)][data.TEST_DATA].get('file_type') if 'wfs' in info: assert info['wfs'].get('url') == wfs_url, f'r_json={info}, wfs_url={wfs_url}' assert info_internal['style_type'] == style, f'info_internal={info_internal}' assert info['style']['type'] == style, info.get('style') external_style_url = info['style']['url'] assert external_style_url == expected_style_url, (info, external_style_url)
def test_style_correctly_saved(source_style_file_path, layer_suffix, expected_style_file_template, expected_style_type): workspace = 'test_style_correctly_saved_workspace' layer = 'test_style_correctly_saved_layer' + layer_suffix expected_style_file = expected_style_file_template.format( workspace=workspace, layer=layer) if expected_style_file_template else None process_client.publish_workspace_layer(workspace, layer, style_file=source_style_file_path) assert_style_file(workspace, layer, expected_style_file) with app.app_context(): info = layman_util.get_publication_info(workspace, process_client.LAYER_TYPE, layer, context={ 'keys': ['style_type', 'style'], }) assert info['style_type'] == expected_style_type process_client.delete_workspace_layer(workspace, layer) process_client.publish_workspace_layer(workspace, layer) with app.app_context(): info = layer_util.get_layer_info(workspace, layer) assert info['style_type'] == 'sld' assert info['style']['type'] == 'sld', info.get('style') assert info['style']['url'], info.get('style') assert_style_file(workspace, layer, None) process_client.patch_workspace_layer(workspace, layer, style_file=source_style_file_path) assert_style_file(workspace, layer, expected_style_file) with app.app_context(): info = layer_util.get_layer_info(workspace, layer) assert info['style_type'] == expected_style_type process_client.delete_workspace_layer(workspace, layer)
def patch_layer(workspace, layername, title, description, access_rights=None): geoserver_workspace = get_geoserver_workspace(workspace) info = layer_util.get_layer_info(workspace, layername, context={'keys': ['style_type'], }) if info['style_type'] == 'sld': gs_util.patch_feature_type(geoserver_workspace, layername, title=title, description=description, auth=settings.LAYMAN_GS_AUTH) clear_cache(workspace) if access_rights and access_rights.get('read'): security_read_roles = gs_common.layman_users_to_geoserver_roles(access_rights['read']) gs_util.ensure_layer_security_roles(geoserver_workspace, layername, security_read_roles, 'r', settings.LAYMAN_GS_AUTH) if access_rights and access_rights.get('write'): security_write_roles = gs_common.layman_users_to_geoserver_roles(access_rights['write']) gs_util.ensure_layer_security_roles(geoserver_workspace, layername, security_write_roles, 'w', settings.LAYMAN_GS_AUTH)
def ensure_wfs_t_attributes(attribs): app.logger.info(f"GET WFS check_xml_for_attribute attribs={attribs}") editable_attribs = set(attr for attr in attribs if authz.can_i_edit(LAYER_TYPE, attr[0], attr[1])) created_attributes = db.ensure_attributes(editable_attribs) if created_attributes: changed_layers = {(workspace, layer) for workspace, layer, _ in created_attributes} qgis_changed_layers = { (workspace, layer) for workspace, layer in changed_layers if layer_util.get_layer_info( workspace, layer, context={ 'keys': ['style_type'], })['style_type'] == 'qml' } for workspace, layer in qgis_changed_layers: qgis_wms.save_qgs_file(workspace, layer) gs_reset(settings.LAYMAN_GS_AUTH)
def test_missing_attribute(style_file, ): username = '******' layername = 'inexisting_attribute_layer' layername2 = 'inexisting_attribute_layer2' authn_headers = get_authz_headers(username) process_client.ensure_reserved_username(username, headers=authn_headers) process_client.publish_workspace_layer( username, layername, file_paths=[ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ], style_file=style_file, headers=authn_headers, ) process_client.publish_workspace_layer( username, layername2, file_paths=[ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ], style_file=style_file, headers=authn_headers, ) with app.app_context(): style_type = layer_util.get_layer_info(username, layername, context={ 'keys': ['style_type'], })['style_type'] def wfs_post(workspace, attr_names_list, data_xml): with app.app_context(): wfs_url = f"http://{settings.LAYMAN_SERVER_NAME}/geoserver/{workspace}/wfs" old_db_attributes = {} old_wfs_properties = {} for layer, attr_names in attr_names_list: # test that all attr_names are not yet presented in DB table old_db_attributes[layer] = db.get_all_column_names( workspace, layer) for attr_name in attr_names: assert attr_name not in old_db_attributes[ layer], f"old_db_attributes={old_db_attributes[layer]}, attr_name={attr_name}" layer_schema = get_wfs_schema(wfs_url, typename=f"{workspace}:{layer}", version=geoserver_wfs.VERSION, headers=authn_headers) old_wfs_properties[layer] = sorted( layer_schema['properties'].keys()) if style_type == 'qml': assert qgis_wms.get_layer_info(workspace, layer) old_qgis_attributes = qgis_util.get_layer_attribute_names( workspace, layer) assert all( attr_name not in old_qgis_attributes for attr_name in attr_names), (attr_names, old_qgis_attributes) process_client.post_wfst(data_xml, headers=authn_headers, workspace=username) new_db_attributes = {} new_wfs_properties = {} for layer, attr_names in attr_names_list: # test that exactly all attr_names were created in DB table new_db_attributes[layer] = db.get_all_column_names( workspace, layer) for attr_name in attr_names: assert attr_name in new_db_attributes[ layer], f"new_db_attributes={new_db_attributes[layer]}, attr_name={attr_name}" assert set(attr_names).union(set( old_db_attributes[layer])) == set(new_db_attributes[layer]) # test that exactly all attr_names were distinguished also in WFS feature type layer_schema = get_wfs_schema(wfs_url, typename=f"{workspace}:{layer}", version=geoserver_wfs.VERSION, headers=authn_headers) new_wfs_properties[layer] = sorted( layer_schema['properties'].keys()) for attr_name in attr_names: assert attr_name in new_wfs_properties[ layer], f"new_wfs_properties={new_wfs_properties[layer]}, attr_name={attr_name}" assert set(attr_names).union(set(old_wfs_properties[layer])) == set(new_wfs_properties[layer]),\ set(new_wfs_properties[layer]).difference(set(attr_names).union(set(old_wfs_properties[layer]))) if style_type == 'qml': assert qgis_wms.get_layer_info(workspace, layer) new_qgis_attributes = qgis_util.get_layer_attribute_names( workspace, layer) assert all( attr_name in new_qgis_attributes for attr_name in attr_names), (attr_names, new_qgis_attributes) else: assert not qgis_wms.get_layer_info(workspace, layer) attr_names = ['inexisting_attribute_attr', 'inexisting_attribute_attr1a'] data_xml = data_wfs.get_wfs20_insert_points_new_attr( username, layername, attr_names) wfs_post(username, [(layername, attr_names)], data_xml) attr_names2 = ['inexisting_attribute_attr2'] data_xml = data_wfs.get_wfs20_update_points_new_attr( username, layername, attr_names2) wfs_post(username, [(layername, attr_names2)], data_xml) attr_names3 = ['inexisting_attribute_attr3'] data_xml = data_wfs.get_wfs20_update_points_new_attr( username, layername, attr_names3, with_attr_namespace=True) wfs_post(username, [(layername, attr_names3)], data_xml) attr_names4 = ['inexisting_attribute_attr4'] data_xml = data_wfs.get_wfs20_update_points_new_attr(username, layername, attr_names4, with_filter=True) wfs_post(username, [(layername, attr_names4)], data_xml) attr_names5 = ['inexisting_attribute_attr5'] data_xml = data_wfs.get_wfs20_replace_points_new_attr( username, layername, attr_names5) wfs_post(username, [(layername, attr_names5)], data_xml) attr_names_i1 = ['inexisting_attribute_attr_complex_i1'] attr_names_i2 = ['inexisting_attribute_attr_complex_i2'] attr_names_u = ['inexisting_attribute_attr_complex_u'] attr_names_r = ['inexisting_attribute_attr_complex_r'] attr_names_complex = [(layername, attr_names_i1 + attr_names_r), (layername2, attr_names_i2 + attr_names_u)] data_xml = data_wfs.get_wfs20_complex_new_attr( workspace=username, layername1=layername, layername2=layername2, attr_names_insert1=attr_names_i1, attr_names_insert2=attr_names_i2, attr_names_update=attr_names_u, attr_names_replace=attr_names_r) wfs_post(username, attr_names_complex, data_xml) attr_names6 = ['inexisting_attribute_attr6'] data_xml = data_wfs.get_wfs10_insert_points_new_attr( username, layername, attr_names6) wfs_post(username, [(layername, attr_names6)], data_xml) attr_names7 = ['inexisting_attribute_attr7'] data_xml = data_wfs.get_wfs11_insert_points_new_attr( username, layername, attr_names7) wfs_post(username, [(layername, attr_names7)], data_xml) attr_names8 = ['inexisting_attribute_attr8'] data_xml = data_wfs.get_wfs10_update_points_new(username, layername, attr_names8, with_attr_namespace=True) wfs_post(username, [(layername, attr_names8)], data_xml) attr_names9 = ['inexisting_attribute_attr9'] data_xml = data_wfs.get_wfs10_update_points_new(username, layername, attr_names9, with_filter=True) wfs_post(username, [(layername, attr_names9)], data_xml) attr_names10 = ['inexisting_attribute_attr10'] data_xml = data_wfs.get_wfs11_insert_polygon_new_attr( username, layername, attr_names10) wfs_post(username, [(layername, attr_names10)], data_xml) process_client.delete_workspace_layer(username, layername, headers=authn_headers) process_client.delete_workspace_layer(username, layername2, headers=authn_headers)
def test_update_style_type_in_db(): workspace = 'test_update_style_type_in_db_workspace' map = 'test_update_style_type_in_db_map' TestLayerDef = namedtuple('TestLayerDef', [ 'name', 'style_file', 'expected_style', ]) layers = [ TestLayerDef( 'test_update_style_type_in_db_none_layer', '', 'sld', ), TestLayerDef( 'test_update_style_type_in_db_sld_layer', 'sample/style/generic-blue_sld.xml', 'sld', ), TestLayerDef( 'test_update_style_type_in_db_sld110_layer', 'sample/style/sld_1_1_0.xml', 'sld', ), # This should not happened, because before this release, it was not possible to upload QGIS files TestLayerDef( 'test_update_style_type_in_db_qgis_layer', 'sample/style/small_layer.qml', 'sld', ), ] process_client.publish_workspace_map(workspace, map) for layer in layers: process_client.publish_workspace_layer( workspace, layer.name, style_file=layer.style_file, ) set_column_null = f"""update {DB_SCHEMA}.publications set style_type = null""" with app.app_context(): db_util.run_statement(set_column_null) map_info = map_util.get_map_info(workspace, map) assert map_info['style_type'] is None for layer in layers: layer_info = layer_util.get_layer_info(workspace, layer.name) assert layer_info['style_type'] is None upgrade_v1_10.update_style_type_in_db() map_info = map_util.get_map_info(workspace, map) assert map_info['style_type'] is None for layer in layers: layer_info = layer_util.get_layer_info(workspace, layer.name) assert layer_info['style_type'] == layer.expected_style process_client.delete_workspace_map(workspace, map) for layer in layers: process_client.delete_workspace_layer( workspace, layer.name, )