class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() uri = QgsDataSourceURI() uri.setDatabase(os.path.join(TESTDATA, 'jk.sqlite')) uri.setDataSource('', 'osm_buildings', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') hazard_path = os.path.join(HAZDATA, 'Shakemap_Padang_2009.asc') self.raster_layer, layer_type = load_layer( hazard_path, directory=None) del layer_type self.vector_layer, layer_type = load_layer('Padang_WGS84.shp') del layer_type self.expected_sqlite_keywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building'} self.expected_vector_keywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'structure', 'title': 'Padang WGS84'} self.expected_raster_keywords = { 'category': 'hazard', 'source': 'USGS', 'subcategory': 'earthquake', 'unit': 'MMI', 'title': ('An earthquake in Padang ' 'like in 2009')} 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) assert 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) assert 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) assert keyword == expected_keyword, 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 didnt 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.assertEquals(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) assert keywords == expected_keywords, message def test_append_keywords(self): """Can we append file keywords with the generic readKeywords method.""" layer, _ = clone_padang_layer() new_keywords = {'category': 'exposure', 'test': 'TEST'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) for key, value in new_keywords.iteritems(): message = ( 'Layer keywords misses appended key: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (key, keywords, new_keywords)) assert key in keywords, message message = ( 'Layer keywords misses appended value: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (value, keywords, new_keywords)) assert keywords[key] == value, message def test_read_db_keywords(self): """Can we read sqlite keywords with the generic readKeywords method """ # noinspection PyUnresolvedReferences local_path = os.path.join( os.path.dirname(__file__), '../../..///', 'jk.sqlite') path = os.path.join(TESTDATA, 'test_keywords.db') self.keyword_io.set_keyword_db_path(path) # We need to make a local copy of the dataset so # that we can use a local path that will hash properly on the # database to return us the correct / valid keywords record. shutil.copy2(os.path.join(TESTDATA, 'jk.sqlite'), local_path) uri = QgsDataSourceURI() # always use relative path! uri.setDatabase('../jk.sqlite') uri.setDataSource('', 'osm_buildings', 'Geometry') # create a local version that has the relative url sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'../jk.sqlite\' table="osm_buildings" (Geometry) sql=') message = 'Got source: %s\n\nExpected %s\n' % ( sqlite_layer.source, expected_source) assert sqlite_layer.source() == expected_source, message keywords = self.keyword_io.read_keywords(sqlite_layer) expected_keywords = self.expected_sqlite_keywords assert keywords == expected_keywords, message source = self.sqlite_layer.source() # delete sqlite_layer so that we can delete the file del sqlite_layer os.remove(local_path) message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, source) assert keywords == expected_keywords, message 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.assertEquals(copied_keywords, expected_keywords, message)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keywordIO = KeywordIO() myUri = QgsDataSourceURI() myUri.setDatabase(os.path.join(TESTDATA, 'jk.sqlite')) myUri.setDataSource('', 'osm_buildings', 'Geometry') self.sqliteLayer = QgsVectorLayer(myUri.uri(), 'OSM Buildings', 'spatialite') myHazardPath = os.path.join(HAZDATA, 'Shakemap_Padang_2009.asc') self.fileRasterLayer, myType = load_layer( myHazardPath, directory=None) del myType self.fileVectorLayer, myType = load_layer('Padang_WGS84.shp') del myType self.expectedSqliteKeywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building'} self.expectedVectorKeywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'structure', 'title': 'Padang WGS84'} self.expectedRasterKeywords = { 'category': 'hazard', 'source': 'USGS', 'subcategory': 'earthquake', 'unit': 'MMI', 'title': ('An earthquake in Padang ' 'like in 2009')} def tearDown(self): pass def test_getHashForDatasource(self): """Test we can reliably get a hash for a uri""" myHash = self.keywordIO.hash_for_datasource(PG_URI) myExpectedHash = '7cc153e1b119ca54a91ddb98a56ea95e' myMessage = "Got: %s\nExpected: %s" % (myHash, myExpectedHash) assert myHash == myExpectedHash, myMessage def test_writeReadKeywordFromUri(self): """Test we can set and get keywords for a non local datasource""" myHandle, myFilename = 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(myHandle) os.remove(myFilename) myExpectedKeywords = {'category': 'exposure', 'datatype': 'itb', 'subcategory': 'building'} # SQL insert test # On first write schema is empty and there is no matching hash self.keywordIO.set_keyword_db_path(myFilename) self.keywordIO.write_keywords_for_uri(PG_URI, myExpectedKeywords) # SQL Update test # On second write schema is populated and we update matching hash myExpectedKeywords = {'category': 'exposure', 'datatype': 'OSM', # <--note the change here! 'subcategory': 'building'} self.keywordIO.write_keywords_for_uri(PG_URI, myExpectedKeywords) # Test getting all keywords myKeywords = self.keywordIO.readKeywordFromUri(PG_URI) myMessage = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( myKeywords, myExpectedKeywords, myFilename) assert myKeywords == myExpectedKeywords, myMessage # Test getting just a single keyword myKeyword = self.keywordIO.readKeywordFromUri(PG_URI, 'datatype') myExpectedKeyword = 'OSM' myMessage = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( myKeyword, myExpectedKeyword, myFilename) assert myKeyword == myExpectedKeyword, myMessage # Test deleting keywords actually does delete self.keywordIO.delete_keywords_for_uri(PG_URI) try: myKeyword = self.keywordIO.readKeywordFromUri(PG_URI, 'datatype') #if the above didnt cause an exception then bad myMessage = 'Expected a HashNotFoundError to be raised' assert myMessage except HashNotFoundError: #we expect this outcome so good! pass def test_areKeywordsFileBased(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keywordIO.are_keywords_file_based(self.sqliteLayer) assert self.keywordIO.are_keywords_file_based(self.fileRasterLayer) assert self.keywordIO.are_keywords_file_based(self.fileVectorLayer) def test_readRasterFileKeywords(self): """Can we read raster file keywords using generic readKeywords method """ myKeywords = self.keywordIO.read_keywords(self.fileRasterLayer) myExpectedKeywords = self.expectedRasterKeywords mySource = self.fileRasterLayer.source() myMessage = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage def test_readVectorFileKeywords(self): """Test read vector file keywords with the generic readKeywords method. """ myKeywords = self.keywordIO.read_keywords(self.fileVectorLayer) myExpectedKeywords = self.expectedVectorKeywords mySource = self.fileVectorLayer.source() myMessage = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage def test_appendKeywords(self): """Can we append file keywords with the generic readKeywords method.""" myLayer, _ = makePadangLayerClone() myNewKeywords = {'category': 'exposure', 'test': 'TEST'} self.keywordIO.update_keywords(myLayer, myNewKeywords) myKeywords = self.keywordIO.read_keywords(myLayer) for myKey, myValue in myNewKeywords.iteritems(): myMessage = ( 'Layer keywords misses appended key: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (myKey, myKeywords, myNewKeywords)) assert myKey in myKeywords, myMessage myMessage = ( 'Layer keywords misses appended value: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (myValue, myKeywords, myNewKeywords)) assert myKeywords[myKey] == myValue, myMessage def test_readDBKeywords(self): """Can we read sqlite keywords with the generic readKeywords method """ myLocalPath = os.path.join(os.path.dirname(__file__), '../../..///', 'jk.sqlite') myPath = os.path.join(TESTDATA, 'test_keywords.db') self.keywordIO.set_keyword_db_path(myPath) # We need to make a local copy of the dataset so # that we can use a local path that will hash properly on the # database to return us the correct / valid keywords record. shutil.copy2(os.path.join(TESTDATA, 'jk.sqlite'), myLocalPath) myUri = QgsDataSourceURI() # always use relative path! myUri.setDatabase('../jk.sqlite') myUri.setDataSource('', 'osm_buildings', 'Geometry') # create a local version that has the relative url mySqliteLayer = QgsVectorLayer(myUri.uri(), 'OSM Buildings', 'spatialite') myExpectedSource = ('dbname=\'../jk.sqlite\' table="osm_buildings"' ' (Geometry) sql=') myMessage = 'Got source: %s\n\nExpected %s\n' % ( mySqliteLayer.source, myExpectedSource) assert mySqliteLayer.source() == myExpectedSource, myMessage myKeywords = self.keywordIO.read_keywords(mySqliteLayer) myExpectedKeywords = self.expectedSqliteKeywords assert myKeywords == myExpectedKeywords, myMessage mySource = self.sqliteLayer.source() # delete mySqliteLayer so that we can delete the file del mySqliteLayer os.remove(myLocalPath) myMessage = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keyword_io = KeywordIO() uri = QgsDataSourceURI() uri.setDatabase(os.path.join(TESTDATA, 'jk.sqlite')) uri.setDataSource('', 'osm_buildings', 'Geometry') self.sqlite_layer = QgsVectorLayer( uri.uri(), 'OSM Buildings', 'spatialite') hazard_path = os.path.join(HAZDATA, 'Shakemap_Padang_2009.asc') self.raster_layer, layer_type = load_layer( hazard_path, directory=None) del layer_type self.vector_layer, layer_type = load_layer('Padang_WGS84.shp') del layer_type self.expected_sqlite_keywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building'} self.expected_vector_keywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'structure', 'title': 'Padang WGS84'} self.expected_raster_keywords = { 'category': 'hazard', 'source': 'USGS', 'subcategory': 'earthquake', 'unit': 'MMI', 'title': ('An earthquake in Padang ' 'like in 2009')} 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) assert 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) assert 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) assert keyword == expected_keyword, 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 didnt 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.assertEquals(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) assert keywords == expected_keywords, message def test_append_keywords(self): """Can we append file keywords with the generic readKeywords method.""" layer, _ = clone_padang_layer() new_keywords = {'category': 'exposure', 'test': 'TEST'} self.keyword_io.update_keywords(layer, new_keywords) keywords = self.keyword_io.read_keywords(layer) for key, value in new_keywords.iteritems(): message = ( 'Layer keywords misses appended key: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (key, keywords, new_keywords)) assert key in keywords, message message = ( 'Layer keywords misses appended value: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (value, keywords, new_keywords)) assert keywords[key] == value, message def test_read_db_keywords(self): """Can we read sqlite kw with the generic readKeywords method """ db_path = os.path.join(TESTDATA, 'test_keywords.db') self.read_db_keywords(db_path) def test_read_legacy_db_keywords(self): """Can we read legacy sqlite kw with the generic readKeywords method """ db_path = os.path.join(TESTDATA, 'test_keywords_legacy.db') self.read_db_keywords(db_path) def read_db_keywords(self, db_path): """Can we read sqlite keywords with the generic readKeywords method """ # noinspection PyUnresolvedReferences local_path = os.path.join( os.path.dirname(__file__), '../../..///', 'jk.sqlite') self.keyword_io.set_keyword_db_path(db_path) # We need to make a local copy of the dataset so # that we can use a local path that will hash properly on the # database to return us the correct / valid keywords record. shutil.copy2(os.path.join(TESTDATA, 'jk.sqlite'), local_path) uri = QgsDataSourceURI() # always use relative path! uri.setDatabase('../jk.sqlite') uri.setDataSource('', 'osm_buildings', 'Geometry') # create a local version that has the relative url sqlite_layer = QgsVectorLayer(uri.uri(), 'OSM Buildings', 'spatialite') expected_source = ( 'dbname=\'../jk.sqlite\' table="osm_buildings" (Geometry) sql=') message = 'Got source: %s\n\nExpected %s\n' % ( sqlite_layer.source(), expected_source) assert 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()) assert keywords == expected_keywords, message source = self.sqlite_layer.source() # delete sqlite_layer so that we can delete the file del sqlite_layer os.remove(local_path) message = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( keywords, expected_keywords, source) assert keywords == expected_keywords, message 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.assertEquals(copied_keywords, expected_keywords, message)
class KeywordIOTest(unittest.TestCase): """Tests for reading and writing of raster and vector data """ def setUp(self): self.keywordIO = KeywordIO() myUri = QgsDataSourceURI() myUri.setDatabase(os.path.join(TESTDATA, 'jk.sqlite')) myUri.setDataSource('', 'osm_buildings', 'Geometry') self.sqliteLayer = QgsVectorLayer(myUri.uri(), 'OSM Buildings', 'spatialite') myHazardPath = os.path.join(HAZDATA, 'Shakemap_Padang_2009.asc') self.fileRasterLayer, myType = load_layer( myHazardPath, directory=None) del myType self.fileVectorLayer, myType = load_layer('Padang_WGS84.shp') del myType self.expectedSqliteKeywords = { 'category': 'exposure', 'datatype': 'OSM', 'subcategory': 'building'} self.expectedVectorKeywords = { 'category': 'exposure', 'datatype': 'itb', 'subcategory': 'structure', 'title': 'Padang WGS84'} self.expectedRasterKeywords = { 'category': 'hazard', 'source': 'USGS', 'subcategory': 'earthquake', 'unit': 'MMI', 'title': ('An earthquake in Padang ' 'like in 2009')} def tearDown(self): pass def test_getHashForDatasource(self): """Test we can reliably get a hash for a uri""" myHash = self.keywordIO.hash_for_datasource(PG_URI) myExpectedHash = '7cc153e1b119ca54a91ddb98a56ea95e' myMessage = "Got: %s\nExpected: %s" % (myHash, myExpectedHash) assert myHash == myExpectedHash, myMessage def test_writeReadKeywordFromUri(self): """Test we can set and get keywords for a non local datasource""" myHandle, myFilename = 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(myHandle) os.remove(myFilename) myExpectedKeywords = {'category': 'exposure', 'datatype': 'itb', 'subcategory': 'building'} # SQL insert test # On first write schema is empty and there is no matching hash self.keywordIO.set_keyword_db_path(myFilename) self.keywordIO.write_keywords_for_uri(PG_URI, myExpectedKeywords) # SQL Update test # On second write schema is populated and we update matching hash myExpectedKeywords = {'category': 'exposure', 'datatype': 'OSM', # <--note the change here! 'subcategory': 'building'} self.keywordIO.write_keywords_for_uri(PG_URI, myExpectedKeywords) # Test getting all keywords myKeywords = self.keywordIO.read_keyword_from_uri(PG_URI) myMessage = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( myKeywords, myExpectedKeywords, myFilename) assert myKeywords == myExpectedKeywords, myMessage # Test getting just a single keyword myKeyword = self.keywordIO.read_keyword_from_uri(PG_URI, 'datatype') myExpectedKeyword = 'OSM' myMessage = 'Got: %s\n\nExpected %s\n\nDB: %s' % ( myKeyword, myExpectedKeyword, myFilename) assert myKeyword == myExpectedKeyword, myMessage # Test deleting keywords actually does delete self.keywordIO.delete_keywords_for_uri(PG_URI) try: myKeyword = self.keywordIO.read_keyword_from_uri(PG_URI, 'datatype') #if the above didnt cause an exception then bad myMessage = 'Expected a HashNotFoundError to be raised' assert myMessage except HashNotFoundError: #we expect this outcome so good! pass def test_areKeywordsFileBased(self): """Can we correctly determine if keywords should be written to file or to database?""" assert not self.keywordIO.are_keywords_file_based(self.sqliteLayer) assert self.keywordIO.are_keywords_file_based(self.fileRasterLayer) assert self.keywordIO.are_keywords_file_based(self.fileVectorLayer) def test_readRasterFileKeywords(self): """Can we read raster file keywords using generic readKeywords method """ myKeywords = self.keywordIO.read_keywords(self.fileRasterLayer) myExpectedKeywords = self.expectedRasterKeywords mySource = self.fileRasterLayer.source() myMessage = 'Got:\n%s\nExpected:\n%s\nSource:\n%s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage def test_readVectorFileKeywords(self): """Test read vector file keywords with the generic readKeywords method. """ myKeywords = self.keywordIO.read_keywords(self.fileVectorLayer) myExpectedKeywords = self.expectedVectorKeywords mySource = self.fileVectorLayer.source() myMessage = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage def test_appendKeywords(self): """Can we append file keywords with the generic readKeywords method.""" myLayer, _ = makePadangLayerClone() myNewKeywords = {'category': 'exposure', 'test': 'TEST'} self.keywordIO.update_keywords(myLayer, myNewKeywords) myKeywords = self.keywordIO.read_keywords(myLayer) for myKey, myValue in myNewKeywords.iteritems(): myMessage = ( 'Layer keywords misses appended key: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (myKey, myKeywords, myNewKeywords)) assert myKey in myKeywords, myMessage myMessage = ( 'Layer keywords misses appended value: %s\n' 'Layer keywords:\n%s\n' 'Appended keywords:\n%s\n' % (myValue, myKeywords, myNewKeywords)) assert myKeywords[myKey] == myValue, myMessage def test_readDBKeywords(self): """Can we read sqlite keywords with the generic readKeywords method """ myLocalPath = os.path.join(os.path.dirname(__file__), '../../..///', 'jk.sqlite') myPath = os.path.join(TESTDATA, 'test_keywords.db') self.keywordIO.set_keyword_db_path(myPath) # We need to make a local copy of the dataset so # that we can use a local path that will hash properly on the # database to return us the correct / valid keywords record. shutil.copy2(os.path.join(TESTDATA, 'jk.sqlite'), myLocalPath) myUri = QgsDataSourceURI() # always use relative path! myUri.setDatabase('../jk.sqlite') myUri.setDataSource('', 'osm_buildings', 'Geometry') # create a local version that has the relative url mySqliteLayer = QgsVectorLayer(myUri.uri(), 'OSM Buildings', 'spatialite') myExpectedSource = ('dbname=\'../jk.sqlite\' table="osm_buildings"' ' (Geometry) sql=') myMessage = 'Got source: %s\n\nExpected %s\n' % ( mySqliteLayer.source, myExpectedSource) assert mySqliteLayer.source() == myExpectedSource, myMessage myKeywords = self.keywordIO.read_keywords(mySqliteLayer) myExpectedKeywords = self.expectedSqliteKeywords assert myKeywords == myExpectedKeywords, myMessage mySource = self.sqliteLayer.source() # delete mySqliteLayer so that we can delete the file del mySqliteLayer os.remove(myLocalPath) myMessage = 'Got: %s\n\nExpected %s\n\nSource: %s' % ( myKeywords, myExpectedKeywords, mySource) assert myKeywords == myExpectedKeywords, myMessage