def test_delete_map(client): with app.app_context(): username = '******' mapname = 'administrativni_cleneni_libereckeho_kraje' rest_path = url_for('rest_workspace_map.delete_map', workspace=username, mapname=mapname) response = client.delete(rest_path) assert response.status_code == 200 resp_json = response.get_json() uuid_str = resp_json['uuid'] md_record_url = f"http://micka:80/record/basic/m-{uuid_str}" response = requests.get(md_record_url, auth=settings.CSW_BASIC_AUTHN) response.raise_for_status() assert 'Záznam nenalezen' in response.text assert mapname not in response.text publication_counter.decrease() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() }) with app.app_context(): rest_path = url_for('rest_workspace_map.delete_map', workspace=username, mapname=mapname) response = client.delete(rest_path) assert response.status_code == 404 resp_json = response.get_json() assert resp_json['code'] == 26 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() })
def test_post_layers_shp_missing_extensions(client): workspace = 'testuser1' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.dbf', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.shp', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.VERSION.txt', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': 'ne_110m_admin_0_countries_shp', }) resp_json = response.get_json() # print(resp_json) assert response.status_code == 400 assert resp_json['code'] == 18 assert sorted(resp_json['detail']['missing_extensions']) == [ '.prj', '.shx'] finally: for file_path in files: file_path[0].close() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_no_file(chrome): check_redis_consistency(expected_publ_num_by_type={f'{MAP_TYPE}': 0}) username = '******' client_url = settings.LAYMAN_CLIENT_URL response = requests.get(client_url) assert response.status_code == 200 chrome.get(client_url) chrome.set_window_size(1000, 2000) # chrome.save_screenshot('/code/tmp/test-1.png') map_tab = chrome.find_elements_by_css_selector( '.ui.attached.tabular.menu > a.item:nth-child(2)') assert len(map_tab) == 1 map_tab = map_tab[0] map_tab.click() button = chrome.find_elements_by_xpath('//button[text()="POST"]') assert len(button) == 1 button = button[0] button.click() user_input = chrome.find_elements_by_name('Workspace') assert len(user_input) == 1 user_input = user_input[0] user_input.clear() user_input.send_keys(username) button = chrome.find_elements_by_xpath('//button[@type="submit"]') assert len(button) == 1 button = button[0] button.click() time.sleep(0.1) # chrome.save_screenshot('/code/tmp/test-3.png') resp_msg_div = chrome.find_elements_by_css_selector( 'div.ui.container > div:nth-child(8) > div.ui.segment > div.ui.negative.message > code' ) assert len(resp_msg_div) == 1 resp_msg_div = resp_msg_div[0] resp_json = json.loads(resp_msg_div.text) assert resp_json['code'] == 1 entries = chrome.get_log('browser') assert len(entries) == 1 severe_entries = [e for e in entries if e['level'] == 'SEVERE'] assert len(severe_entries) == 1 for entry in severe_entries: assert entry['message'].startswith( f'{client_url}rest/{settings.REST_WORKSPACES_PREFIX}/{username}/maps?' ) and entry['message'].endswith( 'Failed to load resource: the server responded with a status of 400 (BAD REQUEST)' ) check_redis_consistency(expected_publ_num_by_type={f'{MAP_TYPE}': 0})
def test_get_layers_testuser1_v2(client): workspace = 'testuser1' layer1 = 'countries_concurrent' layer2 = 'ne_110m_admin_0_countries' layer3 = 'ne_110m_admin_0_countries_shp' response = client.get(url_for('rest_workspace_layers.get', workspace=workspace)) assert response.status_code == 200 resp_json = response.get_json() # assert len(resp_json) == 3 layernames = [layer['name'] for layer in resp_json] for layer in [ layer1, layer2, layer3, ]: assert layer in layernames workspace = 'testuser2' response = client.get(url_for('rest_workspace_layers.get', workspace=workspace)) resp_json = response.get_json() assert response.status_code == 200 assert len(resp_json) == 1 assert resp_json[0]['name'] == 'countries' uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_patch_layer_style(client): with app.app_context(): workspace = 'testuser1' layername = 'ne_110m_admin_0_countries' rest_path = url_for('rest_workspace_layer.patch', workspace=workspace, layername=layername) sld_path = 'sample/style/generic-blue_sld.xml' assert os.path.isfile(sld_path) response = client.patch(rest_path, data={ 'style': (open(sld_path, 'rb'), os.path.basename(sld_path)), 'title': 'countries in blue' }) assert response.status_code == 200 # last_task = util._get_layer_task(workspace, layername) # Time to generate testing thumbnail is probably shorter than getting & parsing WMS/WFS capabilities documents # so it's finished before PATCH request is completed # # assert last_task is not None and not util._is_task_ready(last_task) # resp_json = rv.get_json() # keys_to_check = ['thumbnail'] # for key_to_check in keys_to_check: # assert 'status' in resp_json[key_to_check] flask_client.wait_till_layer_ready(workspace, layername) # last_task['last'].get() resp_json = response.get_json() assert resp_json['title'] == "countries in blue" wms_url = geoserver_wms.get_wms_url(workspace) wms = wms_proxy(wms_url) assert layername in wms.contents assert wms[layername].title == 'countries in blue' assert wms[layername].styles[ workspace + '_wms:' + layername]['title'] == 'Generic Blue' uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) expected_md_values = { 'abstract': "and new description", 'extent': [-180.0, -85.60903859383285, 180.0, 83.64513109859944], 'graphic_url': url_for_external('rest_workspace_layer_thumbnail.get', workspace=workspace, layername=layername), 'identifier': { 'identifier': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'label': 'ne_110m_admin_0_countries' }, 'language': ['eng'], 'layer_endpoint': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': EXP_REFERENCE_SYSTEMS, 'revision_date': TODAY_DATE, 'spatial_resolution': { 'scale_denominator': 100000000, }, 'title': 'countries in blue', } check_metadata(client, workspace, layername, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_post_maps_invalid_json(client): username = '******' rest_path = url_for('rest_workspace_maps.post', workspace=username) file_paths = [ 'sample/layman.map/invalid-missing-title-email.json', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, }) assert response.status_code == 400 resp_json = response.get_json() # print('resp_json', resp_json) assert resp_json['code'] == 2 assert resp_json['detail']['parameter'] == 'file' assert resp_json['detail'][ 'reason'] == 'JSON not valid against schema layman/map/schema.draft-07.json' assert len(resp_json['detail']['validation-errors']) == 2 finally: for file_path in files: file_path[0].close() uuid.check_redis_consistency( expected_publ_num_by_type={f'{MAP_TYPE}': publication_counter.get()})
def test_get_layers_testuser2(client): workspace = 'testuser2' response = client.get(url_for('rest_workspace_layers.get', workspace=workspace)) assert response.status_code == 200 resp_json = response.get_json() assert len(resp_json) == 0 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_get_layers_testuser1_v1(client): workspace = 'test_get_layers_testuser1_v1_user' layername = 'layer1' # publish and delete layer to ensure that username exists flask_client.publish_layer(workspace, layername, client) flask_client.delete_layer(workspace, layername, client) response = client.get(url_for('rest_workspace_layers.get', workspace=workspace)) assert response.status_code == 200, response.get_json() # assert len(resp_json) == 0 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_get_maps_empty(client): username = '******' flask_client.ensure_workspace(username, client) with app.app_context(): response = client.get( url_for('rest_workspace_maps.get', workspace=username)) resp_json = response.get_json() assert response.status_code == 200, response.data assert len(resp_json) == 0 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() })
def test_post_no_file(browser): check_redis_consistency(expected_publ_num_by_type={f'{MAP_TYPE}': 0}) workspace = 'testuser2' client_url = settings.LAYMAN_CLIENT_URL response = requests.get(client_url) assert response.status_code == 200 browser.get(client_url) browser.set_window_size(1000, 2000) # browser.save_screenshot('/code/tmp/test-1.png') map_tab = browser.find_elements_by_css_selector( '.ui.attached.tabular.menu > a.item:nth-child(2)') assert len(map_tab) == 1 map_tab = map_tab[0] map_tab.click() button = browser.find_elements_by_xpath('//button[text()="POST"]') assert len(button) == 1 button = button[0] button.click() user_input = browser.find_elements_by_name('Workspace') assert len(user_input) == 1 user_input = user_input[0] user_input.clear() user_input.send_keys(workspace) button = browser.find_elements_by_xpath('//button[@type="submit"]') assert len(button) == 1 button = button[0] button.click() time.sleep(0.1) # browser.save_screenshot('/code/tmp/test-3.png') resp_msg_div = browser.find_elements_by_css_selector( 'div.ui.container > div:nth-child(8) > div.ui.segment > div.ui.negative.message > code' ) assert len(resp_msg_div) == 1 resp_msg_div = resp_msg_div[0] resp_json = json.loads(resp_msg_div.text) assert resp_json['code'] == 1 check_redis_consistency(expected_publ_num_by_type={f'{MAP_TYPE}': 0})
def test_delete_layer(client): workspace = 'testuser1' layername = 'ne_110m_admin_0_countries' rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert response.status_code == 200 publication_counter.decrease() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert response.status_code == 404 resp_json = response.get_json() assert resp_json['code'] == 15
def test_patch_layer_title(client): with app.app_context(): workspace = 'testuser1' layername = 'ne_110m_admin_0_countries' rest_path = url_for('rest_workspace_layer.patch', workspace=workspace, layername=layername) new_title = "New Title of Countries" new_description = "and new description" response = client.patch(rest_path, data={ 'title': new_title, 'description': new_description, }) assert response.status_code == 200, response.get_json() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and celery_util.is_chain_ready(chain_info) resp_json = response.get_json() assert resp_json['title'] == new_title assert resp_json['description'] == new_description with app.app_context(): expected_md_values = { 'abstract': "and new description", 'extent': [-180.0, -85.60903859383285, 180.0, 83.64513109859944], 'graphic_url': url_for_external('rest_workspace_layer_thumbnail.get', workspace=workspace, layername=layername), 'identifier': { 'identifier': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'label': 'ne_110m_admin_0_countries' }, 'language': ['eng'], 'layer_endpoint': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': EXP_REFERENCE_SYSTEMS, 'revision_date': TODAY_DATE, 'spatial_resolution': { 'scale_denominator': 100000000, }, 'title': "New Title of Countries", } check_metadata(client, workspace, layername, METADATA_PROPERTIES_EQUAL, expected_md_values) uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_concurrent(client): workspace = 'testuser1' layername = 'countries_concurrent' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': layername, }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': layername, }) assert response.status_code == 409 resp_json = response.get_json() assert resp_json['code'] == 17 finally: for file_path in files: file_path[0].close() publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_long_and_delete_it(client): workspace = 'testuser1' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/10m/cultural/ne_10m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() layername = 'ne_10m_admin_0_countries' time.sleep(1) chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) layer_info = util.get_layer_info(workspace, layername) keys_to_check = ['db_table', 'wms', 'wfs', 'thumbnail', 'metadata'] for key_to_check in keys_to_check: assert 'status' in layer_info[key_to_check] rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert response.status_code == 200 response = client.get(url_for('rest_workspace_layer.get', workspace=workspace, layername=layername)) # print(resp_json) assert response.status_code == 404 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_shp(client): workspace = 'testuser1' layername = 'ne_110m_admin_0_countries_shp' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.cpg', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.dbf', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.prj', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.README.html', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.shp', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.shx', 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.VERSION.txt', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': layername, }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) flask_client.wait_till_layer_ready(workspace, layername) # last_task['last'].get() wms_url = geoserver_wms.get_wms_url(workspace) wms = wms_proxy(wms_url) assert 'ne_110m_admin_0_countries_shp' in wms.contents publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_zero_length_attribute(): workspace = 'testuser1' layername = 'zero_length_attribute' file_paths = [ 'sample/data/zero_length_attribute.geojson', ] def wait_for_db_finish(response): info = response.json() return info.get('db_table', dict()).get('status', '') == 'FAILURE' process_client.publish_workspace_layer(workspace, layername, file_paths=file_paths, check_response_fn=wait_for_db_finish) layer_info = util.get_layer_info(workspace, layername) assert layer_info['db_table']['status'] == 'FAILURE', f'layer_info={layer_info}' assert layer_info['db_table']['error']['code'] == 28, f'layer_info={layer_info}' process_client.delete_workspace_layer(workspace, layername) uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_layer_exists(client): workspace = 'testuser1' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, }) assert response.status_code == 409 resp_json = response.get_json() assert resp_json['code'] == 17 finally: for file_path in files: file_path[0].close() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_num_records(): publs_by_type = uuid.check_redis_consistency() num_publications = sum([len(publs) for publs in publs_by_type.values()]) csw = common_util.create_csw() assert csw is not None, f"{settings.CSW_URL}, {settings.CSW_BASIC_AUTHN}" from owslib.fes import PropertyIsLike any_query = PropertyIsLike('apiso:Identifier', '*', wildCard='*') csw.getrecords2(constraints=[any_query], maxrecords=100, outputschema="http://www.isotc211.org/2005/gmd") assert csw.exceptionreport is None url_part = f"://{settings.LAYMAN_PROXY_SERVER_NAME}/rest/" records = { k: r for k, r in csw.records.items() if any((url_part in u for u in [ol.url for ol in r.distribution.online])) } import json assert len( records) == num_publications, f"md_record_ids={json.dumps(list(records.keys()), indent=5)}\npubls={json.dumps(publs_by_type, indent=2)}"
def test_patch_layer_data(client): with app.app_context(): workspace = 'testuser2' layername = 'countries' rest_path = url_for('rest_workspace_layer.patch', workspace=workspace, layername=layername) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_populated_places.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.patch(rest_path, data={ 'file': files, 'title': 'populated places' }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) resp_json = response.get_json() keys_to_check = ['db_table', 'wms', 'wfs', 'thumbnail', 'metadata'] for key_to_check in keys_to_check: assert 'status' in resp_json[key_to_check] flask_client.wait_till_layer_ready(workspace, layername) # last_task['last'].get() with app.app_context(): rest_path = url_for('rest_workspace_layer.get', workspace=workspace, layername=layername) response = client.get(rest_path) assert 200 <= response.status_code < 300 resp_json = response.get_json() assert resp_json['title'] == "populated places" feature_type = get_feature_type(workspace, 'postgresql', layername) attributes = feature_type['attributes']['attribute'] assert next(( a for a in attributes if a['name'] == 'sovereignt' ), None) is None assert next(( a for a in attributes if a['name'] == 'adm0cap' ), None) is not None uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) with app.app_context(): expected_md_values = { 'abstract': "popis st\u00e1t\u016f", 'extent': [-175.22056435043098, -41.29999116752133, 179.21664802661394, 64.15002486626597], 'graphic_url': url_for_external('rest_workspace_layer_thumbnail.get', workspace=workspace, layername=layername), 'identifier': { 'identifier': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), "label": "countries" }, 'language': ["eng", 'chi', 'rus'], 'layer_endpoint': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': EXP_REFERENCE_SYSTEMS, 'revision_date': TODAY_DATE, 'spatial_resolution': None, # it's point data now and we can't guess scale from point data 'title': 'populated places', } check_metadata(client, workspace, layername, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_patch_layer_concurrent_and_delete_it(client): with app.app_context(): workspace = 'testuser2' layername = 'countries' rest_path = url_for('rest_workspace_layer.patch', workspace=workspace, layername=layername) file_paths = [ 'tmp/naturalearth/10m/cultural/ne_10m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) uuid_str = layer_uuid.get_layer_uuid(workspace, layername) assert uuid.is_valid_uuid(uuid_str) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.patch(rest_path, data={ 'file': files, 'title': 'populated places' }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) with app.app_context(): try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.patch(rest_path, data={ 'file': files, }) assert response.status_code == 400, response.get_json() resp_json = response.get_json() assert resp_json['code'] == 49 finally: for file_path in files: file_path[0].close() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) with app.app_context(): rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert response.status_code == 200 from layman.layer import get_layer_type_def from layman.common.filesystem import uuid as common_uuid uuid_filename = common_uuid.get_publication_uuid_file( get_layer_type_def()['type'], workspace, layername) assert not os.path.isfile(uuid_filename) assert not settings.LAYMAN_REDIS.sismember(uuid.UUID_SET_KEY, uuid_str) assert not settings.LAYMAN_REDIS.exists(uuid.get_uuid_metadata_key(uuid_str)) assert not settings.LAYMAN_REDIS.hexists( uuid.get_workspace_type_names_key(workspace, '.'.join(__name__.split('.')[:-1])), layername ) publication_counter.decrease() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_maps_simple(client): with app.app_context(): username = '******' mapname = None expected_mapname = 'administrativni_cleneni_libereckeho_kraje' rest_path = url_for('rest_workspace_maps.post', workspace=username) file_paths = [ 'sample/layman.map/full.json', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, }) assert response.status_code == 200 resp_json = response.get_json() # print('resp_json', resp_json) assert len(resp_json) == 1 assert resp_json[0]['name'] == expected_mapname mapname = resp_json[0]['name'] uuid_str = resp_json[0]['uuid'] finally: for file_path in files: file_path[0].close() assert uuid.is_valid_uuid(uuid_str) publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() }) with app.app_context(): response = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['name'] == mapname assert resp_json['uuid'] == uuid_str assert resp_json['url'] == url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname) assert resp_json[ 'title'] == "Administrativn\u00ed \u010dlen\u011bn\u00ed Libereck\u00e9ho kraje" assert resp_json[ 'description'] == "Na tematick\u00e9 map\u011b p\u0159i p\u0159ibl\u00ed\u017een\u00ed jsou postupn\u011b zobrazovan\u00e9 administrativn\u00ed celky Libereck\u00e9ho kraje : okresy, OP\u00da, ORP a obce." map_file = resp_json['file'] assert 'status' not in map_file assert 'path' in map_file assert map_file['url'] == url_for_external( 'rest_workspace_map_file.get', workspace=username, mapname=mapname) thumbnail = resp_json['thumbnail'] assert 'status' in thumbnail assert thumbnail['status'] in ['PENDING', 'STARTED'] assert 'id' not in resp_json.keys() assert 'type' not in resp_json.keys() with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['thumbnail'] and map_info['thumbnail'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() with app.app_context(): response = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() thumbnail = resp_json['thumbnail'] assert 'status' not in thumbnail assert 'path' in thumbnail assert thumbnail['url'] == url_for_external( 'rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname) with app.app_context(): response = client.get( url_for('rest_workspace_map_file.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['name'] == mapname with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['metadata'] and map_info['metadata'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() assert set(map_info['metadata'].keys()) == { 'identifier', 'csw_url', 'record_url', 'comparison_url' } assert map_info['metadata']['identifier'] == f"m-{uuid_str}" assert map_info['metadata']['csw_url'] == settings.CSW_PROXY_URL md_record_url = f"http://micka:80/record/basic/m-{uuid_str}" assert map_info['metadata']['record_url'].replace( "http://localhost:3080", "http://micka:80") == md_record_url response = requests.get(md_record_url, auth=settings.CSW_BASIC_AUTHN) response.raise_for_status() assert mapname in response.text with app.app_context(): expected_md_values = { 'abstract': "Na tematick\u00e9 map\u011b p\u0159i p\u0159ibl\u00ed\u017een\u00ed jsou postupn\u011b zobrazovan\u00e9 administrativn\u00ed celky Libereck\u00e9ho kraje : okresy, OP\u00da, ORP a obce.", 'extent': [14.62, 50.58, 15.42, 50.82], 'graphic_url': url_for_external('rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname), 'identifier': { "identifier": url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), "label": "administrativni_cleneni_libereckeho_kraje" }, 'map_endpoint': url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), 'map_file_endpoint': url_for_external('rest_workspace_map_file.get', workspace=username, mapname=mapname), 'operates_on': [], 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': [3857], 'revision_date': None, 'title': "Administrativn\u00ed \u010dlen\u011bn\u00ed Libereck\u00e9ho kraje", } check_metadata(client, username, mapname, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_post_layers_sld_1_1_0(client): workspace = 'testuser1' layername = 'countries_sld_1_1_0' rest_path = url_for('rest_workspace_layers.post', workspace=workspace, layername=layername) file_paths = [ 'sample/data/test_layer4.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] sld_path = 'sample/style/sld_1_1_0.xml' assert os.path.isfile(sld_path) try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': layername, 'style': (open(sld_path, 'rb'), os.path.basename(sld_path)), }) assert response.status_code == 200 resp_json = response.get_json() # print(resp_json) assert layername == resp_json[0]['name'] finally: for file_path in files: file_path[0].close() layer_info = util.get_layer_info(workspace, layername) while ('status' in layer_info['wms'] and layer_info['wms']['status'] in ['PENDING', 'STARTED'])\ or ('status' in layer_info['style'] and layer_info['style']['status'] in ['PENDING', 'STARTED']): time.sleep(0.1) layer_info = util.get_layer_info(workspace, layername) wms_url = geoserver_wms.get_wms_url(workspace) wms = wms_proxy(wms_url) assert layername in wms.contents assert wms[layername].title == 'countries_sld_1_1_0' style_url = geoserver_sld.get_workspace_style_url(workspace, layername) response = requests.get(style_url + '.sld', auth=settings.LAYMAN_GS_AUTH ) response.raise_for_status() sld_file = io.BytesIO(response.content) tree = ET.parse(sld_file) root = tree.getroot() assert root.attrib['version'] == '1.1.0' assert root[0][1][1][0][1][0][0].text == '#e31a1c' # assert wms[layername].styles[ # username+':'+layername]['title'] == 'test_layer2' publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert response.status_code == 200 publication_counter.decrease() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_maps_complex(client): with app.app_context(): username = '******' mapname = 'libe' title = 'Liberecký kraj: Administrativní členění' description = 'Libovolný popis' rest_path = url_for('rest_workspace_maps.post', workspace=username) file_paths = [ 'sample/layman.map/full.json', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': mapname, 'title': title, 'description': description, }) assert response.status_code == 200 resp_json = response.get_json() # print('resp_json', resp_json) assert len(resp_json) == 1 assert resp_json[0]['name'] == mapname uuid_str = resp_json[0]['uuid'] finally: for file_path in files: file_path[0].close() publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() }) with app.app_context(): response = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['name'] == mapname assert resp_json['uuid'] == uuid_str assert resp_json['url'] == url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname) assert resp_json['title'] == title assert resp_json['description'] == description map_file = resp_json['file'] assert 'status' not in map_file assert 'path' in map_file assert map_file['url'] == url_for_external( 'rest_workspace_map_file.get', workspace=username, mapname=mapname) thumbnail = resp_json['thumbnail'] assert 'status' in thumbnail assert thumbnail['status'] in ['PENDING', 'STARTED'] with app.app_context(): # assert another PATCH is not possible now response = client.patch(url_for('rest_workspace_map.patch', workspace=username, mapname=mapname), data={ 'title': 'abcd', }) assert response.status_code == 400 resp_json = response.get_json() assert resp_json['code'] == 49 # continue with thumbnail assertion with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['thumbnail'] and map_info['thumbnail'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() with app.app_context(): response = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() thumbnail = resp_json['thumbnail'] assert 'status' not in thumbnail assert 'path' in thumbnail assert thumbnail['url'] == url_for_external( 'rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname) with app.app_context(): response = client.get( url_for('rest_workspace_map_file.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['name'] == mapname assert resp_json['title'] == title assert resp_json['abstract'] == description user_json = resp_json['user'] assert user_json['name'] == username assert user_json['email'] == '' assert len(user_json) == 2 assert 'groups' not in resp_json # continue with metadata assertion with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['metadata'] and map_info['metadata'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() with app.app_context(): expected_md_values = { 'abstract': "Libovoln\u00fd popis", 'extent': [14.62, 50.58, 15.42, 50.82], 'graphic_url': url_for_external('rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname), 'identifier': { "identifier": url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), "label": "libe" }, 'map_endpoint': url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), 'map_file_endpoint': url_for_external('rest_workspace_map_file.get', workspace=username, mapname=mapname), 'operates_on': [], 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': [3857], 'revision_date': None, 'title': "Libereck\u00fd kraj: Administrativn\u00ed \u010dlen\u011bn\u00ed", } check_metadata(client, username, mapname, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_patch_map(client): with app.app_context(): username = '******' mapname = 'administrativni_cleneni_libereckeho_kraje' uuid_str = map_uuid.get_map_uuid(username, mapname) rest_path = url_for('rest_workspace_map.patch', workspace=username, mapname=mapname) file_paths = [ 'sample/layman.map/full2.json', ] for file in file_paths: assert os.path.isfile(file) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.patch(rest_path, data={ 'file': files, }) assert response.status_code == 200 resp_json = response.get_json() # print('resp_json', resp_json) finally: for file in files: file[0].close() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() }) assert resp_json['uuid'] == uuid_str assert resp_json['url'] == url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname) assert resp_json[ 'title'] == "Jiné administrativn\u00ed \u010dlen\u011bn\u00ed Libereck\u00e9ho kraje" assert resp_json['description'] == "Jiný popis" map_file = resp_json['file'] assert 'status' not in map_file assert 'path' in map_file assert map_file['url'] == url_for_external( 'rest_workspace_map_file.get', workspace=username, mapname=mapname) thumbnail = resp_json['thumbnail'] assert 'status' in thumbnail assert thumbnail['status'] in ['PENDING', 'STARTED'] with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['thumbnail'] and map_info['thumbnail'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() with app.app_context(): response = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() thumbnail = resp_json['thumbnail'] assert 'status' not in thumbnail assert 'path' in thumbnail assert thumbnail['url'] == url_for_external( 'rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname) with app.app_context(): response = client.get( url_for('rest_workspace_map_file.get', workspace=username, mapname=mapname)) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['name'] == mapname assert resp_json[ 'title'] == "Jiné administrativn\u00ed \u010dlen\u011bn\u00ed Libereck\u00e9ho kraje" assert resp_json['abstract'] == "Jiný popis" user_json = resp_json['user'] assert user_json['name'] == username assert user_json['email'] == '' assert len(user_json) == 2 assert 'groups' not in resp_json with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() while 'status' in map_info['metadata'] and map_info['metadata'][ 'status'] in ['PENDING', 'STARTED']: time.sleep(0.1) with app.app_context(): map_info = client.get( url_for('rest_workspace_map.get', workspace=username, mapname=mapname)).get_json() with app.app_context(): title = 'Nový název' response = client.patch(rest_path, data={ 'title': title, }) assert response.status_code == 200, response.get_json() resp_json = response.get_json() assert resp_json['title'] == "Nový název" assert resp_json['description'] == "Jiný popis" with app.app_context(): description = 'Nový popis' response = client.patch(rest_path, data={ 'description': description, }) assert response.status_code == 200 resp_json = response.get_json() assert resp_json['title'] == "Nový název" assert resp_json['description'] == "Nový popis" uuid.check_redis_consistency(expected_publ_num_by_type={ f'{MAP_TYPE}': publication_counter.get() }) with app.app_context(): expected_md_values = { 'abstract': "Nov\u00fd popis", 'extent': [14.623, 50.58, 15.42, 50.82], 'graphic_url': url_for_external('rest_workspace_map_thumbnail.get', workspace=username, mapname=mapname), 'identifier': { "identifier": url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), "label": "administrativni_cleneni_libereckeho_kraje" }, 'map_endpoint': url_for_external('rest_workspace_map.get', workspace=username, mapname=mapname), 'map_file_endpoint': url_for_external('rest_workspace_map_file.get', workspace=username, mapname=mapname), 'operates_on': [], 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': [3857], 'revision_date': TODAY_DATE, 'title': "Nov\u00fd n\u00e1zev", } check_metadata(client, username, mapname, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_uppercase_attr(client): with app.app_context(): workspace = 'testuser2' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'sample/data/upper_attr.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] sld_path = 'sample/data/upper_attr.sld' assert os.path.isfile(sld_path) layername = 'upper_attr' try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': layername, 'style': (open(sld_path, 'rb'), os.path.basename(sld_path)), }) assert response.status_code == 200 resp_json = response.get_json() # print(resp_json) finally: for file_path in files: file_path[0].close() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) flask_client.wait_till_layer_ready(workspace, layername) # last_task['last'].get() assert celery_util.is_chain_ready(chain_info) with app.app_context(): rest_path = url_for('rest_workspace_layer.get', workspace=workspace, layername=layername) response = client.get(rest_path) assert 200 <= response.status_code < 300 resp_json = response.get_json() # print(resp_json) for source in [ 'wms', 'wfs', 'thumbnail', 'file', 'db_table', 'metadata', ]: assert 'status' not in resp_json[source], f"{source}: {resp_json[source]}" style_url = geoserver_sld.get_workspace_style_url(workspace, layername) response = requests.get(style_url + '.sld', auth=settings.LAYMAN_GS_AUTH ) response.raise_for_status() sld_file = io.BytesIO(response.content) tree = ET.parse(sld_file) root = tree.getroot() assert root.attrib['version'] == '1.1.0' feature_type = get_feature_type(workspace, 'postgresql', layername) attributes = feature_type['attributes']['attribute'] attr_names = ["id", "dpr_smer_k", "fid_zbg", "silnice", "silnice_bs", "typsil_p", "cislouseku", "jmeno", "typsil_k", "peazkom1", "peazkom2", "peazkom3", "peazkom4", "vym_tahy_k", "vym_tahy_p", "r_indsil7", "kruh_obj_k", "etah1", "etah2", "etah3", "etah4", "kruh_obj_p", "dpr_smer_p"] for attr_name in attr_names: assert next(( a for a in attributes if a['name'] == attr_name ), None) is not None th_path = get_layer_thumbnail_path(workspace, layername) assert os.path.getsize(th_path) > 5000 with app.app_context(): rest_path = url_for('rest_workspace_layer.delete_layer', workspace=workspace, layername=layername) response = client.delete(rest_path) assert 200 <= response.status_code < 300 uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() })
def test_post_layers_complex(client): with app.app_context(): workspace = 'testuser2' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] sld_path = 'sample/style/generic-blue_sld.xml' assert os.path.isfile(sld_path) layername = '' try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, 'name': 'countries', 'title': 'staty', 'description': 'popis států', 'style': (open(sld_path, 'rb'), os.path.basename(sld_path)), }) assert response.status_code == 200 resp_json = response.get_json() # print(resp_json) layername = resp_json[0]['name'] finally: for file_path in files: file_path[0].close() chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) flask_client.wait_till_layer_ready(workspace, layername) # last_task['last'].get() assert celery_util.is_chain_ready(chain_info) wms_url = geoserver_wms.get_wms_url(workspace) wms = wms_proxy(wms_url) assert 'countries' in wms.contents assert wms['countries'].title == 'staty' assert wms['countries'].abstract == 'popis států' assert wms['countries'].styles[workspace + '_wms:countries']['title'] == 'Generic Blue' assert layername != '' rest_path = url_for('rest_workspace_layer.get', workspace=workspace, layername=layername) response = client.get(rest_path) assert 200 <= response.status_code < 300 resp_json = response.get_json() # print(resp_json) assert resp_json['title'] == 'staty' assert resp_json['description'] == 'popis států' for source in [ 'wms', 'wfs', 'thumbnail', 'file', 'db_table', 'metadata', ]: assert 'status' not in resp_json[source] style_url = geoserver_sld.get_workspace_style_url(workspace, layername) response = requests.get(style_url + '.sld', auth=settings.LAYMAN_GS_AUTH ) response.raise_for_status() sld_file = io.BytesIO(response.content) tree = ET.parse(sld_file) root = tree.getroot() assert root.attrib['version'] == '1.0.0' feature_type = get_feature_type(workspace, 'postgresql', layername) attributes = feature_type['attributes']['attribute'] assert next(( a for a in attributes if a['name'] == 'sovereignt' ), None) is not None publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) with app.app_context(): expected_md_values = { 'abstract': "popis st\u00e1t\u016f", 'extent': [-180.0, -85.60903859383285, 180.0, 83.64513109859944], 'graphic_url': url_for_external('rest_workspace_layer_thumbnail.get', workspace=workspace, layername=layername), 'identifier': { "identifier": url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), "label": "countries" }, 'language': ["eng"], 'layer_endpoint': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': EXP_REFERENCE_SYSTEMS, 'revision_date': None, 'spatial_resolution': { 'scale_denominator': 100000000, }, 'title': "staty", } check_metadata(client, workspace, layername, METADATA_PROPERTIES_EQUAL, expected_md_values)
def test_post_layers_simple(client): with app.app_context(): workspace = 'testuser1' rest_path = url_for('rest_workspace_layers.post', workspace=workspace) file_paths = [ 'tmp/naturalearth/110m/cultural/ne_110m_admin_0_countries.geojson', ] for file_path in file_paths: assert os.path.isfile(file_path) files = [] try: files = [(open(fp, 'rb'), os.path.basename(fp)) for fp in file_paths] response = client.post(rest_path, data={ 'file': files, }) assert response.status_code == 200 finally: for file_path in files: file_path[0].close() layername = 'ne_110m_admin_0_countries' chain_info = util.get_layer_chain(workspace, layername) assert chain_info is not None and not celery_util.is_chain_ready(chain_info) layer_info = util.get_layer_info(workspace, layername) keys_to_check = ['db_table', 'wms', 'wfs', 'thumbnail', 'metadata'] for key_to_check in keys_to_check: assert 'status' in layer_info[key_to_check] # For some reason this hangs forever on get() if run (either with src/layman/authz/read_everyone_write_owner_auth2_test.py::test_authn_map_access_rights or src/layman/authn/oauth2_test.py::test_patch_current_user_without_username) and with src/layman/common/metadata/util.csw_insert # last_task['last'].get() # e.g. python3 -m pytest -W ignore::DeprecationWarning -xsvv src/layman/authn/oauth2_test.py::test_patch_current_user_without_username src/layman/layer/rest_workspace_test.py::test_post_layers_simple # this can badly affect also .get(propagate=False) in layman.celery.abort_task_chain # but hopefully this is only related to magic flask&celery test suite flask_client.wait_till_layer_ready(workspace, layername) layer_info = util.get_layer_info(workspace, layername) for key_to_check in keys_to_check: assert isinstance(layer_info[key_to_check], str) \ or 'status' not in layer_info[key_to_check] wms_url = geoserver_wms.get_wms_url(workspace) wms = wms_proxy(wms_url) assert layername in wms.contents from layman.layer import get_layer_type_def from layman.common.filesystem import uuid as common_uuid uuid_filename = common_uuid.get_publication_uuid_file( get_layer_type_def()['type'], workspace, layername) assert os.path.isfile(uuid_filename) uuid_str = None with open(uuid_filename, "r") as file: uuid_str = file.read().strip() assert uuid.is_valid_uuid(uuid_str) assert settings.LAYMAN_REDIS.sismember(uuid.UUID_SET_KEY, uuid_str) assert settings.LAYMAN_REDIS.exists(uuid.get_uuid_metadata_key(uuid_str)) assert settings.LAYMAN_REDIS.hexists( uuid.get_workspace_type_names_key(workspace, '.'.join(__name__.split('.')[:-1])), layername ) layer_info = client.get(url_for('rest_workspace_layer.get', workspace=workspace, layername=layername)).get_json() assert set(layer_info['metadata'].keys()) == {'identifier', 'csw_url', 'record_url', 'comparison_url'} assert layer_info['metadata']['identifier'] == f"m-{uuid_str}" assert layer_info['metadata']['csw_url'] == settings.CSW_PROXY_URL md_record_url = f"http://micka:80/record/basic/m-{uuid_str}" assert layer_info['metadata']['record_url'].replace("http://localhost:3080", "http://micka:80") == md_record_url assert layer_info['metadata']['comparison_url'] == url_for_external('rest_workspace_layer_metadata_comparison.get', workspace=workspace, layername=layername) assert 'id' not in layer_info.keys() assert 'type' not in layer_info.keys() response = requests.get(md_record_url, auth=settings.CSW_BASIC_AUTHN) response.raise_for_status() assert layername in response.text publication_counter.increase() uuid.check_redis_consistency(expected_publ_num_by_type={ f'{LAYER_TYPE}': publication_counter.get() }) with app.app_context(): expected_md_values = { 'abstract': None, 'extent': [-180.0, -85.60903859383285, 180.0, 83.64513109859944], 'graphic_url': url_for_external('rest_workspace_layer_thumbnail.get', workspace=workspace, layername=layername), 'identifier': { 'identifier': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'label': 'ne_110m_admin_0_countries' }, 'language': ['eng'], 'layer_endpoint': url_for_external('rest_workspace_layer.get', workspace=workspace, layername=layername), 'organisation_name': None, 'publication_date': TODAY_DATE, 'reference_system': EXP_REFERENCE_SYSTEMS, 'revision_date': None, 'spatial_resolution': { 'scale_denominator': 100000000, }, 'title': 'ne_110m_admin_0_countries', } check_metadata(client, workspace, layername, METADATA_PROPERTIES_EQUAL, expected_md_values)