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
