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_wms_workspace():
workspace = 'test_wms_workspace_workspace'
layername = 'test_wms_workspace_layer'
wms_url = f"http://localhost:8000/geoserver/test_wms_workspace_workspace{settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX}/ows"
wfs_url = f"http://localhost:8000/geoserver/test_wms_workspace_workspace/wfs"
process_client.publish_workspace_layer(workspace, layername)
r_json = process_client.get_workspace_layer(workspace, layername)
assert r_json['wms']['url'] == wms_url
assert r_json['wfs']['url'] == wfs_url
with app.app_context():
internal_wms_url = url_for('geoserver_proxy_bp.proxy', subpath=workspace + settings.LAYMAN_GS_WMS_WORKSPACE_POSTFIX + '/ows')
internal_wfs_url = url_for('geoserver_proxy_bp.proxy', subpath=workspace + '/wfs')
r_wms = requests.get(internal_wms_url, params={
'service': 'WMS',
'request': 'GetCapabilities',
'version': '1.3.0',
})
assert r_wms.status_code == 200
r_wfs = requests.get(internal_wfs_url, params={
'service': 'WFS',
'request': 'GetCapabilities',
'version': '2.0.0',
})
assert r_wfs.status_code == 200
process_client.delete_workspace_layer(workspace, layername)
def test_parse_md_properties():
xml_path = 'src/layman/layer/micka/util_test_filled_template.xml'
with open(xml_path, 'r') as xml_file:
props = common_util.parse_md_properties(xml_file, [
'abstract',
'extent',
'graphic_url',
'identifier',
'layer_endpoint',
'language',
'md_date_stamp',
'md_file_identifier',
'md_organisation_name',
'organisation_name',
'publication_date',
'reference_system',
'scale_denominator',
'title',
'wfs_url',
'wms_url',
], METADATA_PROPERTIES)
with app.app_context():
expected = {
'md_file_identifier': 'm-ca238200-8200-1a23-9399-42c9fca53542',
'md_date_stamp': '2007-05-25',
'md_organisation_name': None,
'organisation_name': None,
'scale_denominator': None,
'language': [],
'reference_system': [4326, 3857],
'title': 'CORINE - Krajinný pokryv CLC 90',
'publication_date': '2007-05-25',
'identifier': {
'identifier': 'http://www.env.cz/data/corine/1990',
'label': 'MZP-CORINE',
},
'abstract': None,
'graphic_url': url_for('rest_workspace_layer_thumbnail.get', workspace='browser', layername='layer',
internal=False),
'extent': [11.87, 48.12, 19.13, 51.59],
'wms_url': 'http://www.env.cz/corine/data/download.zip',
'wfs_url': 'http://www.env.cz/corine/data/download.zip',
'layer_endpoint': url_for('rest_workspace_layer.get', workspace='browser', layername='layer',
internal=False),
}
assert set(props.keys()) == set(expected.keys())
for k, value in props.items():
equals_fn = COMMON_PROPERTIES[k].get('equals_fn', None)
assert prop_equals(value, expected[k],
equals_fn), f"Values of property {k} do not equal: {value} != {expected[k]}"
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_authn_get_current_user_without_username(client):
rest_path = url_for('rest_current_user.get')
response = client.get(rest_path,
headers={
f'{ISS_URL_HEADER}':
'http://*****:*****@liferay.com'
assert claims['email_verified'] is True
assert claims['family_name'] == 'Test'
assert claims['given_name'] == 'Test'
assert claims['middle_name'] == ''
assert claims['name'] == 'Test Test'
assert claims['preferred_username'] == 'test'
assert claims['screen_name'] == 'test'
assert claims['sub'] == '20139'
def test_token_active(client, headers):
username = '******'
url = url_for('rest_workspace_layers.get', workspace=username)
response = client.get(url, headers=headers)
assert response.status_code == 404
resp_json = response.get_json()
assert resp_json['code'] == 40
def test_get_users():
username = '******'
userinfo = {
"issuer_id": 'mock_test_rest_user_test',
"sub": '1',
"claims": {
"email": "*****@*****.**",
"preferred_username": '******',
"name": "test ensure user",
"given_name": "test",
"family_name": "user",
"middle_name": "ensure",
}
}
# Create username in layman
with app.app_context():
ensure_whole_user(username, userinfo)
# users.GET
url = url_for('rest_users.get')
assert url.endswith('/' + settings.REST_USERS_PREFIX)
response = requests.get(url)
assert response.status_code == 200, response.json()
assert username in [info["username"] for info in response.json()]
def check_metadata(client, username, mapname, props_equal, expected_values):
with app.app_context():
rest_path = url_for('rest_workspace_map_metadata_comparison.get',
workspace=username,
mapname=mapname)
response = client.get(rest_path)
assert response.status_code == 200, response.get_json()
resp_json = response.get_json()
assert METADATA_PROPERTIES == set(
resp_json['metadata_properties'].keys())
# for k, v in resp_json['metadata_properties'].items():
# print(f"'{k}': {json.dumps(list(v['values'].values())[0], indent=2)},")
for key, value in resp_json['metadata_properties'].items():
assert value['equal_or_null'] == (
key in props_equal
), f"Metadata property values have unexpected 'equal_or_null' value: {key}: {json.dumps(value, indent=2)}, sources: {json.dumps(resp_json['metadata_sources'], indent=2)}"
assert value['equal'] == (
key in props_equal
), f"Metadata property values have unexpected 'equal' value: {key}: {json.dumps(value, indent=2)}, sources: {json.dumps(resp_json['metadata_sources'], indent=2)}"
# print(f"'{k}': {json.dumps(list(v['values'].values())[0], indent=2)},")
if key in expected_values:
vals = list(value['values'].values())
vals.append(expected_values[key])
assert prop_equals_strict(vals, equals_fn=PROPERTIES[key].get('equals_fn',
None)),\
f"Property {key} has unexpected values {json.dumps(vals, indent=2)}"
def test_no_file(client):
response = client.post(
url_for('rest_workspace_maps.post', workspace='testuser1'))
assert response.status_code == 400
resp_json = response.get_json()
# print('resp_json', resp_json)
assert resp_json['code'] == 1
assert resp_json['detail']['parameter'] == 'file'
def test_no_provider_found(client, headers):
username = '******'
response = client.get(url_for('rest_workspace_layers.get',
workspace=username),
headers=headers)
assert response.status_code == 403
resp_json = response.get_json()
assert resp_json['code'] == 32
assert resp_json['sub_code'] == 6
def test_auth_header_bad_first_part(client, headers):
username = '******'
response = client.get(url_for('rest_workspace_layers.get',
workspace=username),
headers=headers)
assert response.status_code == 403
resp_json = response.get_json()
assert resp_json['code'] == 32
assert resp_json['sub_code'] == 4
def test_no_auth_header(client):
username = '******'
response = client.get(url_for('rest_workspace_layers.get',
workspace=username),
headers={f'{ISS_URL_HEADER}': 'abc'})
assert response.status_code == 403
resp_json = response.get_json()
assert resp_json['code'] == 32
assert resp_json['sub_code'] == 2
def test_unexisting_introspection_url(client, headers):
username = '******'
response = client.get(url_for('rest_workspace_layers.get',
workspace=username),
headers=headers)
assert response.status_code == 403
resp_json = response.get_json()
assert resp_json['code'] == 32
assert resp_json['sub_code'] == 8
def test_get_maps():
username = '******'
mapname = 'test_get_maps_map'
process_client.publish_workspace_map(username, mapname, title=mapname)
with app.app_context():
url_get = url_for('rest_workspace_maps.get', workspace=username)
# maps.GET
response = requests.get(url_get)
assert response.status_code == 200, response.json()
assert response.json()[0]['name'] == mapname
assert response.json()[0]['title'] == mapname
with app.app_context():
assert response.json()[0]['url'] == url_for('rest_workspace_map.get', workspace=username, mapname=mapname,
internal=False)
process_client.delete_workspace_map(username, mapname)
def test_get_current_user_anonymous(client):
rest_path = url_for('rest_current_user.get')
response = client.get(rest_path)
assert response.status_code == 200
resp_json = response.get_json()
assert resp_json['authenticated'] is False, resp_json
assert {'authenticated', 'claims'} == set(resp_json.keys()), resp_json
claims = resp_json['claims']
assert {'iss', 'name', 'nickname'} == set(claims.keys()), claims
assert claims['name'] == 'Anonymous', claims
assert claims['nickname'] == 'Anonymous', claims
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_style_value():
username = '******'
layername = 'test_style_value_layer'
process_client.publish_workspace_layer(username, layername)
with app.app_context():
layer_url = url_for('rest_workspace_layer.get',
workspace=username,
layername=layername)
expected_style_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername,
internal=False)
response = requests.get(layer_url)
assert response.status_code == 200, response.text
resp_json = json.loads(response.text)
assert 'style' in resp_json, response.text
assert 'url' in resp_json['style'], response.text
assert 'status' not in resp_json['style'], response.text
external_style_url = resp_json['style']['url']
assert external_style_url == expected_style_url, (response.text,
external_style_url)
with app.app_context():
style_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
r_get = requests.get(style_url)
assert r_get.status_code == 200, (r_get.text, style_url)
r_del = requests.delete(style_url)
assert r_del.status_code >= 400, (r_del.text, style_url)
process_client.delete_workspace_layer(username, layername)
def test_wrong_value_of_mapname(client):
username = '******'
mapnames = [' ', '2a', 'ě', ';', '?', 'ABC']
for mapname in mapnames:
response = client.get(
url_for('rest_workspace_map.get',
workspace=username,
mapname=mapname))
resp_json = response.get_json()
# print('username', username)
# print(resp_json)
assert response.status_code == 400
assert resp_json['code'] == 2
assert resp_json['detail']['parameter'] == 'mapname'
def test_authorize_publications_decorator_on_rest_api(
self,
rest_action,
url_for_params,
authz_status_code,
authz_response,
unauthz_status_code,
unauthz_response,
):
username = self.username
authz_headers = self.authz_headers
patch_method = None
publ_name = None
if '_layer' in rest_action:
patch_method = process_client.patch_workspace_layer
publ_name = self.layername
elif '_map' in rest_action:
patch_method = process_client.patch_workspace_map
publ_name = self.mapname
assert publ_name
url_for_params['workspace'] = username
with app.app_context():
rest_url = url_for(rest_action, **url_for_params)
patch_method(username,
publ_name,
headers=authz_headers,
access_rights={
'read': username,
'write': username,
})
response = requests.get(rest_url, headers=authz_headers)
self.assert_response(response, authz_status_code, authz_response)
response = requests.get(rest_url)
self.assert_response(response, unauthz_status_code, unauthz_response)
patch_method(username,
publ_name,
headers=authz_headers,
access_rights={
'read': settings.RIGHTS_EVERYONE_ROLE,
'write': settings.RIGHTS_EVERYONE_ROLE,
})
response = requests.get(rest_url, headers=authz_headers)
self.assert_response(response, authz_status_code, authz_response)
response = requests.get(rest_url)
self.assert_response(response, authz_status_code, authz_response)
def test_get_layer_style_sld():
username = '******'
layername = 'test_get_layer_style_sld_layer'
process_client.publish_workspace_layer(
username,
layername,
)
with app.app_context():
rest_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
response = requests.get(rest_url)
assert response.status_code == 200, response.text
# lxml does not support importing from utf8 string
xml_tree = ET.fromstring(bytes(response.text, encoding='utf8'))
assert ET.QName(
xml_tree
) == "{http://www.opengis.net/sld}StyledLayerDescriptor", response.text
process_client.delete_workspace_layer(username, layername)
def test_qgis_rest():
workspace = 'test_qgis_rest_workspace'
layer = 'test_qgis_rest_workspace_layer'
source_style_file_path = 'sample/style/small_layer.qml'
workspace_directory = f'{settings.LAYMAN_QGIS_DATA_DIR}/workspaces/{workspace}'
layer_directory = f'{workspace_directory}/layers/{layer}'
assert not os.path.exists(workspace_directory)
assert not os.path.exists(layer_directory)
process_client.publish_workspace_layer(workspace,
layer,
style_file=source_style_file_path)
assert os.path.exists(workspace_directory)
assert os.path.exists(layer_directory)
with app.app_context():
url = url_for('rest_workspace_layer_style.get',
workspace=workspace,
layername=layer,
internal=False)
assert wms.get_layer_info(workspace, layer) == {
'name': layer,
'style': {
'type': 'qml',
'url': url
},
'_wms': {
'qgis_capabilities_url':
f'{settings.LAYMAN_QGIS_URL}?SERVICE=WMS&REQUEST=GetCapabilities&VERSION=1.1.1&map=/qgis/data/test/workspaces/{workspace}/layers/{layer}/{layer}.qgis'
}
}
assert workspace in qgis.get_workspaces()
process_client.delete_workspace_layer(workspace, layer)
assert os.path.exists(workspace_directory)
assert not os.path.exists(layer_directory)
with app.app_context():
assert wms.get_layer_info(workspace, layer) == {}
assert workspace in qgis.get_workspaces()
def test_get_layer_style_qml():
username = '******'
layername = 'test_get_layer_style_sld_layer'
qml_file = 'sample/style/small_layer.qml'
process_client.publish_workspace_layer(username,
layername,
style_file=qml_file)
with app.app_context():
rest_url = url_for('rest_workspace_layer_style.get',
workspace=username,
layername=layername)
response = requests.get(rest_url)
assert response.status_code == 200, response.text
# lxml does not support importing from utf8 string
xml_el = ET.fromstring(bytes(response.text, encoding='utf8'))
assert ET.QName(xml_el), response.text
assert ET.QName(xml_el) == "qgis", response.text
assert len(xml_el.xpath('/qgis/renderer-v2')) == 1, response.text
assert xml_el.attrib, response.text
process_client.delete_workspace_layer(username, layername)
def test_get_map_title():
username = '******'
maps = [("c_test_get_map_title_map", "C Test get map title - map title íářžý"),
("a_test_get_map_title_map", "A Test get map title - map title íářžý"),
("b_test_get_map_title_map", "B Test get map title - map title íářžý")
]
sorted_maps = sorted(maps)
for (name, title) in maps:
process_client.publish_workspace_map(username, name, title=title)
with app.app_context():
url_get = url_for('rest_workspace_maps.get', workspace=username)
# maps.GET
response = requests.get(url_get)
assert response.status_code == 200, response.json()
for i in range(0, len(sorted_maps) - 1):
assert response.json()[i]["name"] == sorted_maps[i][0]
assert response.json()[i]["title"] == sorted_maps[i][1]
for (name, title) in maps:
process_client.delete_workspace_map(username, name)
def test_post_maps_invalid_file(client):
username = '******'
rest_path = url_for('rest_workspace_maps.post', workspace=username)
file_paths = [
'sample/style/generic-blue_sld.xml',
]
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'] == 'Invalid JSON syntax'
finally:
for file_path in files:
file_path[0].close()
def test_version():
with app.app_context():
r_url = url_for('rest_about.get_version')
response = requests.get(r_url)
process_client.raise_layman_error(response)
result = response.json()
assert 'about' in result.keys()
assert 'applications' in result['about'].keys()
assert 'layman' in result['about']['applications'].keys()
assert 'version' in result['about']['applications']['layman'].keys()
assert 'release-timestamp' in result['about']['applications'][
'layman'].keys()
assert 'layman-test-client' in result['about']['applications'].keys()
assert 'version' in result['about']['applications'][
'layman-test-client'].keys()
assert 'data' in result['about'].keys()
assert 'layman' in result['about']['data'].keys()
assert 'last-migration' in result['about']['data']['layman'].keys()
assert 'last-data-migration' in result['about']['data']['layman'].keys()
assert 'last-schema-migration' in result['about']['data']['layman'].keys()
assert result['about']['data']['layman']['last-migration'] == result[
'about']['data']['layman']['last-schema-migration']
def test_map_composed_from_local_layers(client):
with app.app_context():
username = '******'
rest_path = url_for('rest_workspace_layers.post', workspace=username)
layername1 = 'mista'
pattern = os.path.join(
os.getcwd(),
'tmp/naturalearth/110m/cultural/ne_110m_populated_places.*')
file_paths = glob.glob(pattern)
assert len(file_paths) > 0
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.post(rest_path,
data={
'file': files,
'name': layername1,
})
assert response.status_code == 200
layer1uuid = response.get_json()[0]['uuid']
finally:
for file in files:
file[0].close()
# If no sleep, Micka throws 500
# [2020-03-26 09-54-11] Dibi\UniqueConstraintViolationException: duplicate key value violates unique constraint "edit_md_pkey" DETAIL: Key (recno)=(17) already exists. SCHEMA NAME: public TABLE NAME: edit_md CONSTRAINT NAME: edit_md_pkey LOCATION: _bt_check_unique, nbtinsert.c:434 #23505 in /var/www/html/Micka/php/vendor/dibi/dibi/src/Dibi/Drivers/PostgreDriver.php:150 @ http://localhost:3080/csw @@ exception--2020-03-26--09-54--3f034f5a61.html
# in /var/www/html/Micka/php/app/model/RecordModel.php, line 197 setEditMd2Md INSERT INTO ...
# probably problem with concurrent CSW insert
# so report bug to Micka
time.sleep(0.3)
with app.app_context():
layername2 = 'hranice'
pattern = os.path.join(
os.getcwd(),
'tmp/naturalearth/110m/cultural/ne_110m_admin_0_boundary_lines_land.*'
)
file_paths = glob.glob(pattern)
assert len(file_paths) > 0
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.post(rest_path,
data={
'file': files,
'name': layername2,
})
assert response.status_code == 200
layer2uuid = response.get_json()[0]['uuid']
finally:
for file in files:
file[0].close()
with app.app_context():
keys_to_check = ['db_table', 'wms', 'wfs', 'thumbnail', 'metadata']
layer_info = client.get(
url_for('rest_workspace_layer.get',
workspace=username,
layername=layername1)).get_json()
max_attempts = 100
num_attempts = 1
while num_attempts < max_attempts and any(
('status' in layer_info[key] for key in keys_to_check)):
time.sleep(0.1)
# print('layer_info1', layer_info)
with app.app_context():
layer_info = client.get(
url_for('rest_workspace_layer.get',
workspace=username,
layername=layername1)).get_json()
num_attempts += 1
assert num_attempts < max_attempts, f"Max attempts reached, layer1info={layer_info}"
wms_url1 = layer_info['wms']['url']
with app.app_context():
layer_info = client.get(
url_for('rest_workspace_layer.get',
workspace=username,
layername=layername2)).get_json()
num_attempts = 1
while any(('status' in layer_info[key] for key in keys_to_check)):
time.sleep(0.1)
# print('layer_info2', layer_info)
with app.app_context():
layer_info = client.get(
url_for('rest_workspace_layer.get',
workspace=username,
layername=layername2)).get_json()
num_attempts += 1
assert num_attempts < max_attempts, f"Max attempts reached, layer2info={layer_info}"
wms_url2 = layer_info['wms']['url']
expected_url = 'http://localhost:8000/geoserver/testuser1_wms/ows'
assert wms_url1 == expected_url
assert wms_url2 == expected_url
with app.app_context():
mapname = 'svet'
rest_path = url_for('rest_workspace_maps.post', workspace=username)
file_paths = [
'sample/layman.map/internal_url.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.post(rest_path,
data={
'file': files,
'name': mapname,
})
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
finally:
for file_path in files:
file_path[0].close()
with app.app_context():
map_info = client.get(
url_for('rest_workspace_map.get',
workspace=username,
mapname=mapname)).get_json()
thumbnail = map_info['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', 'SUCCESS']:
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)
# uuid.check_redis_consistency(expected_publ_num_by_type={
# f'{MAP_TYPE}': num_maps_before_test + 2
# })
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():
# assert metadata file is the same as filled template except for UUID and dates
template_path, prop_values = csw.get_template_path_and_values(
username, mapname, http_method='post')
xml_file_object = micka_common_util.fill_xml_template_as_pretty_file_object(
template_path, prop_values, csw.METADATA_PROPERTIES)
expected_path = 'src/layman/map/rest_test_filled_template.xml'
with open(expected_path) as file:
expected_lines = file.readlines()
diff_lines = list(
difflib.unified_diff(
[line.decode('utf-8') for line in xml_file_object.readlines()],
expected_lines))
assert len(diff_lines) == 40, ''.join(diff_lines)
plus_lines = [line for line in diff_lines if line.startswith('+ ')]
assert len(plus_lines) == 5
minus_lines = [line for line in diff_lines if line.startswith('- ')]
assert len(minus_lines) == 5
plus_line = plus_lines[0]
assert plus_line == '+ <gco:CharacterString>m-91147a27-1ff4-4242-ba6d-faffb92224c6</gco:CharacterString>\n'
minus_line = minus_lines[0]
assert minus_line.startswith(
'- <gco:CharacterString>m') and minus_line.endswith(
'</gco:CharacterString>\n')
plus_line = plus_lines[1]
assert plus_line == '+ <gco:Date>2007-05-25</gco:Date>\n'
minus_line = minus_lines[1]
assert minus_line.startswith(
'- <gco:Date>') and minus_line.endswith('</gco:Date>\n')
plus_line = plus_lines[2]
assert plus_line == '+ <gco:Date>2007-05-25</gco:Date>\n'
minus_line = minus_lines[2]
assert minus_line.startswith('- <gco:Date>'
) and minus_line.endswith('</gco:Date>\n')
plus_line = plus_lines[3]
assert plus_line.startswith(
'+ <srv:operatesOn xlink:href="http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID='
) and plus_line.endswith(
'" xlink:title="hranice" xlink:type="simple"/>\n'), plus_line
minus_line = minus_lines[3]
assert minus_line.startswith(
'- <srv:operatesOn xlink:href="http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID='
) and minus_line.endswith(
'" xlink:title="hranice" xlink:type="simple"/>\n'), minus_line
plus_line = plus_lines[4]
assert plus_line.startswith(
'+ <srv:operatesOn xlink:href="http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID='
) and plus_line.endswith(
'" xlink:title="mista" xlink:type="simple"/>\n'), plus_line
minus_line = minus_lines[4]
assert minus_line.startswith(
'- <srv:operatesOn xlink:href="http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID='
) and minus_line.endswith(
'" xlink:title="mista" xlink:type="simple"/>\n'), minus_line
with app.app_context():
expected_md_values = {
'abstract':
"World places and boundaries abstract",
'extent': [-35.0, -48.5, 179.0, 81.5],
'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":
"svet"
},
'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': [{
"xlink:href":
f"http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID=m-{layer2uuid}#_m-{layer2uuid}",
"xlink:title": "hranice"
}, {
"xlink:href":
f"http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID=m-{layer1uuid}#_m-{layer1uuid}",
"xlink:title": "mista"
}],
'organisation_name':
None,
'publication_date':
TODAY_DATE,
'reference_system': [3857],
'revision_date':
None,
'title':
"World places and boundaries",
}
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_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_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_parse_md_properties():
xml_path = 'src/layman/map/rest_test_filled_template.xml'
with open(xml_path, 'r') as xml_file:
props = common_util.parse_md_properties(xml_file, [
'abstract',
'extent',
'graphic_url',
'identifier',
'map_endpoint',
'map_file_endpoint',
'md_date_stamp',
'md_file_identifier',
'md_organisation_name',
'organisation_name',
'publication_date',
'reference_system',
'title',
'operates_on',
], METADATA_PROPERTIES)
with app.app_context():
expected = {
'md_file_identifier':
'm-91147a27-1ff4-4242-ba6d-faffb92224c6',
'md_organisation_name':
None,
'organisation_name':
None,
'md_date_stamp':
'2007-05-25',
'reference_system': [3857],
'title':
'World places and boundaries',
'publication_date':
'2007-05-25',
'identifier': {
'identifier':
url_for('rest_workspace_map.get',
workspace='testuser1',
mapname='svet',
internal=False),
'label':
'svet',
},
'abstract':
'World places and boundaries abstract',
'graphic_url':
url_for('rest_workspace_map_thumbnail.get',
workspace='testuser1',
mapname='svet',
internal=False),
'extent': [-35, -48.5, 179, 81.5],
'map_endpoint':
url_for('rest_workspace_map.get',
workspace='testuser1',
mapname='svet',
internal=False),
'map_file_endpoint':
url_for('rest_workspace_map_file.get',
workspace='testuser1',
mapname='svet',
internal=False),
'operates_on': [
{
'xlink:href':
'http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID=m-39cc8994-adbc-427a-8522-569eb7e691b2#_m-39cc8994-adbc-427a-8522-569eb7e691b2',
'xlink:title': 'hranice',
},
{
'xlink:href':
'http://localhost:3080/csw?SERVICE=CSW&VERSION=2.0.2&REQUEST=GetRecordById&OUTPUTSCHEMA=http://www.isotc211.org/2005/gmd&ID=m-fb48a6e3-f36c-43fd-a885-ae7de82b3924#_m-fb48a6e3-f36c-43fd-a885-ae7de82b3924',
'xlink:title': 'mista',
},
],
}
assert set(props.keys()) == set(expected.keys())
for k, value in props.items():
equals_fn = COMMON_PROPERTIES[k].get('equals_fn', None)
assert prop_equals(
value, expected[k], equals_fn
), f"Values of property {k} do not equal: {value} != {expected[k]}"
