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))