def getPersistenceRepresentation(value):
"""
Converts the given value to the persistence string format.
@param value: Value to persist.
@type value: C{object}
@return: Persistence representation.
@rtype: C{basestring}
@raise PersistenceError: Indicating unsupported value type or
problems during conversion.
"""
if value is None:
return _NONE_PERSISTENCE_REPRESENTATION
else:
typeConversionFunctionMap = {
str: _convertFromUnicode,
unicode: _convertFromUnicode,
int: _convertFromDecimal,
float: _convertFromDecimal,
bool: _convertFromBool,
decimal.Decimal: _convertFromDecimal,
list: _convertFromList,
datetime.datetime: _convertFromDatetime,
dict: _convertFromDict
}
valueType = type(value)
if valueType in typeConversionFunctionMap:
return typeConversionFunctionMap[valueType](value)
else:
raise PersistenceError("Persistence support for values of type " \
+ "'%s' is not available." % str(valueType))
def testCleanupTemporary(self):
""" Testing the cleanup procedure """
#success and failure
files = list()
files.append(SimpleMock(error=PersistenceError("")))
_cleanupTemporaryFile(files)
def search(self, restrictions, destination):
"""
@see: L{NullPrincipalSearcher<datafinder.persistence.search.searcher.NullSearcher>}
E1101: Pylint cannot detect the internals of the modules solr and lucene.
"""
# pylint: disable=E1101
results = list()
queryString = search_restriction_mapping.mapSearchRestriction(
restrictions)
if self._configuration.luceneIndexUri.startswith("file:///"):
try:
self._configuration.env.attachCurrentThread()
indexDir = lucene.SimpleFSDirectory(
lucene.File(
self._configuration.luceneIndexUri.replace(
"file:///", "")))
analyzer = lucene.StandardAnalyzer(
lucene.Version.LUCENE_CURRENT)
searcher = lucene.IndexSearcher(indexDir)
query = lucene.QueryParser(lucene.Version.LUCENE_CURRENT,
"content",
analyzer).parse(queryString)
hits = searcher.search(query, constants.MAX_RESULTS)
for hit in hits.scoreDocs:
doc = searcher.doc(hit.doc)
results.append("/%s" % urllib.unquote(
doc.get(constants.FILEPATH_FIELD).encode("utf-8")))
searcher.close()
except Exception, error:
errorMessage = "Cannot search items. Reason: '%s'" % error
raise PersistenceError(errorMessage)
def testAuthenticationCallback(self):
self._fileSystemMock.isAccessible = False
self.assertFalse(self._accessManager.isAccessible(self._datastore))
try:
self._accessManager.checkAccessibility(self._datastore)
except AuthenticationError, error:
callback = error.updateCredentialsCallback
# First try
self.assertFalse(callback({
"username": "******",
"password": "******"
}))
self.assertFalse(self._accessManager.isAccessible(self._datastore))
# Successful retry
self._fileSystemMock.isAccessible = True
self.assertTrue(
callback({
"username": "******",
"password": "******"
}))
self.assertTrue(self._accessManager.isAccessible(self._datastore))
# Problems on credential update
self._fileSystemMock.error = PersistenceError(
"Cannot update credentials.")
self.assertTrue(
callback({
"username": "******",
"password__": "secret"
}))
self.assertTrue(self._accessManager.isAccessible(self._datastore))
def testExecute(self):
""" Tests the execution of a script. """
fileObject = _getFile()
try:
self._fileStorerMock.methodNameResultMap = {
"readData": (fileObject, None)
}
self._script.execute()
finally:
os.remove(fileObject.name)
self._fileStorerMock.methodNameResultMap = {
"readData": (None, PersistenceError(""))
}
self.assertRaises(ConfigurationError, self._script.execute)
fileObject = _getFile()
try:
fileObject.write(" jjj")
fileObject.seek(0)
self._fileStorerMock.methodNameResultMap = {
"readData": (fileObject, None)
}
self.assertRaises(ConfigurationError, self._script.execute)
finally:
os.remove(fileObject.name)
def _createLocalFile(path):
try:
fd = open(path, "wb")
fd.close()
except IOError, error:
errorMessage = os.strerror(error.errno)
raise PersistenceError(errorMessage)
def testAddScript(self):
""" Test the adding of a script extension. """
self._createFileStorerMock.value = SimpleMock(True)
self._sourceFileStorerMock.value = SimpleMock()
self._targetFileStorerMock.value = SimpleMock(False)
self._handler.addScript("file:///local/path/to/script.py")
self._createFileStorerMock.value = SimpleMock(False)
self.assertRaises(ConfigurationError, self._handler.addScript, "file:///local/path/to/script.py")
self._createFileStorerMock.value = SimpleMock(error=PersistenceError(""))
self.assertRaises(ConfigurationError, self._handler.addScript, "file:///local/path/to/script.py")
self._createFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._handler.addScript, "file:///local/path/to/script.py")
def testCreate(self):
""" Tests initial data model persistence. """
self._dataModelHandler.create()
self._fileStorerMock.error = PersistenceError()
self.assertRaises(ConfigurationError, self._dataModelHandler.create)
def testErrorHandlingOnLibraryInstanceCreation(self):
""" Tests the error handling when creating concrete library instances. """
adapter = DataWebdavAdapter("/anotherIdentifier", SimpleMock(),
SimpleMock("anotherIdentifier"),
SimpleMock(error=PersistenceError("")))
try:
self.assertFalse(adapter.isLink)
self.fail("PersistenceError not raised.")
except PersistenceError:
self.assertTrue(True)
try:
self.assertFalse(adapter.isLeaf)
self.fail("PersistenceError not raised.")
except PersistenceError:
self.assertTrue(True)
try:
self.assertFalse(adapter.isCollection)
self.fail("PersistenceError not raised.")
except PersistenceError:
self.assertTrue(True)
self.assertRaises(PersistenceError, adapter.createLink,
self._defaultAdapter)
self.assertRaises(PersistenceError, adapter.createResource)
self.assertRaises(PersistenceError, adapter.createCollection)
self.assertRaises(PersistenceError, adapter.getChildren)
self.assertRaises(PersistenceError, adapter.writeData, StringIO(""))
self.assertRaises(PersistenceError, adapter.readData)
self.assertRaises(PersistenceError, adapter.delete)
self.assertRaises(PersistenceError, adapter.move, self._defaultAdapter)
self.assertRaises(PersistenceError, adapter.copy, self._defaultAdapter)
def testStore(self):
""" Tests the persistence of the data model. """
self._dataModelHandler.store()
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._dataModelHandler.store)
def testDelete(self):
""" FlatDataPersisterTestCase: Tests the deletion. """
self._persister.delete()
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.delete)
def testCreate(self):
""" HierarchicalDataPersisterTestCase: Tests the additional actions performed during creation. """
self._persister.create()
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.create)
def testLoad(self):
""" Tests the initialization of the data store handler. """
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.value = datastores.datastores([datastores.default(name="name1", storeType=constants.DEFAULT_STORE),
datastores.default(name="name2", storeType=constants.DEFAULT_STORE)])
self._datastoreHandler.load()
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._fileStorerMock.methodNameResultMap = {"exists": (False, None)}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (None, PersistenceError(""))}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (None, PersistenceError(""))}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.error = ExpatError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.error = ValueError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
def _retrieveSystemProperties(self, connection):
try:
rawSystemProps = connection.info(self.identifier)
except SubversionError, error:
errorMessage = "Problem during meta data retrieval. " \
+ "Reason: '%s'" % str(error)
raise PersistenceError(errorMessage)
def testImportDataModel(self):
""" Tests the data model import. """
self._createFileStorerMock.value = SimpleMock(SimpleMock())
self._parseStringMock.value = self._persistedDataModel
self._dataModelHandler.importDatamodel("")
self.assertEquals(self._dataModelHandler.datatypes, self._dataTypes)
self.assertEquals(self._dataModelHandler.relations, self._relations)
self._createFileStorerMock.value.error = PersistenceError("")
self.assertRaises(ConfigurationError,
self._dataModelHandler.importDatamodel, "")
self._createFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError,
self._dataModelHandler.importDatamodel, "")
def acquire(self):
"""
Acquires a connection.
@return: Usable connection.
@rtype: C{object}
@raise PersistenceError: Indicating time when acquiring a connection object.
"""
self._lock.acquire()
try:
if self._availableConnections < self._maxConnectionNumber:
connection = self._createConnection()
else:
start = time.time()
while self._determineUnunsedConnection() is None:
if not self._timeout is None:
if time.time() - start > self._timeout:
break
self._lock.wait(1) # check at least every second
connection = self._determineUnunsedConnection()
if connection is None:
raise PersistenceError(
"Time out occurred before a new connection was available."
)
self._connections[id(connection)] = connection, True
return connection
finally:
self._lock.release()
def testCreate(self):
""" Tests the creation of the central icon location. """
self._handler.create()
self._sourceFileStorer.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._handler.create)
def testStoreData(self):
""" DefaultDataPersisterTestCase: Tests the retrieval of data. """
self._persister.storeData(SimpleMock())
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.storeData, SimpleMock())
def testMove(self):
""" HierarchicalDataPersisterTestCase: Tests the additional actions performed during move operations. """
itemMock = SimpleMock(dataPersister=SimpleMock(fileStorer=SimpleMock(parent=SimpleMock())))
self._persister.move(itemMock)
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.move, itemMock)
def _checkWebdavConnection(webdavStorer):
""" Checks the connection of the given resource. """
try:
webdavStorer.validate()
except WebdavError, error:
errorMessage = "Cannot connect to WebDAV server. Reason '%s'." % error.reason
raise PersistenceError(errorMessage)
def testCanHandleLocation(self):
# can handle it
self.assertTrue(self._factory.canHandleLocation)
# Cannot handle
self._factory.release()
self._createSvnConnectionMock.error = PersistenceError("")
self.assertFalse(self._factory.canHandleLocation)
def updateCredentials(self, credentials):
""" @see: L{updateCredentials<datafinder.persistence.factory.FileSystem.updateCredentials>} """
try:
self._configuration.username = credentials["username"]
self._configuration.password = credentials["password"]
except KeyError:
raise PersistenceError("Invalid credentials provided.")
def _convertFromUnicode(value):
if not isinstance(value, unicode):
encoding = sys.getdefaultencoding() or "ascii"
try:
value = unicode(value, encoding)
except UnicodeError, error:
errorMessage = "Problem during string conversion: '%s'" \
% str(error)
raise PersistenceError(errorMessage)
def testErrorHandlingOnLibraryInstanceCreation(self):
""" Tests the error handling when creating concrete library instances. """
adapter = MetadataWebdavAdapter("identifier", SimpleMock(),
SimpleMock(), SimpleMock(),
SimpleMock(error=PersistenceError("")))
self.assertRaises(PersistenceError, adapter.retrieve)
self.assertRaises(PersistenceError, adapter.update, dict())
self.assertRaises(PersistenceError, adapter.delete, [])
def initializeWorkingCopy(self):
""" Checks the working copy out if it does not exist. """
try:
if not os.path.exists(self._workingCopyPath):
self._client.checkout(self._repositoryUri,
self._workingCopyPath)
except ClientError, error:
raise PersistenceError(error)
def testInvalidFileSystem(self):
self._createFileSystemMock.error = PersistenceError(
"Invalid interface.")
isAccessible = self._accessManager.isAccessible(self._datastore)
fileSystem = self._accessManager.getFileSystem(self._datastore)
self.assertFalse(isAccessible)
self.assertTrue(fileSystem is None)
def createResource(self):
""" @see: L{NullDataStorer<datafinder.persistence.data.datastorer.NullDataStorer>} """
if len(self._name) == 0:
raise PersistenceError(
"Cannot create item with empty resource name.")
else:
connection = self._connectionPool.acquire()
try:
parentCollection = self._getParentCollectionStorer(connection)
try:
parentCollection.addResource(self._name)
except WebdavError, error:
errorMessage = u"Cannot create resource '%s'. Reason: '%s'" % (
self.identifier, error.reason)
raise PersistenceError(errorMessage)
finally:
self._connectionPool.release(connection)
def convertToPersistenceFormat(obj):
""" Encodes Python objects in a JSON string.
@raise PersistenceError: If encoding fails.
"""
try:
return json.dumps(obj, default=_jsonEncoder)
except ValueError, error:
raise PersistenceError(str(error))
def readData(self):
""" @see:L{NullDataStorer<datafinder.persistence.data.datastorer.NullDataStorer>} """
try:
return self._archive.open(self._persistenceId, "r", self._password)
except IOError, error:
errorMessage = "Cannot access archive member '%s'.\nReason: '%s'" % (
self.identifier, error.message)
raise PersistenceError(errorMessage)
def testRetrieveData(self):
""" Test retrieveData method of the archive data persister. """
self._persister.retrieveData()
self._persister.retrieveData(2)
self._fileStorerMock.parent.value.error = PersistenceError("Does not exist.")
self.assertRaises(PersistenceError, self._persister.retrieveData, -1)