def testPropertyDefinitionHandling(self):
""" Tests the handling of property definitions. """
self._dataType.addPropertyDefinition(SimpleMock(identifier="name"))
self._dataType.addPropertyDefinition(SimpleMock(identifier="name2"))
self.assertEquals(len(self._dataType.propertyDefinitions), 2)
self._dataType.addPropertyDefinition(SimpleMock(identifier="name"))
self.assertEquals(len(self._dataType.propertyDefinitions), 2)
self._dataType.removePropertyType("name")
self._dataType.removePropertyType("name2")
self.assertEquals(len(self._dataType.propertyDefinitions), 0)
self._dataType.propertyDefinitions = [
SimpleMock(identifier="name"),
SimpleMock(identifier="name2")
]
self.assertEquals(len(self._dataType.propertyDefinitions), 2)
def setUp(self):
""" Creates object under test. """
self._tarFileOpenMock = SimpleMock(SimpleMock([SimpleMock()]))
script.tarfile.open = self._tarFileOpenMock
self._configFileStorerMock = SimpleMock(methodNameResultMap={
"readData": (StringIO(""), None),
"exists": (True, None)
})
self._createFileStorerMock = SimpleMock(
SimpleMock(self._configFileStorerMock))
script.createFileStorer = self._createFileStorerMock
script.atexit = SimpleMock()
self._fileStorerMock = SimpleMock(name="name", uri="file:///name")
self._fileStorerMock.value = SimpleMock()
self._scriptCollection = script.ScriptCollection(self._fileStorerMock)
def testIsCollection(self):
""" Tests the normal behavior of the isCollection method. """
adapter = DataWebdavAdapter("identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (True, None)}))
self.assertTrue(adapter.isCollection)
self.assertTrue(adapter.canAddChildren)
adapter = DataWebdavAdapter(
"identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, "/thelinkTargetPath")}))
self.assertFalse(adapter.isCollection)
self.assertFalse(adapter.canAddChildren)
adapter = DataWebdavAdapter("identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, None)}))
self.assertFalse(adapter.isCollection)
self.assertFalse(adapter.canAddChildren)
def testImport(self):
""" Tests the import of data store configurations. """
self._createFileStorerMock.value = SimpleMock(SimpleMock())
self._parseStringMock.value = datastores.datastores([datastores.default(name="name1", storeType=constants.DEFAULT_STORE),
datastores.default(name="name2", storeType=constants.DEFAULT_STORE)])
self._datastoreHandler.importDataStores("/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._parseStringMock.error = ExpatError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._createFileStorerMock.value = SimpleMock(error=PersistenceError(""))
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._createFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
def testWriteData(self):
""" Tests the behavior of the write data method. """
self._dataAdapter.exists = lambda: False
self._dataAdapter.writeData(StringIO(""))
self._dataAdapter.writeData(StringIO("Some test data to write..."))
self._dataAdapter.exists = lambda: True
self.assertRaises(PersistenceError, self._dataAdapter.writeData,
StringIO(""))
self._dataAdapter.exists = lambda: False
self._connectionMock.value = SimpleMock(error=IOError(""))
self.assertRaises(PersistenceError, self._dataAdapter.writeData,
StringIO("Some test data..."))
self._connectionMock.value = SimpleMock(error=SSHException(""))
self.assertRaises(PersistenceError, self._dataAdapter.writeData,
StringIO("Some test data..."))
def testLoad(self):
""" Tests the initialization. """
self._iconRegistry.load()
self._fileStorerMock.value = [
SimpleMock(name="a16.png"),
SimpleMock(name="a24.png"),
SimpleMock(name="b16.png"),
SimpleMock(name="b24.png")
]
self._iconRegistry.load()
self.assertEquals(len(self._iconRegistry.icons), 2)
self.assertEquals(
len(
self._iconRegistry.getIcons(
LOCAL_INSTALLED_ICONS_DIRECTORY_PATH)), 2)
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._iconRegistry.load)
def testErrorHandling(self):
self._connectionHelper.error = PersistenceError("")
self.assertRaises(PersistenceError, self._adapter.retrieveAcl)
self.assertRaises(PersistenceError, self._adapter.updateAcl, dict())
self.assertRaises(PersistenceError, self._adapter.retrievePrivileges)
self._connectionHelper.error = None
self._connectionHelper.value = SimpleMock(error=WebdavError(""))
self.assertRaises(PersistenceError, self._adapter.retrieveAcl)
self.assertRaises(PersistenceError, self._adapter.updateAcl, dict())
self.assertRaises(PersistenceError, self._adapter.retrievePrivileges)
def testReadData(self):
""" Tests the retrieving of data. """
self._dataAdapter._sendCommand = lambda _, __: None
self._connectionMock.value = StringIO("")
self.assertEquals(self._dataAdapter.readData().read(), "")
self._connectionMock.value = StringIO("Some test data...")
self.assertEquals(self._dataAdapter.readData().read(),
"Some test data...")
self._dataAdapter.exists = lambda: False
self.assertRaises(PersistenceError, self._dataAdapter.readData)
self._dataAdapter.exists = lambda: True
self._connectionMock.value = SimpleMock(error=IOError(""))
self.assertRaises(PersistenceError, self._dataAdapter.readData)
self._connectionMock.value = SimpleMock(error=SSHException(""))
self.assertRaises(PersistenceError, self._dataAdapter.readData)
def testCreate(self):
""" Tests the creation of an ACE. """
persistenceAce = SimpleMock()
persistenceAce.principal = principal.Principal(identifier="principal")
persistenceAce.grantedPrivileges = [privilege.READ_PRIVILEGE.identifier]
persistenceAce.deniedPrivileges = [privilege.WRITE_PRIVILEGE.identifier]
mappedAce = self._ace.create(persistenceAce)
self.assertEquals(mappedAce.principal.identifier, "principal")
self.assertEquals(mappedAce.grantedPrivileges, set([privilege.READ_PRIVILEGE]))
self.assertEquals(mappedAce.deniedPrivileges, set([privilege.WRITE_PRIVILEGE]))
def testDataStoreGetter(self):
""" Tests the read-only properties of the handler allowing access to the data store configurations. """
# Fine for testing: pylint: disable=W0212
datastores_ = {"tsm": SimpleMock(storeType=constants.TSM_CONNECTOR_STORE, isMigrated=False),
"file": SimpleMock(storeType=constants.FILE_STORE, isMigrated=False),
"ftp": SimpleMock(storeType=constants.FTP_STORE, isMigrated=False),
"gridftp": SimpleMock(storeType=constants.GRIDFTP_STORE, isMigrated=False),
"default": SimpleMock(storeType=constants.DEFAULT_STORE, isMigrated=False),
"webdav": SimpleMock(storeType=constants.WEBDAV_STORE, isMigrated=False),
"offline": SimpleMock(storeType=constants.OFFLINE_STORE, isMigrated=False),
"s3": SimpleMock(storeType = constants.S3_STORE, isMigrated=False),
"svn": SimpleMock(storeType = constants.SUBVERSION_STORE, isMigrated=False),
"svn_migrated": SimpleMock(storeType = constants.SUBVERSION_STORE, isMigrated=True)}
self._datastoreHandler._datastores = datastores_
self.assertEquals(len(self._datastoreHandler.datastores), 10)
self.assertEquals(len(self._datastoreHandler.archiveDatastores), 1)
self.assertEquals(len(self._datastoreHandler.onlineDatastores), 7)
self.assertEquals(len(self._datastoreHandler.offlineDatastores), 1)
self.assertEquals(len(self._datastoreHandler.externalDatastores), 7)
def testErrorHandling(self):
""" Tests the error handling. """
self._itemMock.properties = {DATASTORE_NAME_ID: SimpleMock(value=None)}
self._factory._determineDatastore = SimpleMock()
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state,
constants.ITEM_STATE_UNSUPPORTED_STORAGE_INTERFACE)
self.assertTrue(isinstance(dataPersister,
persisters.NullDataPersister))
self._itemMock.properties = {DATASTORE_NAME_ID: SimpleMock(value=None)}
self._dataStoreMock.storeType = ""
self._factory._determineDatastore = SimpleMock(self._dataStoreMock)
self._dataStoreAccessManagerMock.methodNameResultMap[
"isAccessible"] = (False, None)
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state,
constants.ITEM_STATE_UNSUPPORTED_STORAGE_INTERFACE)
self.assertTrue(isinstance(dataPersister,
persisters.NullDataPersister))
def testCopy(self):
""" FlatDataPersisterTestCase: Tests the additional actions performed during copying. """
itemMock = SimpleMock(uri="test",
properties={CONTENT_IDENTIFIER_ID:None})
self._persister.copy(itemMock)
itemMock.properties = dict()
self.assertRaises(ItemError, self._persister.copy, itemMock)
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.copy, itemMock)
def testLoad(self):
""" Tests the creation of a relation from the persistence format. """
newRelation = relation.Relation.load(
SimpleMock(name="name",
iconName="iconName",
sourceDataTypeNames=["a", "b"],
targetDataTypeNames=["c", "d"]))
self.assertEquals(newRelation.name, "name")
self.assertEquals(newRelation.iconName, "iconName")
self.assertEquals(newRelation.sourceDataTypeNames, ["a", "b"])
self.assertEquals(newRelation.targetDataTypeNames, ["c", "d"])
def testCreateDataPersiterWithArchivalDataStore(self):
""" Tests the creation with archival data stores. """
self._factory._determineDatastore = SimpleMock(self._dataStoreMock)
self._itemMock.fileStorer = SimpleMock()
self._itemMock.properties[ARCHIVE_ROOT_COLLECTION_ID] = SimpleMock(
value=None)
self._itemMock.properties[ARCHIVE_PART_INDEX_ID] = SimpleMock(value=0)
self._dataStoreMock.storeType = ""
self._dataStoreMock.isMigrated = False
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state,
constants.ITEM_STATE_ARCHIVED_MEMBER)
self.assertTrue(isinstance(dataPersister,
persisters.NullDataPersister))
self._itemMock.properties[
ARCHIVE_RETENTION_EXCEEDED_DATETIME_ID] = SimpleMock(value=None)
self._itemMock.properties[ARCHIVE_PART_COUNT_ID] = SimpleMock(value=0)
del self._itemMock.properties[ARCHIVE_ROOT_COLLECTION_ID]
del self._itemMock.properties[ARCHIVE_PART_INDEX_ID]
self._dataStoreMock.storageRealisation = STORAGE_REALISATION_MODE_ENUM.FLAT
self._dataStoreMock.readOnly = False
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state, constants.ITEM_STATE_ARCHIVED)
self.assertTrue(
isinstance(dataPersister, persisters.ArchiveDataPersister))
self._dataStoreMock.readOnly = True
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state,
constants.ITEM_STATE_ARCHIVED_READONLY)
self.assertTrue(
isinstance(dataPersister, persisters.ArchiveDataPersister))
def testDelete(self):
""" HierarchicalDataPersisterTestCase: Tests the deletion. """
# deletion without deletion of parent directories
self._persister.delete()
# deletion wit deletion of parent directories
self._fileStorerMock.parent.value = list()
self._fileStorerMock.parent.parent = SimpleMock(list(), name="")
self._persister.delete()
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(PersistenceError, self._persister.delete)
def testCreate(self):
""" Tests the creation from persistence format. """
persistedPrincipal = SimpleMock()
persistedPrincipal.identifier = "principal"
persistedPrincipal.type = "____user____"
persistedGroup = SimpleMock()
persistedGroup.identifier = "group"
persistedGroup.type = "____group____"
persistedGroup.memberof = list()
persistedPrincipal.memberof = [persistedGroup]
mappedPrincipal = self._principal.create(persistedPrincipal)
self.assertEquals(mappedPrincipal, self._principal)
self.assertEquals(len(mappedPrincipal.memberof), 1)
# Checking loop detection
persistedPrincipal.memberof.append(persistedPrincipal)
self.assertRaises(CoreError, self._principal.create, persistedPrincipal)
# Checking invalid type
persistedPrincipal.type = "unknown"
self.assertRaises(CoreError, self._principal.create, persistedPrincipal)
def testRemoveIcon(self):
""" Tests the removal of an icon. """
self._sourceFileStorer.value = SimpleMock(True)
self._targetFileStorer.value = SimpleMock(True)
self._handler.removeIcon(SimpleMock())
self._sourceFileStorer.value = SimpleMock(error=PersistenceError(""))
self.assertRaises(ConfigurationError, self._handler.removeIcon,
SimpleMock())
self._targetFileStorer.value = SimpleMock(error=PersistenceError(""))
self._sourceFileStorer.value = SimpleMock(True)
self.assertRaises(ConfigurationError, self._handler.removeIcon,
SimpleMock())
def testCopy(self):
""" Tests the normal behavior of the copy method. """
#success
destinationBucket = SimpleMock(SimpleMock(SimpleMock(SimpleMock())))
self._defaultAdapter.copy(destinationBucket)
#failure
adapter = DataS3Adapter(
"/anotherIdentifier",
SimpleMock(SimpleMock(SimpleMock(error=self.responseError))),
SimpleMock())
try:
adapter.copy(destinationBucket)
self.fail("PersistenceError not thrown")
except PersistenceError:
self.assertTrue(True)
def testScriptCreationErrorHandling(self):
""" Tests the error handling when creating a script. """
self._fileStorerMock.methodNameResultMap = {
"readData": (None, PersistenceError(""))
}
self.assertRaises(PersistenceError, script.Script,
self._fileStorerMock)
self._fileStorerMock.methodNameResultMap = {
"readData": (SimpleMock(error=IOError), None)
}
self.assertRaises(ConfigurationError, script.Script,
self._fileStorerMock)
def setUp(self):
""" Creates object under test. """
self._fileStorerMock = SimpleMock()
self._itemMock = SimpleMock(uri="", properties={CONTENT_IDENTIFIER_ID:SimpleMock(value="")})
self._propertyRegistryMock = SimpleMock(SimpleMock())
self._persister = persisters.FlatDataPersister(
"dataState", SimpleMock(), self._itemMock, self._propertyRegistryMock)
self._persister._fileStorer = self._fileStorerMock
def testIsLink(self):
""" Tests the normal behavior of the isLink method. """
adapter = DataWebdavAdapter(
"identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, "/thelinkTargetPath")}))
self.assertTrue(adapter.isLink)
adapter = DataWebdavAdapter("identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, None)}))
self.assertFalse(adapter.isLink)
def testCopy(self):
""" Tests the copy method behavior. """
destination = adapter.DataFileSystemAdapter("", SimpleMock())
self._shutilMock.error = None
self._adapter.copy(destination)
self._shutilMock.error = IOError("")
self.assertRaises(PersistenceError, self._adapter.copy, destination)
self._shutilMock.error = OSError("")
self.assertRaises(PersistenceError, self._adapter.copy, destination)
self._shutilMock.error = shutil.Error("")
self.assertRaises(PersistenceError, self._adapter.copy, destination)
def testLinkTarget(self):
""" Tests the link target property. """
adapter = DataWebdavAdapter(
"identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, "/thelinkTargetPath")}))
self.assertEquals(adapter.linkTarget, "/thelinkTargetPath")
self.assertTrue(adapter.isLink)
adapter = DataWebdavAdapter("identifier", SimpleMock(), SimpleMock(),
SimpleMock({"/": (False, None)}))
self.assertEquals(adapter.linkTarget, None)
self.assertFalse(adapter.isLink)
def setUp(self):
"""
Set up a minimal item tree which has a root->collection[->leaf, ->link] structure.
It uses the configuration attribute "__checker__" as the checker in charge.
"""
# A sanity checker (tree walker)
self.checker = self.__checker__(False, True, True)
# A root for testing
self.testRoot = ItemRoot("root")
self.testRoot._privileges = [ALL_PRIVILEGE]
self.testRoot._fileStorer = SimpleMock(list(), canAddChildren=True)
self.testRoot._dataPersister = SimpleMock(
self.testRoot.fileStorer, state=constants.ITEM_STATE_ACCESSIBLE)
self.testRoot.itemFactory = SimpleMock(self.testRoot.fileStorer)
self.testRoot.path = "/"
# A collection for testing
self.testNode = ItemCollection("collection")
self.testNode._privileges = [ALL_PRIVILEGE]
self.testNode._fileStorer = SimpleMock(
list(), state=constants.ITEM_STATE_ARCHIVED)
self.testNode.itemFactory = SimpleMock(self.testNode.fileStorer)
self.testNode.parent = self.testRoot
# A leaf for testing
self.testLeaf = ItemLeaf("leaf")
self.testLeaf._privileges = [ALL_PRIVILEGE]
self.testLeaf._fileStorer = SimpleMock(
list(), state=constants.ITEM_STATE_ACCESSIBLE)
self.testLeaf.itemFactory = SimpleMock(self.testLeaf.fileStorer)
self.testLeaf.parent = self.testNode
# A link for testing
self.testLink = ItemLink("link")
self.testLink._privileges = [ALL_PRIVILEGE]
self.testLink._fileStorer = SimpleMock(list())
self.testLink.itemFactory = SimpleMock(self.testLink.fileStorer)
self.testLink.parent = self.testNode
self.testLink._linkTarget = self.testRoot
def testCreate(self):
""" Tests the creation of ACL. """
newAcl = self._acl.create([
_PersistenceAceMock("a"),
_PersistenceAceMock("b"),
_PersistenceAceMock("c")
])
self.assertEquals(len(newAcl.principals), 3)
invalidPrivAce = _PersistenceAceMock("a")
invalidPrivAce.grantedPrivileges = [self._UNSUPPORTED_PRIVILEGE]
self.assertRaises(PrivilegeError, self._acl.create, [invalidPrivAce])
invalidPrincipalAce = _PersistenceAceMock("a")
invalidPrincipalAce.principal = SimpleMock("a")
self.assertRaises(PrincipalError, self._acl.create,
[invalidPrincipalAce])
def testComparison(self):
""" Tests the comparison of two instances. """
self.assertEquals(self._ace, self._ace)
anotherAce = ace.AccessControlListEntry(SimpleMock("principal"))
self.assertNotEquals(self._ace, anotherAce)
anotherAce.principal = self._ace.principal
self.assertEquals(self._ace, anotherAce)
anotherAce.grantPrivilege(privilege.READ_PRIVILEGE)
self.assertNotEquals(self._ace, anotherAce)
self._ace.grantPrivilege(privilege.READ_PRIVILEGE)
self.assertEquals(self._ace, anotherAce)
self.assertEquals(self._ace, deepcopy(self._ace))
def testStore(self):
""" Tests the storing of the preferences. """
self._handler.load()
writeDataMock = _WriteDataMock()
self._fileStorerMock.writeData = writeDataMock
self._handler.showDottedFilesLocal = True
self._handler.showDottedFilesRemote = False
self._handler.addConnection(
"http://192.168.125.130/repos/config/test2", "test", "test", False,
"ldap://", "OU=DLR,DC=intra,DC=dlr,DC=de", False, None, "ds1",
"ds2")
self._handler.addConnection(
"http://192.168.125.130/repos/config/test1", None, None)
self._handler.addScriptUri("path")
self._handler.addScriptUri("path2")
self._handler.addSearchQuery("query", "query")
self._handler.addSearchQuery("query2", "query2")
self._handler.store()
self.assertEquals(writeDataMock.content, _VALID_CONFIGURATION)
del self._fileStorerMock.writeData
self._handler.load()
self._fileStorerMock.methodNameResultMap = {
"exists": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._fileStorerMock.methodNameResultMap = {
"exists": (False, None),
"createResource": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._fileStorerMock.methodNameResultMap = {
"exists": (True, None),
"writeData": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._handler._preferences = SimpleMock(error=ExpatError())
self._fileStorerMock.methodNameResultMap = {"exists": (True, None)}
self.assertRaises(ConfigurationError, self._handler.store)
def testRetrieveSuccess(self):
""" Tests successful meta data retrieval. """
webdavStorerMock = SimpleMock(dict())
adapter = MetadataWebdavAdapter("identifier", SimpleMock(),
SimpleMock(), SimpleMock("1"),
SimpleMock(webdavStorerMock))
self.assertEquals(adapter.retrieve(), _VALID_PROPERTY_RESULT)
self.assertEquals(adapter.retrieve(list()), dict())
webdavStorerMock.value = {("1", "1"): SimpleMock("value")}
self.assertEquals(adapter.retrieve(["1"]),
{"1": MetadataValue("value")})
def testRemoveScript(self):
""" Tests the removal of a script extension. """
self._sourceFileStorerMock.value = SimpleMock(True)
self._targetFileStorerMock.value = SimpleMock(True)
self._handler.removeScript(SimpleMock(name="scriptBaseFileName"))
self._sourceFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._handler.removeScript, SimpleMock(name="scriptBaseFileName"))
self._sourceFileStorerMock.error = SimpleMock(True)
self._targetFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._handler.removeScript, SimpleMock(name="scriptBaseFileName"))
def testCreateDataPersiterWithCommonDataStores(self):
""" Tests the data persister creation for items which own a data store property. """
self._factory._determineDatastore = SimpleMock(self._dataStoreMock)
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state, constants.ITEM_STATE_ACCESSIBLE)
self.assertTrue(
isinstance(dataPersister, persisters.DefaultDataPersister))
self._dataStoreMock.storeType = OFFLINE_STORE
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state,
constants.ITEM_STATE_INACCESSIBLE)
self.assertTrue(isinstance(dataPersister,
persisters.NullDataPersister))
self._dataStoreMock.storeType = DEFAULT_STORE
self._dataStoreMock.isMigrated = True
dataPersister = self._factory.createDataPersister(self._itemMock)
self.assertEquals(dataPersister.state, constants.ITEM_STATE_MIGRATED)
self.assertTrue(isinstance(dataPersister,
persisters.NullDataPersister))