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)
