def show_current_metadata(self): """Show metadata of the current selected layer.""" LOGGER.debug('Showing layer: ' + self.layer.name()) keywords = KeywordIO(self.layer) content_html = keywords.to_message().to_html() full_html = html_header() + content_html + html_footer() self.metadata_preview_web_view.setHtml(full_html)
def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = standard_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = {'datatype': 'OSM'} # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.5', 'value_map': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = standard_data_path('exposure', 'buildings_osm_4326.xml') def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ self.maxDiff = None keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ("{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*High*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I'] } table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*High*, Kawasan Rawan Bencana III------', table.to_text())
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = standard_data_path( 'exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'datatype': 'OSM' } # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.5', 'value_map': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = standard_data_path( 'exposure', 'buildings_osm_4326.xml') def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ self.maxDiff = None keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ( "{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*High*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I']} table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*High*, Kawasan Rawan Bencana III------', table.to_text())
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = standard_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = {'datatype': 'OSM'} # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.5', 'structure_class_field': 'FLOODED', 'value_mapping': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = standard_data_path('exposure', 'buildings_osm_4326.xml') def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ self.maxDiff = None keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" self.maxDiff = None layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard')) new_keywords = {'hazard_category': 'multiple_event'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.assertDictEqual(keywords, expected_keywords) def test_copy_keywords(self): """Test we can copy the keywords.""" self.maxDiff = None out_path = unique_filename(prefix='test_copy_keywords', suffix='.shp') layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) self.keyword_io.copy_keywords(layer, out_path) # copied_keywords = read_file_keywords(out_path.split('.')[0] + 'xml') copied_keywords = read_iso19115_metadata(out_path) expected_keywords = self.expected_raster_keywords expected_keywords['keyword_version'] = inasafe_keyword_version self.assertDictEqual(copied_keywords, expected_keywords) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' keyword_definition = definition(keyword) self.assertTrue('description' in keyword_definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ("{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I'] } table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) def test_keyword_io(self): """Test read keywords directly from keywords file .. versionadded:: 3.2 """ self.maxDiff = None keywords = self.keyword_io.read_keywords_file(self.keyword_path) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building'} # Raster Layer keywords hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } # Vector Layer keywords vector_path = test_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': inasafe_keyword_version, 'structure_class_field': 'FLOODED', 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure' } # Keyword less layer keywordless_path = test_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) def tearDown(self): pass def test_get_hash_for_datasource(self): """Test we can reliably get a hash for a uri""" hash_value = self.keyword_io.hash_for_datasource(PG_URI) expected_hash = '7cc153e1b119ca54a91ddb98a56ea95e' message = "Got: %s\nExpected: %s" % (hash_value, expected_hash) self.assertEqual(hash_value, expected_hash, message) def test_write_read_keyword_from_uri(self): """Test we can set and get keywords for a non local datasource""" handle, filename = tempfile.mkstemp( '.db', 'keywords_', temp_dir()) # Ensure the file is deleted before we try to write to it # fixes windows specific issue where you get a message like this # ERROR 1: c:\temp\inasafe\clip_jpxjnt.shp is not a directory. # This is because mkstemp creates the file handle and leaves # the file open. os.close(handle) os.remove(filename) expected_keywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'building'} # SQL insert test # On first write schema is empty and there is no matching hash self.keyword_io.set_keyword_db_path(filename) self.keyword_io.write_keywords_for_uri(PG_URI, expected_keywords) # SQL Update test # On second write schema is populated and we update matching hash expected_keywords = { 'category': 'exposure', 'datatype': 'OSM', # <--note the change here! 'subcategory': 'building'} self.keyword_io.write_keywords_for_uri(PG_URI, expected_keywords) # Test getting all keywords keywords = self.keyword_io.read_keyword_from_uri(PG_URI) message = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( keywords, expected_keywords, filename) self.assertDictEqual(keywords, expected_keywords, message) # Test getting just a single keyword keyword = self.keyword_io.read_keyword_from_uri(PG_URI, 'datatype') expected_keyword = 'OSM' message = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( keyword, expected_keyword, filename) self.assertDictEqual(keywords, expected_keywords, message) # Test deleting keywords actually does delete self.keyword_io.delete_keywords_for_uri(PG_URI) try: _ = self.keyword_io.read_keyword_from_uri(PG_URI, 'datatype') # if the above didn't cause an exception then bad message = 'Expected a HashNotFoundError to be raised' assert message except HashNotFoundError: # we expect this outcome so good! pass def test_are_keywords_file_based(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keyword_io.are_keywords_file_based(self.sqlite_layer) assert self.keyword_io.are_keywords_file_based(self.raster_layer) assert self.keyword_io.are_keywords_file_based(self.vector_layer) def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ keywords = self.keyword_io.read_keywords(self.raster_layer) expected_keywords = self.expected_raster_keywords source = self.raster_layer.source() message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( keywords, expected_keywords, source) self.assertDictEqual(keywords, expected_keywords, message) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords source = self.vector_layer.source() message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, source) self.assertDictEqual(keywords, expected_keywords, message) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=test_data_path('hazard')) new_keywords = {'category': 'exposure', 'test': 'TEST'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'category': 'exposure', 'hazard_category': 'single_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'test': 'TEST', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } message = 'Got:\n%s\nExpected:\n%s' % (keywords, expected_keywords) self.assertDictEqual(keywords, expected_keywords, message) def test_read_db_keywords(self): """Can we read sqlite kw with the generic read_keywords method """ db_path = test_data_path('other', 'test_keywords.db') self.read_db_keywords(db_path) def read_db_keywords(self, db_path): """Can we read sqlite keywords with the generic readKeywords method """ self.keyword_io.set_keyword_db_path(db_path) # We need to use relative path so that the hash from URI will match local_path = os.path.join( os.path.dirname(__file__), 'exposure.sqlite') sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') shutil.copy2(sqlite_building_path, local_path) uri = QgsDataSourceURI() uri.setDatabase('exposure.sqlite') uri.setDataSource('', 'buildings_osm_4326', 'Geometry') sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'exposure.sqlite\' table="buildings_osm_4326" (' 'Geometry) sql=') message = 'Got source: %s\n\nExpected %s\n' % ( sqlite_layer.source(), expected_source) self.assertEqual(sqlite_layer.source(), expected_source, message) keywords = self.keyword_io.read_keywords(sqlite_layer) expected_keywords = self.expected_sqlite_keywords message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, self.sqlite_layer.source()) self.assertDictEqual(keywords, expected_keywords, message) # Delete SQL Layer so that we can delete the file del sqlite_layer os.remove(local_path) def test_copy_keywords(self): """Test we can copy the keywords.""" out_path = unique_filename( prefix='test_copy_keywords', suffix='.keywords') self.keyword_io.copy_keywords(self.raster_layer, out_path) copied_keywords = read_file_keywords(out_path) expected_keywords = self.expected_raster_keywords message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( copied_keywords, expected_keywords, out_path) self.assertDictEqual(copied_keywords, expected_keywords, message) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' definition = self.keyword_io.definition(keyword) self.assertTrue('description' in definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ( "{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I']} table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text())
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = standard_data_path( 'exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'datatype': 'OSM' } # Raster Layer keywords hazard_path = standard_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.5' } # Vector Layer keywords vector_path = standard_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.5', 'structure_class_field': 'FLOODED', 'value_mapping': {}, 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure', } # Keyword less layer keywordless_path = standard_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = standard_data_path( 'exposure', 'buildings_osm_4326.xml') def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ self.maxDiff = None keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" self.maxDiff = None layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=standard_data_path('hazard')) new_keywords = { 'hazard_category': 'multiple_event' } self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.assertDictEqual(keywords, expected_keywords) def test_copy_keywords(self): """Test we can copy the keywords.""" self.maxDiff = None out_path = unique_filename( prefix='test_copy_keywords', suffix='.shp') layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=standard_data_path('hazard')) self.keyword_io.copy_keywords(layer, out_path) # copied_keywords = read_file_keywords(out_path.split('.')[0] + 'xml') copied_keywords = read_iso19115_metadata(out_path) expected_keywords = self.expected_raster_keywords expected_keywords['keyword_version'] = inasafe_keyword_version self.assertDictEqual(copied_keywords, expected_keywords) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' keyword_definition = definition(keyword) self.assertTrue('description' in keyword_definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ( "{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I']} table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) def test_keyword_io(self): """Test read keywords directly from keywords file .. versionadded:: 3.2 """ self.maxDiff = None keywords = self.keyword_io.read_keywords_file(self.keyword_path) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = {'datatype': 'OSM'} # Raster Layer keywords hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.2' } # Vector Layer keywords vector_path = test_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.3', 'structure_class_field': 'FLOODED', 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure' } # Keyword less layer keywordless_path = test_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = test_data_path('exposure', 'buildings_osm_4326.xml') def tearDown(self): pass def test_get_hash_for_datasource(self): """Test we can reliably get a hash for a uri""" hash_value = self.keyword_io.hash_for_datasource(PG_URI) expected_hash = '7cc153e1b119ca54a91ddb98a56ea95e' message = "Got: %s\nExpected: %s" % (hash_value, expected_hash) self.assertEqual(hash_value, expected_hash, message) def test_are_keywords_file_based(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keyword_io.are_keywords_file_based(self.sqlite_layer) assert self.keyword_io.are_keywords_file_based(self.raster_layer) assert self.keyword_io.are_keywords_file_based(self.vector_layer) def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer(name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=test_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" layer = clone_raster_layer(name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=test_data_path('hazard')) new_keywords = {'hazard_category': 'multiple_event'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.maxDiff = None self.assertDictEqual(keywords, expected_keywords) @unittest.skip('No longer used in the new metadata.') def test_read_db_keywords(self): """Can we read sqlite kw with the generic read_keywords method """ db_path = test_data_path('other', 'test_keywords.db') self.read_db_keywords(db_path) def read_db_keywords(self, db_path): """Can we read sqlite keywords with the generic readKeywords method """ self.keyword_io.set_keyword_db_path(db_path) # We need to use relative path so that the hash from URI will match local_path = os.path.join(os.path.dirname(__file__), 'exposure.sqlite') sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') shutil.copy2(sqlite_building_path, local_path) uri = QgsDataSourceURI() uri.setDatabase('exposure.sqlite') uri.setDataSource('', 'buildings_osm_4326', 'Geometry') sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'exposure.sqlite\' table="buildings_osm_4326" (' 'Geometry) sql=') self.assertEqual(sqlite_layer.source(), expected_source) keywords = self.keyword_io.read_keywords(sqlite_layer) expected_keywords = self.expected_sqlite_keywords self.assertDictEqual(keywords, expected_keywords) # Delete SQL Layer so that we can delete the file del sqlite_layer os.remove(local_path) def test_copy_keywords(self): """Test we can copy the keywords.""" out_path = unique_filename(prefix='test_copy_keywords', suffix='.shp') layer = clone_raster_layer(name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=test_data_path('hazard')) self.keyword_io.copy_keywords(layer, out_path) # copied_keywords = read_file_keywords(out_path.split('.')[0] + 'xml') copied_keywords = read_iso19115_metadata(out_path) expected_keywords = self.expected_raster_keywords expected_keywords['keyword_version'] = inasafe_keyword_version self.maxDiff = None self.assertDictEqual(copied_keywords, expected_keywords) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' keyword_definition = definition(keyword) self.assertTrue('description' in keyword_definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ("{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I'] } table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) def test_keyword_io(self): """Test read keywords directly from keywords file .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords_file(self.keyword_path) expected_keywords = self.expected_vector_keywords message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( keywords, expected_keywords, self.keyword_path) self.assertDictEqual(keywords, expected_keywords, message)
def test_regression_2553_no_resample(self): """Test for regression 2553 (no resampling). see : https://github.com/inasafe/inasafe/issues/2553 We want to verify that population with resampling should produce a result within a reasonable range of the same analysis but doing population with no resampling. """ hazard_path = test_data_path( 'hazard', 'continuous_flood_unaligned_big_size.tif') exposure_path = test_data_path( 'exposure', 'people_allow_resampling_false.tif') hazard_layer, hazard_layer_purpose = load_layer(hazard_path) # Check if there is a regression about keywords being updated from # another layer - see #2605 keywords = KeywordIO(hazard_layer) self.assertIn('flood unaligned', keywords.to_message().to_text()) exposure_layer, exposure_layer_purpose = load_layer( exposure_path) keywords = KeywordIO(exposure_layer) self.assertIn( '*Allow resampling*, false------', keywords.to_message().to_text()) QgsMapLayerRegistry.instance().addMapLayers( [hazard_layer, exposure_layer]) # Count the total value of all exposure pixels # this is arse about face but width is actually giving height height = exposure_layer.width() # this is arse about face but height is actually giving width width = exposure_layer.height() provider = exposure_layer.dataProvider() # Bands count from 1! block = provider.block(1, provider.extent(), height, width) # Enable on-the-fly reprojection set_canvas_crs(GEOCRS, True) # This is the nicer way but wierdly it gets nan for every cell total_population = 0.0 cell_count = 0 row = 0 # Iterate down each column to match the layout produced by r.stats while row < width: column = 0 while column < height: cell_count += 1 value = block.value(row, column) if value > 0: total_population += value column += 1 row += 1 print "Total value of all cells is: %d" % total_population print "Number of cells counted: %d" % cell_count # 131 computed using r.sum self.assertAlmostEqual(total_population, 131.0177006121) result, message = setup_scenario( self.dock, hazard='flood unaligned', exposure='People never resample', function='Need evacuation', function_id='FloodEvacuationRasterHazardFunction') self.assertTrue(result, message) # Press RUN self.dock.accept() safe_layer = self.dock.analysis.impact_layer keywords = safe_layer.get_keywords() evacuated = float(keywords['evacuated']) self.assertLess(evacuated, total_population) expected_evacuated = 131.0 self.assertEqual(evacuated, expected_evacuated)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'datatype': 'OSM' } # Raster Layer keywords hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Generic Continuous Flood', 'hazard': 'flood', 'continuous_hazard_unit': 'generic', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': '3.2' } # Vector Layer keywords vector_path = test_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': '3.3', 'structure_class_field': 'FLOODED', 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure' } # Keyword less layer keywordless_path = test_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) # Keyword file self.keyword_path = test_data_path( 'exposure', 'buildings_osm_4326.xml') def tearDown(self): pass def test_get_hash_for_datasource(self): """Test we can reliably get a hash for a uri""" hash_value = self.keyword_io.hash_for_datasource(PG_URI) expected_hash = '7cc153e1b119ca54a91ddb98a56ea95e' message = "Got: %s\nExpected: %s" % (hash_value, expected_hash) self.assertEqual(hash_value, expected_hash, message) def test_are_keywords_file_based(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keyword_io.are_keywords_file_based(self.sqlite_layer) assert self.keyword_io.are_keywords_file_based(self.raster_layer) assert self.keyword_io.are_keywords_file_based(self.vector_layer) def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=test_data_path('hazard')) keywords = self.keyword_io.read_keywords(layer) expected_keywords = self.expected_raster_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords self.assertDictEqual(keywords, expected_keywords) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" layer = clone_raster_layer( name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=test_data_path('hazard')) new_keywords = { 'hazard_category': 'multiple_event' } self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'hazard_category': 'multiple_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } expected_keywords = { k: get_unicode(v) for k, v in expected_keywords.iteritems() } self.maxDiff = None self.assertDictEqual(keywords, expected_keywords) @unittest.skip('No longer used in the new metadata.') def test_read_db_keywords(self): """Can we read sqlite kw with the generic read_keywords method """ db_path = test_data_path('other', 'test_keywords.db') self.read_db_keywords(db_path) def read_db_keywords(self, db_path): """Can we read sqlite keywords with the generic readKeywords method """ self.keyword_io.set_keyword_db_path(db_path) # We need to use relative path so that the hash from URI will match local_path = os.path.join( os.path.dirname(__file__), 'exposure.sqlite') sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') shutil.copy2(sqlite_building_path, local_path) uri = QgsDataSourceURI() uri.setDatabase('exposure.sqlite') uri.setDataSource('', 'buildings_osm_4326', 'Geometry') sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'exposure.sqlite\' table="buildings_osm_4326" (' 'Geometry) sql=') self.assertEqual(sqlite_layer.source(), expected_source) keywords = self.keyword_io.read_keywords(sqlite_layer) expected_keywords = self.expected_sqlite_keywords self.assertDictEqual(keywords, expected_keywords) # Delete SQL Layer so that we can delete the file del sqlite_layer os.remove(local_path) def test_copy_keywords(self): """Test we can copy the keywords.""" out_path = unique_filename( prefix='test_copy_keywords', suffix='.shp') layer = clone_raster_layer( name='generic_continuous_flood', extension='.asc', include_keywords=True, source_directory=test_data_path('hazard')) self.keyword_io.copy_keywords(layer, out_path) # copied_keywords = read_file_keywords(out_path.split('.')[0] + 'xml') copied_keywords = read_iso19115_metadata(out_path) expected_keywords = self.expected_raster_keywords expected_keywords['keyword_version'] = inasafe_keyword_version self.maxDiff = None self.assertDictEqual(copied_keywords, expected_keywords) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' keyword_definition = definition(keyword) self.assertTrue('description' in keyword_definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_layer_to_message(self): """Test to show augmented keywords if KeywordsIO ctor passed a layer. .. versionadded:: 3.3 """ keywords = KeywordIO(self.vector_layer) message = keywords.to_message().to_text() self.assertIn('*Reference system*, ', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ( "{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I']} table = self.keyword_io._dict_to_row(keyword_value) self.assertIn( u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) def test_keyword_io(self): """Test read keywords directly from keywords file .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords_file(self.keyword_path) expected_keywords = self.expected_vector_keywords message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( keywords, expected_keywords, self.keyword_path) self.assertDictEqual(keywords, expected_keywords, message)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() # SQLite Layer uri = QgsDataSourceURI() sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') uri.setDatabase(sqlite_building_path) uri.setDataSource('', 'buildings_osm_4326', 'Geometry') self.sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') self.expected_sqlite_keywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building' } # Raster Layer keywords hazard_path = test_data_path('hazard', 'tsunami_wgs84.tif') self.raster_layer, _ = load_layer(hazard_path) self.expected_raster_keywords = { 'hazard_category': 'single_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } # Vector Layer keywords vector_path = test_data_path('exposure', 'buildings_osm_4326.shp') self.vector_layer, _ = load_layer(vector_path) self.expected_vector_keywords = { 'keyword_version': inasafe_keyword_version, 'structure_class_field': 'FLOODED', 'title': 'buildings_osm_4326', 'layer_geometry': 'polygon', 'layer_purpose': 'exposure', 'layer_mode': 'classified', 'exposure': 'structure' } # Keyword less layer keywordless_path = test_data_path('other', 'keywordless_layer.shp') self.keywordless_layer, _ = load_layer(keywordless_path) def tearDown(self): pass def test_get_hash_for_datasource(self): """Test we can reliably get a hash for a uri""" hash_value = self.keyword_io.hash_for_datasource(PG_URI) expected_hash = '7cc153e1b119ca54a91ddb98a56ea95e' message = "Got: %s\nExpected: %s" % (hash_value, expected_hash) self.assertEqual(hash_value, expected_hash, message) def test_write_read_keyword_from_uri(self): """Test we can set and get keywords for a non local datasource""" handle, filename = tempfile.mkstemp('.db', 'keywords_', temp_dir()) # Ensure the file is deleted before we try to write to it # fixes windows specific issue where you get a message like this # ERROR 1: c:\temp\inasafe\clip_jpxjnt.shp is not a directory. # This is because mkstemp creates the file handle and leaves # the file open. os.close(handle) os.remove(filename) expected_keywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'building' } # SQL insert test # On first write schema is empty and there is no matching hash self.keyword_io.set_keyword_db_path(filename) self.keyword_io.write_keywords_for_uri(PG_URI, expected_keywords) # SQL Update test # On second write schema is populated and we update matching hash expected_keywords = { 'category': 'exposure', 'datatype': 'OSM', # <--note the change here! 'subcategory': 'building' } self.keyword_io.write_keywords_for_uri(PG_URI, expected_keywords) # Test getting all keywords keywords = self.keyword_io.read_keyword_from_uri(PG_URI) message = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( keywords, expected_keywords, filename) self.assertDictEqual(keywords, expected_keywords, message) # Test getting just a single keyword keyword = self.keyword_io.read_keyword_from_uri(PG_URI, 'datatype') expected_keyword = 'OSM' message = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( keyword, expected_keyword, filename) self.assertDictEqual(keywords, expected_keywords, message) # Test deleting keywords actually does delete self.keyword_io.delete_keywords_for_uri(PG_URI) try: _ = self.keyword_io.read_keyword_from_uri(PG_URI, 'datatype') # if the above didn't cause an exception then bad message = 'Expected a HashNotFoundError to be raised' assert message except HashNotFoundError: # we expect this outcome so good! pass def test_are_keywords_file_based(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keyword_io.are_keywords_file_based(self.sqlite_layer) assert self.keyword_io.are_keywords_file_based(self.raster_layer) assert self.keyword_io.are_keywords_file_based(self.vector_layer) def test_read_raster_file_keywords(self): """Can we read raster file keywords using generic readKeywords method """ keywords = self.keyword_io.read_keywords(self.raster_layer) expected_keywords = self.expected_raster_keywords source = self.raster_layer.source() message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( keywords, expected_keywords, source) self.assertDictEqual(keywords, expected_keywords, message) def test_read_vector_file_keywords(self): """Test read vector file keywords with the generic readKeywords method. """ keywords = self.keyword_io.read_keywords(self.vector_layer) expected_keywords = self.expected_vector_keywords source = self.vector_layer.source() message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, source) self.assertDictEqual(keywords, expected_keywords, message) def test_read_keywordless_layer(self): """Test read 'keyword' file from keywordless layer. """ self.assertRaises( NoKeywordsFoundError, self.keyword_io.read_keywords, self.keywordless_layer, ) def test_update_keywords(self): """Test append file keywords with update_keywords method.""" layer = clone_raster_layer(name='tsunami_wgs84', extension='.tif', include_keywords=True, source_directory=test_data_path('hazard')) new_keywords = {'category': 'exposure', 'test': 'TEST'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) expected_keywords = { 'category': 'exposure', 'hazard_category': 'single_event', 'title': 'Tsunami', 'hazard': 'tsunami', 'continuous_hazard_unit': 'metres', 'test': 'TEST', 'layer_geometry': 'raster', 'layer_purpose': 'hazard', 'layer_mode': 'continuous', 'keyword_version': inasafe_keyword_version } message = 'Got:\n%s\nExpected:\n%s' % (keywords, expected_keywords) self.assertDictEqual(keywords, expected_keywords, message) def test_read_db_keywords(self): """Can we read sqlite kw with the generic read_keywords method """ db_path = test_data_path('other', 'test_keywords.db') self.read_db_keywords(db_path) def read_db_keywords(self, db_path): """Can we read sqlite keywords with the generic readKeywords method """ self.keyword_io.set_keyword_db_path(db_path) # We need to use relative path so that the hash from URI will match local_path = os.path.join(os.path.dirname(__file__), 'exposure.sqlite') sqlite_building_path = test_data_path('exposure', 'exposure.sqlite') shutil.copy2(sqlite_building_path, local_path) uri = QgsDataSourceURI() uri.setDatabase('exposure.sqlite') uri.setDataSource('', 'buildings_osm_4326', 'Geometry') sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'exposure.sqlite\' table="buildings_osm_4326" (' 'Geometry) sql=') message = 'Got source: %s\n\nExpected %s\n' % (sqlite_layer.source(), expected_source) self.assertEqual(sqlite_layer.source(), expected_source, message) keywords = self.keyword_io.read_keywords(sqlite_layer) expected_keywords = self.expected_sqlite_keywords message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, self.sqlite_layer.source()) self.assertDictEqual(keywords, expected_keywords, message) # Delete SQL Layer so that we can delete the file del sqlite_layer os.remove(local_path) def test_copy_keywords(self): """Test we can copy the keywords.""" out_path = unique_filename(prefix='test_copy_keywords', suffix='.keywords') self.keyword_io.copy_keywords(self.raster_layer, out_path) copied_keywords = read_file_keywords(out_path) expected_keywords = self.expected_raster_keywords message = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( copied_keywords, expected_keywords, out_path) self.assertDictEqual(copied_keywords, expected_keywords, message) def test_definition(self): """Test we can get definitions for keywords. .. versionadded:: 3.2 """ keyword = 'hazards' definition = self.keyword_io.definition(keyword) self.assertTrue('description' in definition) def test_to_message(self): """Test we can convert keywords to a message object. .. versionadded:: 3.2 """ keywords = self.keyword_io.read_keywords(self.vector_layer) message = self.keyword_io.to_message(keywords).to_text() self.assertIn('*Exposure*, structure------', message) def test_dict_to_row(self): """Test the dict to row helper works. .. versionadded:: 3.2 """ keyword_value = ("{'high': ['Kawasan Rawan Bencana III'], " "'medium': ['Kawasan Rawan Bencana II'], " "'low': ['Kawasan Rawan Bencana I']}") table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text()) # should also work passing a dict keyword_value = { 'high': ['Kawasan Rawan Bencana III'], 'medium': ['Kawasan Rawan Bencana II'], 'low': ['Kawasan Rawan Bencana I'] } table = self.keyword_io._dict_to_row(keyword_value) self.assertIn(u'\n---\n*high*, Kawasan Rawan Bencana III------', table.to_text())
def test_regression_2553_no_resample(self): """Test for regression 2553 (no resampling). see : https://github.com/inasafe/inasafe/issues/2553 We want to verify that population with resampling should produce a result within a reasonable range of the same analysis but doing population with no resampling. """ hazard_path = test_data_path( 'hazard', 'continuous_flood_unaligned_big_size.tif') exposure_path = test_data_path( 'exposure', 'people_allow_resampling_false.tif') hazard_layer, hazard_layer_purpose = load_layer(hazard_path) # Check if there is a regression about keywords being updated from # another layer - see #2605 keywords = KeywordIO(hazard_layer) self.assertIn('flood unaligned', keywords.to_message().to_text()) exposure_layer, exposure_layer_purpose = load_layer( exposure_path) keywords = KeywordIO(exposure_layer) self.assertIn( '*Allow resampling*, false------', keywords.to_message().to_text()) QgsMapLayerRegistry.instance().addMapLayers( [hazard_layer, exposure_layer]) # Count the total value of all exposure pixels # this is arse about face but width is actually giving height height = exposure_layer.width() # this is arse about face but height is actually giving width width = exposure_layer.height() provider = exposure_layer.dataProvider() # Bands count from 1! block = provider.block(1, provider.extent(), height, width) # Enable on-the-fly reprojection set_canvas_crs(GEOCRS, True) # This is the nicer way but wierdly it gets nan for every cell total_population = 0.0 cell_count = 0 row = 0 # Iterate down each column to match the layout produced by r.stats while row < width: column = 0 while column < height: cell_count += 1 value = block.value(row, column) if value > 0: total_population += value column += 1 row += 1 print "Total value of all cells is: %d" % total_population print "Number of cells counted: %d" % cell_count # 131 computed using r.sum self.assertAlmostEqual(total_population, 131.0177006121) result, message = setup_scenario( self.dock, hazard='flood unaligned', exposure='People never resample', function='Need evacuation', function_id='FloodEvacuationRasterHazardFunction') self.assertTrue(result, message) # Press RUN self.dock.accept() safe_layer = self.dock.impact_function.impact keywords = safe_layer.get_keywords() evacuated = float(keywords['evacuated']) self.assertLess(evacuated, total_population) expected_evacuated = 131.0 self.assertEqual(evacuated, expected_evacuated)