def runTestSuite():
"""
Transfer function for setup.py script ro-manager-test
"""
base = os.path.dirname(__file__)
#print "Run test suite assuming base path "+base
sys.path.insert(0, os.path.normpath(base+"/..") )
sys.path.insert(0, os.path.normpath(base+"/../..") )
sys.path.insert(0, os.path.normpath(base+"/../../iaeval/test") )
sys.path.insert(0, os.path.normpath(base+"/../../sync/test") )
#print "Path: "+repr(sys.path)
TestUtils.runTests("TestAll", getTestSuite, sys.argv)
return 0
"component" return suite of component tests
"integration" return suite of integration tests
"all" return suite of unit and component tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testOrigConfig"
, "testMakeConfig"
, "testCopyConfig"
, "testSetConfig"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestWbConfigEdit, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestWbConfigEdit.log", getTestSuite, sys.argv)
, "testUserACreateHTTPCollabDeleteHTTP"
# Test RG Leader's access permissions on files in User A's Private area
, "testRGLeaderCreateCIFSInUserA"
, "testUserACreateCIFSRGLeaderReadCIFS"
, "testUserACreateCIFSRGLeaderUpdateCIFS"
, "testUserACreateCIFSRGLeaderDeleteCIFS"
, "testRGLeaderCreateHTTPInUserA"
, "testUserACreateHTTPRGLeaderReadHTTP"
, "testUserACreateHTTPRGLeaderUpdateHTTP"
, "testUserACreateHTTPRGLeaderDeleteHTTP"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestFileCommonArea, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileCommonArea.log", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testUnits",
"testUnWrap1",
"testUnWrap2",
"testUnWrap3",
"testUnWrap4",
"testUnWrap5",
"testFlatten1",
"testFlatten2",
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"],
}
return TestUtils.getTestSuite(TestEventEnvelope, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventEnvelope.log", getTestSuite, sys.argv)
# End.
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testNull"
, "testLink"
, "testLinkType"
, "testLinkCreated"
, "testLinkRdfType"
, "testLinkUnknownUri"
, "testLinkWithGraph"
, "testLinkWithNotExistentGraph"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestLinks, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestLinks.log", getTestSuite, sys.argv)
# End.
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testEventFromString"
, "testReadLogFile"
, "testReadLogFile2"
, "testLineReader"
],
"component":
[ "testDummy"
],
"integration":
[ "testDummy"
],
"pending":
[ "testDummy"
, "testReadLogFiles"
, "ReadZipFileSendEvents"
, "ReadZipFilesSendEvents"
]
}
return TestUtils.getTestSuite(TestReadEventLogs, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestReadEventLogs.log", getTestSuite, sys.argv)
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testMakeDeferred"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestSyncDeferred, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestSyncDeferred.log", getTestSuite, sys.argv)
# End.
, "testSubscriptionForwarding1"
, "testSubscriptionForwarding2"
, "testSubscriptionForwarding3"
, "testSubscriptionForwarding4"
, "testSubscriptionForwarding5"
, "testSubscriptionForwarding6"
, "testSubscriptionForwarding7"
, "testSubscriptionForwarding8"
, "testBlockingEventDelivery"
, "testInterleavedEventDelivery"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
, "testWatch"
]
}
return TestUtils.getTestSuite(TestEventRouterThreaded, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventRouterThreaded.log", getTestSuite, sys.argv)
# End.
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits"],
"component": ["testComponents"],
"integration": [
"testIntegration", "testTestEventHTTPClientIntro",
"testSubscriptionForwarding1", "testSubscriptionForwarding2",
"testSubscriptionForwarding3", "testSubscriptionForwarding4",
"testTestEventHTTPClientDone"
],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestEventHTTPClient, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventHTTPClient.log", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testCase"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestExample, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestExample", getTestSuite, sys.argv)
# End.
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testUnits", "testUnWrap1", "testUnWrap2", "testUnWrap3",
"testUnWrap4", "testUnWrap5", "testFlatten1", "testFlatten2"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestEventEnvelope, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventEnvelope.log", getTestSuite, sys.argv)
# End.
def testAskQueries(self):
sparqlquery = """ASK { ?s ?p ?o }"""
pattern = re.compile("[ \n]+")
responsedata = self.doQueryGET(sparqlquery)
responsedata = pattern.sub("", responsedata)
self.assertEqual(responsedata, """{"head":{},"boolean":true}""")
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testAskQueries"],
}
return TestUtils.getTestSuite(TestSimplePatterns, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestSimplePatterns.log", getTestSuite, sys.argv)
# End.
Created on Sep 13, 2012
@author: zhaoj
'''
import os, os.path
import sys
import unittest
import logging
# Add main library directory to python path
sys.path.append("../../..")
sys.path.append("..")
import TestHelloAnyone
import TestHelloAnyoneWfprov
import TestHelloAnyoneHandmade
def getTestSuite(select="unit"):
suite = unittest.TestSuite()
#suite.addTest(TestHelloAnyone.getTestSuite(select=select))
suite.addTest(TestHelloAnyoneWfprov.getTestSuite(select=select))
#suite.addTest(TestHelloAnyoneHandmade.getTestSuite(select=select))
return suite
from MiscLib import TestUtils
if __name__ == "__main__":
TestUtils.runTests("AllSingleTests.log", getTestSuite, sys.argv)
from MiscLib import TestUtils
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testNull", "testServiceDocumentAccess"],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": []
}
return TestUtils.getTestSuite(TestDatasetSubmission,
testdict,
select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestDatasetSubmission", getTestSuite, sys.argv)
# End.
"testMakeEnvelopeData2", "testMakeEnvSubscribeData1",
"testMakeEnvSubscribeData2", "testMakeEnvSubscribeData3",
"testMakeEnvSubscribeData4", "testMakeEnvUnsubscribeData",
"testMakeClosedownData", "testMakeIdleData",
"testParseEnvelopeData1", "testParseEnvelopeData2",
"testParseEnvelopeData3", "testParseEnvelopeData4",
"testParseEnvSubscribeData1", "testParseEnvSubscribeData2",
"testParseEnvSubscribeData3", "testParseEnvUnsubscribeData1",
"testParseEnvUnsubscribeData2", "testParseEnvUnsubscribeData3",
"testParseEnvUnsubscribeData4", "testParseEnvUnsubscribeData5",
"testParseMessageData1", "testParseMessageData2",
"testParseMessageData3", "testParseMessageData4",
"testParseMessageData5", "testParseMessageData6",
"testParseMessageData7", "testParseMessageData8",
"testParseMessageData9", "testParseMessageData10",
"testParseMessageData11", "testParseMessageData12",
"testEventEnvelope2"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"zzpending": ["testPending"]
}
return TestUtils.getTestSuite(TestEventSerializer, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventSerializer.log", getTestSuite, sys.argv)
# End.
"component" return suite of component tests
"integration" return suite of integration tests
"all" return suite of unit and component tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
, "testGetHomepage"
, "testGetStatus"
, "testGetConfig"
, "testCommand"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestWbAccess, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestWbAccess.log", getTestSuite, sys.argv)
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testLoad"
, "testRun"
],
"component":
[ "testDummy"
],
"integration":
[ "testDummy"
],
"pending":
[ "testDummy"
]
}
return TestUtils.getTestSuite(TestScheduleProcessor, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestScheduleProcessor.log", getTestSuite, sys.argv)
"all" return suite of udirName, baseDir,nit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ #"testUnits"
"testSubmitDatasetHandlerHTMLResponse"
,"testSubmitDatasetHandlerDatasetCreation"
,"testSubmitDatasetHandlerDatasetDeletion"
,"testSubmitDatasetHandlerDirectorySubmission"
,"testSubmitDatasetHandlerEmptyDirectorySubmission"
,"testSubmitDatasetHandlerUpdateMetadataBeforeSubmission"
,"testUpdateLocalManifestAndDatasetSubmission"
],
"component":
[ #"testComponents"
],
"integration":
[ #"testIntegration"
],
"pending":
[ #"testPending"
]
}
return TestUtils.getTestSuite(TestSubmitDatasetHandler, testdict, select=select)
if __name__ == "__main__":
TestConfig.setDatasetsBaseDir(".")
TestUtils.runTests("TestSubmitDatasetHandler.log", getTestSuite, sys.argv)
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testDataset"
],
"component":
[ "testDummy"
],
"integration":
[ "testDummy"
],
"pending":
[ "testDummy"
]
}
return TestUtils.getTestSuite(TestDataset, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestDataset.log", getTestSuite, sys.argv)
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testNull"],
"component": [
"testComponents", "testSharedUserHTTP",
"testSharedUserCIFSRGLeader", "testSharedUserCIFSCollab"
],
"integration": ["testIntegration"],
"pending": [
"testPending", "testReadMeSSH", "testReadMeDAVfs",
"testCreateFileDAVfs", "testUpdateFileDAVfs",
"testDeleteFileDAVfs", "testDeleteFileCIFS", "testDeleteFileHTTP"
]
}
return TestUtils.getTestSuite(TestFileHTTPwriteCIFSread,
testdict,
select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileHTTPwriteCIFSread", getTestSuite, sys.argv)
# End.
"""
testdict = {
"unit":
[ "testUnits"
, "testNull"
, "testAnnotate"
, "testAnnotateType"
, "testAnnotateKeywords"
, "testAnnotateDescription"
, "testAnnotateCreated"
, "testAnnotateTypeUri"
, "testAnnotateMultiple"
, "testAnnotationDisplay"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestAnnotations, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestAnnotations.log", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testUnits", "testShutdown", "testSubscriptionRouteTable",
"testSubscriptionForwarding1", "testSubscriptionForwarding2",
"testSubscriptionForwarding3", "testSubscriptionForwarding4",
"testSubscriptionForwarding5", "testSubscriptionForwarding6",
"testSubscriptionForwarding7", "testSubscriptionForwarding8",
"testBlockingEventDelivery", "testInterleavedEventDelivery"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending", "testWatch"]
}
return TestUtils.getTestSuite(TestEventRouterThreaded,
testdict,
select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventRouterThreaded.log", getTestSuite, sys.argv)
# End.
import TestTestUtils
import TestFunctions
import TestCombinators
import TestDomHelpers
import TestScanFiles
import TestScanDirectories
import TestNetUtils
import TestSuperGlobal
# Code to run unit tests from all library test modules
def getTestSuite(select="unit"):
suite = unittest.TestSuite()
suite.addTest(TestTestUtils.getTestSuite(select=select))
suite.addTest(TestFunctions.getTestSuite())
suite.addTest(TestCombinators.getTestSuite())
suite.addTest(TestDomHelpers.getTestSuite())
suite.addTest(TestScanFiles.getTestSuite())
suite.addTest(TestScanDirectories.getTestSuite())
suite.addTest(TestNetUtils.getTestSuite())
suite.addTest(TestSuperGlobal.getTestSuite())
return suite
from MiscLib import TestUtils
if __name__ == "__main__":
TestUtils.runTests("TestAll", getTestSuite, sys.argv)
# End.
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testCase", "testArg"],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
for (argname, argval) in testargs:
if argval: setattr(TestExample, argname, argval)
return TestUtils.getTestSuite(TestExample, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
testargs = [("-a", "--arg", "VAL", "arg", "Argument passed to test suite")]
TestUtils.runTests("TestTestUtils.log",
getTestSuite,
sys.argv + ['-a', 'val'],
testargs=testargs)
# End.
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testNull"],
"component": [
"testComponents", "testReadMe", "testCreateFile",
"testRewriteFile", "testUpdateFile", "testDeleteFile",
"testWebDAVFile"
],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestFileAccess, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileAccess", getTestSuite, sys.argv)
# End.
data = self.doQueryPOST(sparqlquery, JSON=True)
self.assertBindingEqual(data, 0,
"An activity can only have one end time")
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testUniqueGeneration", "testUniqueInvalidation",
"testUniqueStartedBy", "testUniqueEndedBy", "testUniqueStartTime",
"testUniqueEndTime"
],
}
return TestUtils.getTestSuite(TestUniqueness, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestUniqueness", getTestSuite, sys.argv)
# End.
suite.addTest(TestSubmitDataset.getTestSuite(select=select))
suite.addTest(TestSubmitDatasetHandler.getTestSuite(select=select))
suite.addTest(TestDirectoryListingHandler.getTestSuite(select=select))
suite.addTest(TestMetadataMerging.getTestSuite(select=select))
suite.addTest(TestGetDatasetMetadataHandler.getTestSuite(select=select))
suite.addTest(TestHttpSession.getTestSuite(select=select))
return suite
from MiscLib import TestUtils
import junitxml
if __name__ == "__main__":
print "============================================================"
print "This test suite needs to run under a Linux operating system"
print "Edit TestConfig.py to specify hostname and other parameters"
print "Create test accounts on target system to match TestConfig.py"
print "============================================================"
TestConfig.setDatasetsBaseDir(".")
if len(sys.argv) >= 2 and sys.argv[1] == "xml":
with open('xmlresults.xml', 'w') as report:
result = junitxml.JUnitXmlResult(report)
result.startTestRun()
getTestSuite().run(result)
result.stopTestRun()
else:
TestUtils.runTests("TestAll", getTestSuite, sys.argv)
# End.
, "testCreateEventAgent1"
, "testCreateEventAgentError"
, "testMakeEventAgent1"
, "testMakeEventAgent2"
, "testMakeEventAgent3"
, "testEventAgentEqual1"
, "testEventAgentEqual2"
, "testEventAgentEqual3"
, "testEventAgentEqual4"
, "testEventAgentEqual5"
, "testEventAgentEqual6"
, "testEventAgentEqual7"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestEventAgent, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventAgent.log", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [ #"testUnits"
"testDirectoryListingHandlerResponse"
],
"component": [ #"testComponents"
],
"integration": [ #"testIntegration"
],
"pending": [ #"testPending"
]
}
return TestUtils.getTestSuite(TestDirectoryListingHandler,
testdict,
select=select)
if __name__ == "__main__":
#logging.basicConfig(level=logging.DEBUG)
TestConfig.setDatasetsBaseDir(".")
TestUtils.runTests("TestDirectoryListingHandler.log", getTestSuite,
sys.argv)
#runner = unittest.TextTestRunner()
#runner.run(getTestSuite())
import junitxml
logger = logging.getLogger("AllTests")
# Code to run unit tests from all library test modules
def getTestSuite(select="all"):
suite = unittest.TestSuite()
suite.addTest(TestAll.getTestSuite(select=select))
return suite
if __name__ == "__main__":
print "============================================================"
print "This test suite needs to run under a Linux operating system"
print "Edit TestConfig.py to specify hostname and other parameters"
print "Create test accounts on target system to match TestConfig.py"
print "============================================================"
#print repr( commands.getstatusoutput('ls ../../'))
TestConfig.setDatasetsBaseDir("../../SubmitDatasetHandler/tests")
if len(sys.argv) >= 2 and sys.argv[1] == "xml":
with open('xmlresults.xml', 'w') as report:
result = junitxml.JUnitXmlResult(report)
result.startTestRun()
getTestSuite().run(result)
result.stopTestRun()
else:
TestUtils.runTests("AllTests", getTestSuite, sys.argv)
# End.
"testUserACreateCIFSCollabReadCIFS",
"testUserACreateCIFSCollabUpdateCIFS",
"testUserACreateCIFSCollabDeleteCIFS",
"testCollabCreateHTTPInUserA",
"testUserACreateHTTPCollabReadHTTP",
"testUserACreateHTTPCollabUpdateHTTP",
"testUserACreateHTTPCollabDeleteHTTP"
# Test RG Leader's access permissions on files in User A's Private area
,
"testRGLeaderCreateCIFSInUserA",
"testUserACreateCIFSRGLeaderReadCIFS",
"testUserACreateCIFSRGLeaderUpdateCIFS",
"testUserACreateCIFSRGLeaderDeleteCIFS",
"testRGLeaderCreateHTTPInUserA",
"testUserACreateHTTPRGLeaderReadHTTP",
"testUserACreateHTTPRGLeaderUpdateHTTP",
"testUserACreateHTTPRGLeaderDeleteHTTP"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestFilePrivateArea, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFilePrivateArea.log", getTestSuite, sys.argv)
# End.
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testNull"],
"component": [
"testComponents", "testReadMeCIFS", "testReadMeHTTP",
"testCreateFileCIFS", "testCreateFileHTTP", "testUpdateFileCIFS",
"testUpdateFileHTTP"
],
"integration": ["testIntegration"],
"pending": [
"testPending", "testReadMeSSH", "testReadMeDAVfs",
"testCreateFileDAVfs", "testUpdateFileDAVfs",
"testDeleteFileDAVfs", "testDeleteFileCIFS", "testDeleteFileHTTP"
]
}
return TestUtils.getTestSuite(TestFileUserASharedPublic,
testdict,
select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileUserASharedPublic", getTestSuite, sys.argv)
# End.
def https_request(self, request):
credentials = self.passwd.find_user_password(None,
request.get_full_url())
if all(credentials):
request.add_header(
self.auth_header,
'Basic %s' % base64.b64encode(':'.join(credentials)))
return request
# Assemble test suite
from MiscLib import TestUtils
def getTestSuite(select="unit"):
testdict = {
"unit": [],
"component": ["testMe"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(OXDSDataset, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("OXDSDataset", getTestSuite, sys.argv)
# End.
[ "testComponents"
, "testSharedUserCIFS"
, "testSharedUserHTTP"
, "testSharedUserHTTPB"
, "testSharedUserHTTPRGLeader"
, "testSharedUserHTTPCollab"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
, "testReadMeSSH"
, "testReadMeDAVfs"
, "testCreateFileDAVfs"
, "testUpdateFileDAVfs"
, "testDeleteFileDAVfs"
, "testDeleteFileCIFS"
, "testDeleteFileHTTP"
]
}
return TestUtils.getTestSuite(TestFileCollabArea, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileCollabArea", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[
"testGenerationPrecedesInvalidation",
"testGenerationPrecedesUsage",
"testUsagePrecedesInvalidation",
"testGenerationOrdering",
"testInvalidationOrdering",
"testDerivationUsageGenerationOrdering",
"testDerivationGenerationGenerationOrdering",
"testWasStartedByOrdering",
"testWasEndedByOrdering",
"testSpecializationGenerationOrdering",
"testSpecializationInvalidationOrdering"
],
}
return TestUtils.getTestSuite(TestEntityOrdering, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestEntityOrdering", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testRunASK", "testRUNSELECT1", "testNumberOfWorkflowOutputsCOUNT",
"testNumberOfWorkflowInputsCOUNT",
"testWorkflowInputPatternSELECT", "testNumberOfProcessRunsCount",
"testNumberOfProcessRunsCount2", "testStartTimeOfRunSelect",
"testEndTimeOfRunSelect", "testSourceArtifactsOfWfOutputCount",
"testSourceActivitiesOfWfOutputCount",
"testAllSourceArtifactsOfWfOutputCount",
"testAllSourceActivitiesOfWfOutputCount", "testOutputOfHelloCount",
"testInputsOfConcatenateCount", "testStartTimeOfConcatenateSelect",
"testEndTimeOfConcatenateSelect"
],
}
return TestUtils.getTestSuite(TestHelloAnyoneHandmade,
testdict,
select=select)
if __name__ == "__main__":
TestUtils.runTests("TestHelloAnyoneHandmade", getTestSuite, sys.argv)
# End.
"""
testdict = {
"unit":
[ "testUnits"
, "testNull"
],
"component":
[ "testComponents"
, "testWebDAVFileRead"
, "testWebDAVFileCreate"
, "testWebDAVFileUpdate"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
, "testWebDAVFile"
, "testWebDAVFileDelete"
]
}
return TestUtils.getTestSuite(TestWebDAVbyHTTP, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestWebDAVbyHTTP", getTestSuite, sys.argv)
# End.
, "testWatch1"
, "testWatch2"
, "testWatch3"
, "testWatch4"
, "testWatch5"
, "testWatch6"
, "testWatch7"
, "testWatchPrior1"
, "testWatchPrior2"
, "testWatchPrior3"
, "testWatchPrior4"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
, "testWatch8"
]
}
return TestUtils.getTestSuite(TestEventPubSub, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventPubSub.log", getTestSuite, sys.argv)
# End.
, "testUserACreateHTTPCollabDeleteHTTP"
# Test RG Leader's access permissions on files in User A's Shared area
, "testRGLeaderCreateCIFSInUserA"
, "testUserACreateCIFSRGLeaderReadCIFS"
, "testUserACreateCIFSRGLeaderUpdateCIFS"
, "testUserACreateCIFSRGLeaderDeleteCIFS"
, "testRGLeaderCreateHTTPInUserA"
, "testUserACreateHTTPRGLeaderReadHTTP"
, "testUserACreateHTTPRGLeaderUpdateHTTP"
, "testUserACreateHTTPRGLeaderDeleteHTTP"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestFileSharedArea, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileSharedArea.log", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[
"GetEvents"
, "DecodeMessage"
, "DecodeMultiple"
, "DecodeDirtyMessage"
],
"component":
[ "testDummy"
],
"integration":
[ "testDummy"
],
"pending":
[ "testDummy"
]
}
return TestUtils.getTestSuite(TestSkyDrivers, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestSkyDrivers.log", getTestSuite, sys.argv)
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ #"testUnits"
"testGetDatasetMetadataResponse"
],
"component":
[ #"testComponents"
],
"integration":
[ #"testIntegration"
],
"pending":
[ #"testPending"
]
}
return TestUtils.getTestSuite(TestGetDatasetMetadataHandler, testdict, select=select)
if __name__ == "__main__":
#logging.basicConfig(level=logging.DEBUG)
TestConfig.setDatasetsBaseDir(".")
TestUtils.runTests("TestGetDatasetMetadataHandler.log", getTestSuite, sys.argv)
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be testSimpleHttpGet_origrun
"""
testdict = {
"unit": [ #"testUnits"
#"testSimpleHttpGet_orig",
"testSimpleHttpGet",
"testSimpleHttpPost",
"testSimpleHttpDelete"
],
"component": [ #"testComponents"
],
"integration": [ #"testIntegration"
],
"pending": [ #"testPending"
]
}
return TestUtils.getTestSuite(TestHttpSession, testdict, select=select)
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
TestConfig.setDatasetsBaseDir(".")
TestUtils.runTests("TestHttpSession.log", getTestSuite, sys.argv)
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testNull"
,"testDatasetSubmission"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[
]
}
return TestUtils.getTestSuite(TestDatasetSubmission, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestDatasetSubmission", getTestSuite, sys.argv)
# End.
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
, "testNull"
, "testTripleExists"
, "testSimpleJSONDecode"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(SparqlQueryTestCase, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("SparqlQueryTestCase", getTestSuite, sys.argv)
# End.
, "testMultipleFilesLocal"
, "testMultipleFilesLocalCleanUp"
, "testMultipleFilesAbsoluteLocal"
, "testSingleDirectoryAbsoluteLocal"
, "testSingleDirectoryRecursiveAbsoluteLocal"
, "testMultipleDirectorysLocal"
, "testMixedDataSetLocal"
, "testMultipleFileChangeLocal"
, "testMixedDataSetChangeLocal"
, "testMultipleFileDeltaLocal"
, "testMixedDataSetDeltaLocal"
, "testCommandLine"
],
"zzcomponent":
[ "testComponents"
],
"integration":
[ "testSingleDirectoryHttpS"
,"testSingleDirectoryFtp"
],
"zzpending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestBackupHandler, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestBackupHandler.log", getTestSuite, sys.argv)
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ #"testUnits"
"testAdmiralModifyUserDetails"
],
"component":
[ #"testComponents"
],
"integration":
[ #"testIntegration"
],
"pending":
[ #"testPending"
]
}
return TestUtils.getTestSuite(TestAdminInterfaceRestfulAPIs, testdict, select=select)
if __name__ == "__main__":
#logging.basicConfig(level=logging.DEBUG)
TestUtils.runTests("TestAdminInterfaceRestfulAPIs.log", getTestSuite, sys.argv)
#runner = unittest.TextTestRunner()
#runner.run(getTestSuite())
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testEventLogger"
],
"component":
[ "testDummy"
],
"integration":
[ "testDummy"
],
"pending":
[ "testDummy"
]
}
return TestUtils.getTestSuite(TestLogEvents, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestLogEvents.log", getTestSuite, sys.argv)
"testUserACreateCIFSCollabReadCIFS",
"testUserACreateCIFSCollabUpdateCIFS",
"testUserACreateCIFSCollabDeleteCIFS",
"testCollabCreateHTTPInUserA",
"testUserACreateHTTPCollabReadHTTP",
"testUserACreateHTTPCollabUpdateHTTP",
"testUserACreateHTTPCollabDeleteHTTP"
# Test RG Leader's access permissions on files in User A's Private area
,
"testRGLeaderCreateCIFSInUserA",
"testUserACreateCIFSRGLeaderReadCIFS",
"testUserACreateCIFSRGLeaderUpdateCIFS",
"testUserACreateCIFSRGLeaderDeleteCIFS",
"testRGLeaderCreateHTTPInUserA",
"testUserACreateHTTPRGLeaderReadHTTP",
"testUserACreateHTTPRGLeaderUpdateHTTP",
"testUserACreateHTTPRGLeaderDeleteHTTP"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestFileCommonArea, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestFileCommonArea.log", getTestSuite, sys.argv)
# End.
"""
testdict = {
"unit":
[
"testRUNOfAWorkflow",
"testRUNOfAWorkflow2",
"testNumberOfWorkflowOutputsCOUNT",
"testNumberOfWorkflowOutputsCOUNTProv",
"testNumberOfWorkflowInputsCOUNT",
"testNumberOfWorkflowInputsCOUNTProv",
"testWorkflowInputPatternSELECT",
"testNumberOfProcessRunsCount",
"testStartTimeOfRunSelect",
"testEndTimeOfRunSelect",
"testSourceArtifactsOfWfOutputCount",
"testSourceActivitiesOfWfOutputCount",
"testOutputOfConcatenateCount",
"testInputsOfConcatenateCount",
"testStartTimeOfConcatenateSelect",
"testEndTimeOfConcatenateSelect",
"testIntermediateOutputsCount",
"testIntermediateInputsCount"
],
}
return TestUtils.getTestSuite(TestHelloAnyoneWfprov, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("TestHelloAnyoneWfprov", getTestSuite, sys.argv)
# End.
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testReadMetadata",
"testUpdateMetadata",
"testGetElementValuesFromManifest",
"testGetDictionaryFromManifest",
],
"component": [], # "testComponents"
"integration": [], # "testIntegration"
"pending": [], # "testPending"
}
return TestUtils.getTestSuite(TestMetadataMerging, testdict, select=select)
if __name__ == "__main__":
TestConfig.setDatasetsBaseDir(".")
TestUtils.runTests("TestMetadataMerging.log", getTestSuite, sys.argv)
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"zzunit":
[ "testDummy"
],
"zzcomponent":
[ "testDummy"
],
"integration":
[ "testSend"
, "testListen"
],
"zzpending":
[ "testDummy"
]
}
return TestUtils.getTestSuite(TestCounters, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestCounters.log", getTestSuite, sys.argv)
# Assemble test suite
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
["testUnits", "testNull", "testTripleExists", "testSimpleJSONDecode"],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(SparqlQueryTestCase, testdict, select=select)
if __name__ == "__main__":
TestUtils.runTests("SparqlQueryTestCase", getTestSuite, sys.argv)
# End.
# Assemble test suite
from MiscLib import TestUtils
def getTestSuite(select="unit"):
testdict = {
"unit":
[
],
"component":
[ "testMe"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(OXDSDataset, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("OXDSDataset", getTestSuite, sys.argv)
# End.
],
"integration":
[ "testIntegration"
, "verifyVersion"
, "verifyName"
, "verifyNodeNumber"
, "verifyFadeRate"
, "verifyIp"
, "verifyMacAddress"
, "verifyRotary"
, "verifyDwellConfiguration"
, "verifySetPointConfiguration"
, "verifyDoNameConfiguration"
, "verifyAoNameConfiguration"
, "verifyDigitalIn"
, "verifyTemperatures"
, "verifyAnalogueIn"
, "verifySchedules"
, "verifyScenes"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestWb6Config, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestWb6Config.log", getTestSuite, sys.argv)
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": [
"testUnits", "testDate1", "testTime1", "testDateTime1",
"testDateTime2"
],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestURI, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestURI.log", getTestSuite, sys.argv)
# End.
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit":
[ "testUnits"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
, "testTestEventHTTPClientIntro"
, "testSubscriptionForwarding1"
, "testSubscriptionForwarding2"
, "testSubscriptionForwarding3"
, "testSubscriptionForwarding4"
, "testTestEventHTTPClientDone"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestEventHTTPClient, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestEventHTTPClient.log", getTestSuite, sys.argv)
# End.
, "testStatusEqual1"
, "testStatusEqual2"
, "testStatusEqual3"
, "testStatusString1"
, "testStatusString2"
, "testStatusString3"
, "testStatusString4"
, "testStatusException1"
, "testStatusException2"
, "testStatusEvent1"
, "testStatusEvent2"
, "testStatusValues"
],
"component":
[ "testComponents"
],
"integration":
[ "testIntegration"
],
"pending":
[ "testPending"
]
}
return TestUtils.getTestSuite(TestStatusVals, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestStatus.log", getTestSuite, sys.argv)
# End.
# Assemble test suite
from MiscLib import TestUtils
def getTestSuite(select="unit"):
"""
Get test suite
select is one of the following:
"unit" return suite of unit tests only
"component" return suite of unit and component tests
"all" return suite of unit, component and integration tests
"pending" return suite of pending tests
name a single named test to be run
"""
testdict = {
"unit": ["testUnits", "testMakeDeferred"],
"component": ["testComponents"],
"integration": ["testIntegration"],
"pending": ["testPending"]
}
return TestUtils.getTestSuite(TestSyncDeferred, testdict, select=select)
# Run unit tests directly from command line
if __name__ == "__main__":
TestUtils.runTests("TestSyncDeferred.log", getTestSuite, sys.argv)
# End.
