def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Keywords matching F1 and F3
haz_keywords1 = dict(category='hazard', subcategory='flood',
layertype='raster', unit='m')
exp_keywords1 = dict(category='exposure', subcategory='population',
layertype='raster', datatype='population')
# Keywords matching F2 and F3
haz_keywords2 = dict(category='hazard', subcategory='flood',
layertype='raster', unit='m')
exp_keywords2 = dict(category='exposure', subcategory='building')
# Check correct matching
P = get_admissible_plugins([haz_keywords1, exp_keywords1])
msg = 'Expected impact functions F1 and F3 in %s' % str(P.keys())
assert 'F1' in P and 'F3' in P, msg
P = get_admissible_plugins([haz_keywords2, exp_keywords2])
msg = 'Expected impact functions F2 and F3 in %s' % str(P.keys())
assert 'F2' in P and 'F3' in P, msg
# Check empty call returns all
P = get_admissible_plugins([])
msg = ('Expected at least impact functions F1, F2 and F3 in %s'
% str(P.keys()))
assert 'F1' in P and 'F2' in P and 'F3' in P, msg
def test_plugin_compatibility(self):
"""Default plugins perform as expected
"""
# Upload a raster and a vector data set
hazard_filename = os.path.join(UNITDATA, 'hazard',
'jakarta_flood_design.tif')
hazard_layer = save_to_geonode(hazard_filename)
check_layer(hazard_layer, full=True)
exposure_filename = os.path.join(UNITDATA, 'exposure',
'buildings_osm_4326.shp')
exposure_layer = save_to_geonode(exposure_filename)
check_layer(exposure_layer, full=True)
# Test
plugin_list = get_admissible_plugins()
assert len(plugin_list) > 0
geoserver = {'url': settings.GEOSERVER_BASE_URL + 'ows',
'name': 'Local Geoserver',
'version': '1.0.0',
'id': 0}
metadata = get_metadata(geoserver['url'])
msg = 'There were no layers in test geoserver'
assert len(metadata) > 0, msg
# Characterisation test to preserve the behaviour of
# get_layer_descriptors. FIXME: I think we should change this to be
# a dictionary of metadata entries (ticket #126).
reference = {'geonode:buildings_osm_4326':
{'layertype': 'vector',
'category': 'exposure',
'subcategory': 'structure',
'title': 'buildings_osm_4326'},
'geonode:jakarta_flood_like_2007_with_structural_improvements':
{'layertype': 'raster',
'category': 'hazard',
'subcategory': 'flood',
'title': 'Jakarta flood like 2007 with structural improvements'}
}
for name, keywords in reference.items():
msg = 'Expected layer %s in %s' % (name, metadata.keys())
assert name in metadata.keys(), msg
values = metadata[name]['keywords']
for key in keywords.keys():
refval = keywords[key]
val = values[key]
msg = ('Got value "%s" for key "%s" '
'Expected "%s"' % (val, key, refval))
assert refval == val, msg
plugins = get_admissible_plugins(keywords=reference.values())
msg = 'No compatible layers returned'
assert len(plugins) > 0, msg
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Keywords matching F1 and F3
haz_keywords1 = dict(category='test_cat1',
subcategory='flood',
layertype='raster',
unit='m')
exp_keywords1 = dict(category='test_cat2',
subcategory='population',
layertype='raster',
datatype='population')
# Keywords matching F2 and F3
haz_keywords2 = dict(category='test_cat1',
subcategory='flood',
layertype='raster',
unit='m')
exp_keywords2 = dict(category='test_cat2', subcategory='building')
# Check correct matching of keyword set 1
plugins = get_admissible_plugins([haz_keywords1, exp_keywords1])
msg = 'Expected impact functions F1 and F3 in %s' % str(plugins.keys())
self.assertIn('F1', plugins, msg)
self.assertIn('F3', plugins, msg)
self.assertNotIn('F2', plugins, msg)
# Check correctness of title attribute
self.assertEqual(get_function_title(plugins['F1']), 'Title for F1')
self.assertEqual(get_function_title(plugins['F3']), 'F3')
# Check correct matching of keyword set 2
plugins = get_admissible_plugins([haz_keywords2, exp_keywords2])
msg = 'Expected impact functions F2 and F3 in %s' % str(plugins.keys())
self.assertIn('F2', plugins, msg)
self.assertIn('F3', plugins, msg)
self.assertNotIn('F1', plugins, msg)
# Check correctness of title attribute
self.assertEqual(get_function_title(plugins['F2']), 'Title for F2')
self.assertEqual(get_function_title(plugins['F3']), 'F3')
# Check empty call returns all
plugins = get_admissible_plugins([])
msg = ('Expected at least impact functions F1, F2 and F3 in %s' %
str(plugins.keys()))
self.assertIn('F1', plugins, msg)
self.assertIn('F2', plugins, msg)
self.assertIn('F3', plugins, msg)
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Keywords matching F1 and F3
haz_keywords1 = dict(category='test_cat1', subcategory='flood',
layertype='raster', unit='m')
exp_keywords1 = dict(category='test_cat2',
subcategory='population',
layertype='raster', datatype='population')
# Keywords matching F2 and F3
haz_keywords2 = dict(category='test_cat1', subcategory='flood',
layertype='raster', unit='m')
exp_keywords2 = dict(category='test_cat2',
subcategory='building')
# Check correct matching of keyword set 1
plugins = get_admissible_plugins([haz_keywords1, exp_keywords1])
msg = 'Expected impact functions F1 and F3 in %s' % str(plugins.keys())
self.assertIn('F1', plugins, msg)
self.assertIn('F3', plugins, msg)
self.assertNotIn('F2', plugins, msg)
# Check correctness of title attribute
self.assertEqual(get_function_title(plugins['F1']), 'Title for F1')
self.assertEqual(get_function_title(plugins['F3']), 'F3')
# Check correct matching of keyword set 2
plugins = get_admissible_plugins([haz_keywords2, exp_keywords2])
msg = 'Expected impact functions F2 and F3 in %s' % str(
plugins.keys())
self.assertIn('F2', plugins, msg)
self.assertIn('F3', plugins, msg)
self.assertNotIn('F1', plugins, msg)
# Check correctness of title attribute
self.assertEqual(get_function_title(plugins['F2']), 'Title for F2')
self.assertEqual(get_function_title(plugins['F3']), 'F3')
# Check empty call returns all
plugins = get_admissible_plugins([])
msg = ('Expected at least impact functions F1, F2 and F3 in %s'
% str(plugins.keys()))
self.assertIn('F1', plugins, msg)
self.assertIn('F2', plugins, msg)
self.assertIn('F3', plugins, msg)
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Keywords matching F1 and F3
haz_keywords1 = dict(category='test_cat1',
subcategory='flood',
layertype='raster',
unit='m')
exp_keywords1 = dict(category='test_cat2',
subcategory='population',
layertype='raster',
datatype='population')
# Keywords matching F2 and F3
haz_keywords2 = dict(category='test_cat1',
subcategory='flood',
layertype='raster',
unit='m')
exp_keywords2 = dict(category='test_cat2', subcategory='building')
# Check correct matching of keyword set 1
P = get_admissible_plugins([haz_keywords1, exp_keywords1])
msg = 'Expected impact functions F1 and F3 in %s' % str(P.keys())
assert 'F1' in P and 'F3' in P, msg
# Check correctness of title attribute
assert get_function_title(P['F1']) == 'Title for F1'
assert get_function_title(P['F3']) == 'F3'
# Check correct matching of keyword set 2
P = get_admissible_plugins([haz_keywords2, exp_keywords2])
msg = 'Expected impact functions F2 and F3 in %s' % str(P.keys())
assert 'F2' in P and 'F3' in P, msg
# Check correctness of title attribute
assert get_function_title(P['F2']) == 'Title for F2'
assert get_function_title(P['F3']) == 'F3'
# Check empty call returns all
P = get_admissible_plugins([])
msg = ('Expected at least impact functions F1, F2 and F3 in %s' %
str(P.keys()))
assert 'F1' in P and 'F2' in P and 'F3' in P, msg
def test_get_admissible_plugins(self):
"""Test for get_admissible_plugins function."""
functions = get_admissible_plugins()
message = 'No functions available (len=%ss)' % len(functions)
self.assertTrue(len(functions) > 0, message)
# Also test if it works when we give it two layers
# to see if we can determine which functions will
# work for them.
keywords1 = read_file_keywords(self.raster_shake_path)
keywords2 = read_file_keywords(self.vector_path)
# We need to explicitly add the layer type to each keyword list
keywords1['layertype'] = 'raster'
keywords2['layertype'] = 'vector'
functions = [keywords1, keywords2]
functions = get_admissible_plugins(functions)
message = 'No functions available (len=%ss)' % len(functions)
self.assertTrue(len(functions) > 0, message)
def test_get_admissible_plugins(self):
"""Test for get_admissible_plugins function."""
functions = get_admissible_plugins()
message = 'No functions available (len=%ss)' % len(functions)
self.assertTrue(len(functions) > 0, message)
# Also test if it works when we give it two layers
# to see if we can determine which functions will
# work for them.
keywords1 = read_file_keywords(self.raster_shake_path)
keywords2 = read_file_keywords(self.vector_path)
# We need to explicitly add the layer type to each keyword list
keywords1['layertype'] = 'raster'
keywords2['layertype'] = 'vector'
functions = [keywords1, keywords2]
functions = get_admissible_plugins(functions)
message = 'No functions available (len=%ss)' % len(functions)
self.assertTrue(len(functions) > 0, message)
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Keywords matching F1 and F3
haz_keywords1 = dict(category='test_cat1', subcategory='flood',
layertype='raster', unit='m')
exp_keywords1 = dict(category='test_cat2', subcategory='population',
layertype='raster', datatype='population')
# Keywords matching F2 and F3
haz_keywords2 = dict(category='test_cat1', subcategory='flood',
layertype='raster', unit='m')
exp_keywords2 = dict(category='test_cat2', subcategory='building')
# Check correct matching of keyword set 1
P = get_admissible_plugins([haz_keywords1, exp_keywords1])
msg = 'Expected impact functions F1 and F3 in %s' % str(P.keys())
assert 'F1' in P and 'F3' in P, msg
# Check correctness of title attribute
assert get_function_title(P['F1']) == 'Title for F1'
assert get_function_title(P['F3']) == 'F3'
# Check correct matching of keyword set 2
P = get_admissible_plugins([haz_keywords2, exp_keywords2])
msg = 'Expected impact functions F2 and F3 in %s' % str(P.keys())
assert 'F2' in P and 'F3' in P, msg
# Check correctness of title attribute
assert get_function_title(P['F2']) == 'Title for F2'
assert get_function_title(P['F3']) == 'F3'
# Check empty call returns all
P = get_admissible_plugins([])
msg = ('Expected at least impact functions F1, F2 and F3 in %s'
% str(P.keys()))
assert 'F1' in P and 'F2' in P and 'F3' in P, msg
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Check empty call returns all
P = get_admissible_plugins([])
# List the known impact function names
# based on their class names - not their titles
msg = 'Available impact functions are: %s' % str(P.keys())
#print msg
assert 'Flood Evacuation Function Vector Hazard' in P, msg
assert 'I T B Earthquake Building Damage Function' in P, msg
assert 'Earthquake Building Impact Function' in P, msg
assert 'P A G Fatality Function' in P, msg
assert 'Flood Evacuation Function' in P, msg
assert 'Flood Building Impact Function' in P, msg
assert 'I T B Fatality Function' in P, msg
assert 'Volcano Building Impact' in P, msg
assert 'Volcano Polygon Hazard Population' in P, msg
# This one should get 2 earthquake building impact functions
D1 = {'category': 'hazard', 'subcategory': 'earthquake', 'unit': 'MMI'}
D2 = {'category': 'exposure', 'datatype': 'itb',
'subcategory': 'structure'}
# Add layertype
D1['layertype'] = 'raster'
D2['layertype'] = 'vector'
P = get_admissible_plugins([D1, D2])
msg = 'Expected: len(P) >= 2, Got: len(P) is %i' % len(P)
assert len(P) >= 1, msg # Depending on other tests there could be more
assert 'Earthquake Building Impact Function' in P
# This one should get 3 flood population impact functions
D1 = {'category': 'hazard', 'subcategory': 'flood', 'unit': 'm'}
D2 = {'category': 'exposure', 'subcategory': 'population'}
# Add layertype
D1['layertype'] = 'raster'
D2['layertype'] = 'raster'
P = get_admissible_plugins([D1, D2])
assert len(P) >= 1 # Depending on other tests there could be more
#assert 'W B Flood Evacuation Function' in P
# Try form where only one dictionary is passed
# This one gets all the flood related impact functions
# Try to get general inundation building impact function
f_name = 'Flood Building Impact Function'
P = get_admissible_plugins(D1)
assert len(P) >= 2
#assert 'W B Flood Evacuation Function' in P
assert f_name in P
#assert 'Flood Road Impact Function' in P
D1 = {'category': 'hazard', 'subcategory': 'tsunami'}
D2 = {'category': 'exposure', 'subcategory': 'structure'}
# Add layertype
#D1['layertype'] = 'raster' # Not required for flood building impact
D2['layertype'] = 'vector'
P = get_admissible_plugins([D1, D2])
msg = 'Expected name "%s" in P: %s' % (f_name, P)
assert f_name in P, msg
# Get requirements from expected function
P_all = get_admissible_plugins()
assert P[f_name] == P_all[f_name]
requirelines = requirements_collect(P[f_name])
for i, D in enumerate([D1, D2]):
for key in D:
msg = 'Key %s was not found in %s' % (key, requirelines[i])
assert key in requirelines[i], msg
msg = 'Val %s was not found in %s' % (D[key], requirelines[i])
assert D[key] in requirelines[i], msg
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Check empty call returns all
admissible_plugins = get_admissible_plugins([])
# List the known impact function names
# based on their class names - not their titles
msg = (
'Available impact functions are: %s' %
str(admissible_plugins.keys()))
self.assertIn(
'Flood Evacuation Function Vector Hazard',
admissible_plugins, msg)
self.assertIn(
'I T B Earthquake Building Damage Function',
admissible_plugins, msg)
self.assertIn(
'Earthquake Building Impact Function',
admissible_plugins, msg)
self.assertIn(
'P A G Fatality Function',
admissible_plugins, msg)
self.assertIn(
'Flood Evacuation Function',
admissible_plugins, msg)
self.assertIn(
'Flood Building Impact Function',
admissible_plugins, msg)
self.assertIn(
'I T B Fatality Function',
admissible_plugins, msg)
self.assertIn(
'Volcano Building Impact',
admissible_plugins, msg)
self.assertIn(
'Volcano Polygon Hazard Population',
admissible_plugins, msg)
# This one should get 2 earthquake building impact functions
dict1 = {
'category': 'hazard',
'subcategory': 'earthquake',
'unit': 'MMI'}
dict2 = dict(
category='exposure',
datatype='itb',
subcategory='structure')
# Add layertype
dict1['layertype'] = 'raster'
dict2['layertype'] = 'vector'
admissible_plugins = get_admissible_plugins([dict1, dict2])
msg = (
'Expected: len(admissible_plugins) >= 2, Got: '
'len(admissible_plugins) is %i' % len(admissible_plugins))
# Depending on other tests there could be more
assert len(admissible_plugins) >= 1, msg
assert 'Earthquake Building Impact Function' in admissible_plugins
# This one should get 3 flood population impact functions
dict1 = {'category': 'hazard', 'subcategory': 'flood', 'unit': 'm'}
dict2 = dict(category='exposure', subcategory='population')
# Add layertype
dict1['layertype'] = 'raster'
dict2['layertype'] = 'raster'
admissible_plugins = get_admissible_plugins([dict1, dict2])
# Depending on other tests there could be more
assert len(admissible_plugins) >= 1
# assert 'W B Flood Evacuation Function' in admissible_plugins
# Try form where only one dictionary is passed
# This one gets all the flood related impact functions
# Try to get general inundation building impact function
f_name = 'Flood Building Impact Function'
admissible_plugins = get_admissible_plugins(dict1)
assert len(admissible_plugins) >= 2
# assert 'W B Flood Evacuation Function' in admissible_plugins
assert f_name in admissible_plugins
# assert 'Flood Road Impact Function' in admissible_plugins
dict1 = {'category': 'hazard', 'subcategory': 'tsunami'}
dict2 = dict(category='exposure', subcategory='structure')
# Add layertype
# Not required for flood building impact
# dict1['layertype'] = 'raster'
dict2['layertype'] = 'vector'
admissible_plugins = get_admissible_plugins([dict1, dict2])
msg = 'Expected name "%s" in admissible_plugins: %s' % (
f_name, admissible_plugins)
assert f_name in admissible_plugins, msg
# Get requirements from expected function
all_plugins = get_admissible_plugins()
assert admissible_plugins[f_name] == all_plugins[f_name]
requirelines = requirements_collect(admissible_plugins[f_name])
for i, D in enumerate([dict1, dict2]):
for key in D:
msg = 'Key %s was not found in %s' % (key, requirelines[i])
assert key in requirelines[i], msg
msg = 'Val %s was not found in %s' % (D[key], requirelines[i])
assert D[key] in requirelines[i], msg
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Check empty call returns all
admissible_plugins = get_admissible_plugins([])
# List the known impact function names
# based on their class names - not their titles
message = (
'Available impact functions are: %s' %
str(admissible_plugins.keys()))
if_names = [
'Flood Evacuation Function Vector Hazard',
'Earthquake Building Impact Function',
'PAG Fatality Function',
'Flood Evacuation Function',
'Flood Vector Building Impact Function',
'Flood Raster Building Impact Function',
'ITB Fatality Function',
'Volcano Building Impact',
'Volcano Polygon Hazard Population',
]
for if_name in if_names:
self.assertIn(if_name, admissible_plugins, message)
# This one should get 1 earthquake building impact functions
dict1 = dict(
category='hazard',
subcategory='earthquake',
layertype='raster',
unit='MMI')
dict2 = dict(
category='exposure',
subcategory='structure',
layertype='vector',
datatype='itb')
admissible_plugins = get_admissible_plugins([dict1, dict2])
message = (
'Expected: len(admissible_plugins) >= 1, Got: '
'len(admissible_plugins) is %i' % len(admissible_plugins))
# Depending on other tests there could be more
self.assertTrue(len(admissible_plugins) >= 1, message)
self.assertIn(
'Earthquake Building Impact Function', admissible_plugins)
# This one should get 1 flood population impact functions
dict1 = dict(
category='hazard',
subcategory='flood',
layertype='raster',
unit='m')
dict2 = dict(
category='exposure',
subcategory='population',
layertype='raster')
admissible_plugins = get_admissible_plugins([dict1, dict2])
# Depending on other tests there could be more
self.assertTrue(len(admissible_plugins) >= 1)
# Try to get general inundation population impact function
f_name = 'Flood Evacuation Function'
self.assertIn(f_name, admissible_plugins)
admissible_plugins = get_admissible_plugins(dict1)
self.assertTrue(len(admissible_plugins) >= 1)
self.assertIn(f_name, admissible_plugins)
dict1 = dict(
category='hazard',
subcategory='flood',
layertype='raster')
dict2 = dict(
category='exposure',
subcategory='structure',
layertype='vector')
admissible_plugins = get_admissible_plugins([dict1, dict2])
f_name = 'Flood Raster Building Impact Function'
message = 'Expected name "%s" in admissible_plugins: %s' % (
f_name, admissible_plugins)
self.assertIn(f_name, admissible_plugins, message)
# Get requirements from expected function
all_plugins = get_admissible_plugins()
self.assertEqual(admissible_plugins[f_name], all_plugins[f_name])
requirelines = requirements_collect(admissible_plugins[f_name])
for i, D in enumerate([dict1, dict2]):
for key in D:
message = 'Key %s was not found in %s' % (key, requirelines[i])
self.assertIn(key, requirelines[i], message)
message = (
'Val %s was not found in %s' % (D[key], requirelines[i]))
self.assertIn(D[key], requirelines[i], message)
def test_filtering_of_impact_functions(self):
"""Impact functions are filtered correctly
"""
# Check empty call returns all
P = get_admissible_plugins([])
# List the known impact function names
# based on their class names - not their titles
msg = 'Available impact functions are: %s' % str(P.keys())
#print msg
assert 'Flood Evacuation Function Vector Hazard' in P, msg
assert 'I T B Earthquake Building Damage Function' in P, msg
assert 'Earthquake Building Impact Function' in P, msg
assert 'P A G Fatality Function' in P, msg
assert 'Flood Evacuation Function' in P, msg
assert 'Flood Building Impact Function' in P, msg
assert 'I T B Fatality Function' in P, msg
assert 'Volcano Building Impact' in P, msg
assert 'Volcano Polygon Hazard Population' in P, msg
# This one should get 2 earthquake building impact functions
D1 = {'category': 'hazard', 'subcategory': 'earthquake', 'unit': 'MMI'}
D2 = {
'category': 'exposure',
'datatype': 'itb',
'subcategory': 'structure'
}
# Add layertype
D1['layertype'] = 'raster'
D2['layertype'] = 'vector'
P = get_admissible_plugins([D1, D2])
msg = 'Expected: len(P) >= 2, Got: len(P) is %i' % len(P)
assert len(P) >= 1, msg # Depending on other tests there could be more
assert 'Earthquake Building Impact Function' in P
# This one should get 3 flood population impact functions
D1 = {'category': 'hazard', 'subcategory': 'flood', 'unit': 'm'}
D2 = {'category': 'exposure', 'subcategory': 'population'}
# Add layertype
D1['layertype'] = 'raster'
D2['layertype'] = 'raster'
P = get_admissible_plugins([D1, D2])
assert len(P) >= 1 # Depending on other tests there could be more
#assert 'W B Flood Evacuation Function' in P
# Try form where only one dictionary is passed
# This one gets all the flood related impact functions
# Try to get general inundation building impact function
f_name = 'Flood Building Impact Function'
P = get_admissible_plugins(D1)
assert len(P) >= 2
#assert 'W B Flood Evacuation Function' in P
assert f_name in P
#assert 'Flood Road Impact Function' in P
D1 = {'category': 'hazard', 'subcategory': 'tsunami'}
D2 = {'category': 'exposure', 'subcategory': 'structure'}
# Add layertype
#D1['layertype'] = 'raster' # Not required for flood building impact
D2['layertype'] = 'vector'
P = get_admissible_plugins([D1, D2])
msg = 'Expected name "%s" in P: %s' % (f_name, P)
assert f_name in P, msg
# Get requirements from expected function
P_all = get_admissible_plugins()
assert P[f_name] == P_all[f_name]
requirelines = requirements_collect(P[f_name])
for i, D in enumerate([D1, D2]):
for key in D:
msg = 'Key %s was not found in %s' % (key, requirelines[i])
assert key in requirelines[i], msg
msg = 'Val %s was not found in %s' % (D[key], requirelines[i])
assert D[key] in requirelines[i], msg
def test_plugin_compatibility(self):
"""Default plugins perform as expected
"""
# Upload a raster and a vector data set
hazard_filename = os.path.join(UNITDATA, 'hazard',
'jakarta_flood_design.tif')
hazard_layer = save_to_geonode(hazard_filename)
check_layer(hazard_layer, full=True)
exposure_filename = os.path.join(UNITDATA, 'exposure',
'buildings_osm_4326.shp')
exposure_layer = save_to_geonode(exposure_filename)
check_layer(exposure_layer, full=True)
# Test
plugin_list = get_admissible_plugins()
assert len(plugin_list) > 0
geoserver = {
'url': settings.GEOSERVER_BASE_URL + 'ows',
'name': 'Local Geoserver',
'version': '1.0.0',
'id': 0
}
metadata = get_metadata(geoserver['url'])
msg = 'There were no layers in test geoserver'
assert len(metadata) > 0, msg
# Characterisation test to preserve the behaviour of
# get_layer_descriptors. FIXME: I think we should change this to be
# a dictionary of metadata entries (ticket #126).
reference = {
'geonode:buildings_osm_4326': {
'layertype': 'vector',
'category': 'exposure',
'subcategory': 'structure',
'title': 'buildings_osm_4326'
},
'geonode:jakarta_flood_like_2007_with_structural_improvements': {
'layertype': 'raster',
'category': 'hazard',
'subcategory': 'flood',
'title': 'Jakarta flood like 2007 with structural improvements'
}
}
for name, keywords in reference.items():
msg = 'Expected layer %s in %s' % (name, metadata.keys())
assert name in metadata.keys(), msg
values = metadata[name]['keywords']
for key in keywords.keys():
refval = keywords[key]
val = values[key]
msg = ('Got value "%s" for key "%s" '
'Expected "%s"' % (val, key, refval))
assert refval == val, msg
plugins = get_admissible_plugins(keywords=reference.values())
msg = 'No compatible layers returned'
assert len(plugins) > 0, msg
