def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
return suite
def suite():
suite = TestSuite()
suite.addTests(
defaultTestLoader.loadTestsFromTestCase(TestSubmissionModule))
suite.addTests(
defaultTestLoader.loadTestsFromTestCase(TestSubmission))
return suite
def suite():
suite = TestSuite()
suite.addTest(
defaultTestLoader.loadTestsFromTestCase(TestWildcardMatching))
suite.addTest(
defaultTestLoader.loadTestsFromTestCase(TestFindCommonPrefix))
return suite
def suite():
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestParseLine))
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestFuzzyMatch))
suite.addTest(
defaultTestLoader.loadTestsFromTestCase(TestAppIdentification))
return suite
def suite_validate_content():
suite = defaultTestLoader.loadTestsFromTestCase(
tests.test_validate_content.TestValidateTools)
suite.addTest(
defaultTestLoader.loadTestsFromTestCase(
tests.test_validate_content.TestValidateScripts))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(LibraryAccessionTestCase))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(LibraryTestCase))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(SampleWebTestCase))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFaLibrary))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(MatchCodeTests))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestMappedReads))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(ElandTests))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestElandMatches))
return suite
def tests(self):
from unittest import defaultTestLoader
yield defaultTestLoader.loadTestsFromTestCase(DetectorTest)
yield defaultTestLoader.loadTestsFromTestCase(ImporterTest)
from hwp5_uno.tests import test_hwp5_uno
yield defaultTestLoader.loadTestsFromModule(test_hwp5_uno)
from hwp5.tests import test_suite
yield test_suite()
def tests(self):
from unittest import defaultTestLoader
yield defaultTestLoader.loadTestsFromTestCase(DetectorTest)
yield defaultTestLoader.loadTestsFromTestCase(ImporterTest)
from hwp5_uno.tests import test_hwp5_uno
yield defaultTestLoader.loadTestsFromModule(test_hwp5_uno)
from hwp5.tests import test_suite
yield test_suite()
def runUnitTest():
moc_stdout = StringIO()
runner = unittest.TextTestRunner(moc_stdout)
suite = loader.loadTestsFromTestCase(TestMacroCommand)
runner.run(suite)
suite = loader.loadTestsFromTestCase(ParserTest)
runner.run(suite)
lx.out(moc_stdout.getvalue())
def full_suite():
# Metadata classes
suite = defaultTestLoader.loadTestsFromTestCase(TestMakeToolMetadata)
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestMakeSubtoolMetadata))
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestMakeParentToolMetadata))
# Get metadata
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestMetadataFromBioTools))
return suite
def selftest(logger):
if os.environ.get('BORG_SELFTEST') == 'disabled':
logger.debug("borg selftest disabled via BORG_SELFTEST env variable")
return
selftest_started = time.perf_counter()
result = SelfTestResult()
test_suite = TestSuite()
for test_case in SELFTEST_CASES:
module = sys.modules[test_case.__module__]
# a normal borg user does not have pytest installed, we must not require it in the test modules used here.
# note: this only detects the usual toplevel import
assert 'pytest' not in dir(module), "pytest must not be imported in %s" % module.__name__
test_suite.addTest(defaultTestLoader.loadTestsFromTestCase(test_case))
test_suite.run(result)
result.log_results(logger)
successful_tests = result.successful_test_count()
count_mismatch = successful_tests != SELFTEST_COUNT
if result.wasSuccessful() and count_mismatch:
# only print this if all tests succeeded
logger.error("self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
"without updating borg.selftest",
successful_tests, SELFTEST_COUNT)
if not result.wasSuccessful() or count_mismatch:
logger.error("self test failed\n"
"Could be a bug either in Borg, the package / distribution you use, your OS or your hardware.")
sys.exit(2)
assert False, "sanity assertion failed: ran beyond sys.exit()"
selftest_elapsed = time.perf_counter() - selftest_started
logger.debug("%d self tests completed in %.2f seconds", successful_tests, selftest_elapsed)
def selftest(logger):
selftest_started = time.perf_counter()
result = SelfTestResult()
test_suite = TestSuite()
for test_case in SELFTEST_CASES:
test_suite.addTest(defaultTestLoader.loadTestsFromTestCase(test_case))
test_suite.run(result)
result.log_results(logger)
successful_tests = result.successful_test_count()
count_mismatch = successful_tests != SELFTEST_COUNT
if result.wasSuccessful() and count_mismatch:
# only print this if all tests succeeded
logger.error(
"self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
"without updating borg.selftest", successful_tests, SELFTEST_COUNT)
if not result.wasSuccessful() or count_mismatch:
logger.error(
"self test failed\n"
"This is a bug either in Borg or in the package / distribution you use."
)
sys.exit(2)
assert False, "sanity assertion failed: ran beyond sys.exit()"
selftest_elapsed = time.perf_counter() - selftest_started
logger.debug("%d self tests completed in %.2f seconds", successful_tests,
selftest_elapsed)
def _execute_test(cls, test: FirmwareTestClass, router: Router, routers: List[Router]) -> TestResult:
if not isinstance(router, Router):
raise ValueError("Chosen Router is not a real Router...")
# proofed: this method runs in other process as the server
setproctitle(str(router.id) + " - " + str(test))
logging.debug("%sExecute test " + str(test) + " on Router(" + str(router.id) + ")", LoggerSetup.get_log_deep(2))
test_suite = defaultTestLoader.loadTestsFromTestCase(test)
# prepare all test cases
for test_case in test_suite:
logging.debug("%sTestCase " + str(test_case), LoggerSetup.get_log_deep(4))
test_case.prepare(router, routers)
result = TestResult()
cls.__setns(router)
try:
result = test_suite.run(result)
except Exception as e:
logging.error("%sTestCase execution raised an exception", LoggerSetup.get_log_deep(3))
logging.error("%s" + str(e), LoggerSetup.get_log_deep(3))
test_obj = test()
result.addError(test_obj, sys.exc_info()) # add the reason of the exception
finally:
# I'm sry for this dirty hack, but if you don't do this you get an
# "TypeError: cannot serialize '_io.TextIOWrapper' object" because sys.stdout is not serializeable...
result._original_stdout = None
result._original_stderr = None
logging.debug("%sResult from test " + str(result), LoggerSetup.get_log_deep(3))
return result
def add_test(self, test):
class CurrentResultRecyclerTest(ResultRecyclerTest):
pass
CurrentResultRecyclerTest.init(**test)
self.addTest(
defaultTestLoader.loadTestsFromTestCase(CurrentResultRecyclerTest))
def run(self):
test_suite = TestSuite(tests=[
defaultTestLoader.loadTestsFromTestCase(TestHamming),
defaultTestLoader.loadTestsFromTestCase(TestSortTrainLabelsKNN),
defaultTestLoader.loadTestsFromTestCase(TestPYXKNN),
defaultTestLoader.loadTestsFromTestCase(TestClassificationError),
defaultTestLoader.loadTestsFromTestCase(TestModelSelectionKNN),
defaultTestLoader.loadTestsFromTestCase(TestEstimateAPrioriNB),
defaultTestLoader.loadTestsFromTestCase(TestEstimatePXYNB),
defaultTestLoader.loadTestsFromTestCase(TestPYXNB),
defaultTestLoader.loadTestsFromTestCase(TestModelSelectionNB),
])
return self.runner.run(test_suite)
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
for testcase in [ExerimentsTestCases,
TestEmailNotify,
TestSequencer]:
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testcase))
return suite
def add_test(self, test):
class CurrentVectorConverterTest(VectorConverterTest):
pass
CurrentVectorConverterTest.init(**test)
self.addTest(
defaultTestLoader.loadTestsFromTestCase(
CurrentVectorConverterTest))
def full_suite():
suite = unittest.TestSuite()
testcases = [RequestHandlerTestCase, MsgPackTestCase]
for testcase in testcases:
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testcase))
return suite
def run(self):
test_suite = TestSuite(tests=[
defaultTestLoader.loadTestsFromTestCase(TestSigmoid),
defaultTestLoader.loadTestsFromTestCase(TestLogisticCostFunction),
defaultTestLoader.loadTestsFromTestCase(TestGradientDescent),
defaultTestLoader.loadTestsFromTestCase(TestStochasticGradientDescent),
defaultTestLoader.loadTestsFromTestCase(TestRegularizedLogisticCostFunction),
defaultTestLoader.loadTestsFromTestCase(TestPrediction),
defaultTestLoader.loadTestsFromTestCase(TestFMeasure),
defaultTestLoader.loadTestsFromTestCase(TestModelSelection),
])
return self.runner.run(test_suite)
def suite():
return defaultTestLoader.loadTestsFromTestCase((
TestMediator,
TestDB,
TestParser,
TestCrawler,
TestCommandHandler,
# TestCrawlerWeb,
TestClientCache,
TestCommandParser))
def add_test(self, test):
class TestUnweightedMetric(TestMetricSkeleton):
@classmethod
def init(cls, metric_class, distance):
super().init(metric_class, distance)
cls.name += " unweighted"
def setUp(self):
self.metric = self.metric_class()
super().setUp()
class TestWeightedMetric(TestMetricSkeleton):
@classmethod
def init(cls, metric_class, distance):
super().init(metric_class, distance)
cls.name += " weighted"
def setUp(self):
self.metric = self.metric_class(self.weights)
super().setUp()
class TestBoundedMetric(TestMetricSkeleton):
@classmethod
def init(cls, metric_class, distance):
super().init(metric_class, distance)
cls.name += " bounded"
def setUp(self):
self.metric = self.metric_class(self.bounds)
super().setUp()
TestUnweightedMetric.init(test['metric_class'],
test['unweighted_distance'])
self.addTest(
defaultTestLoader.loadTestsFromTestCase(TestUnweightedMetric))
TestWeightedMetric.init(test['metric_class'],
test['weighted_distance'])
self.addTest(
defaultTestLoader.loadTestsFromTestCase(TestWeightedMetric))
TestBoundedMetric.init(test['metric_class'], test['weighted_distance'])
self.addTest(
defaultTestLoader.loadTestsFromTestCase(TestBoundedMetric))
def test_with_stdout(self):
class LoudTestCase(TestCase):
def test(self):
print('True is true, who knew!')
self.assertTrue(True)
loud_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(LoudTestCase))
with self.assertRaises(RuntimeError):
self._run_suite(loud_suite)
def test_with_no_stdout(self):
class QuietTestCase(TestCase):
def test(self):
self.assertTrue(True)
quiet_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(QuietTestCase))
result = self._run_suite(quiet_suite)
# No errors should be raised and the suite should have passed
self.assertEqual(result.errors, [])
self.assertEqual(result.failures, [])
def test_with_stdout(self):
class LoudTestCase(TestCase):
def test(self):
print('True is true, who knew!')
self.assertTrue(True)
loud_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(LoudTestCase)
)
with self.assertRaises(RuntimeError):
self._run_suite(loud_suite)
def test_with_no_stdout(self):
class QuietTestCase(TestCase):
def test(self):
self.assertTrue(True)
quiet_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(QuietTestCase)
)
result = self._run_suite(quiet_suite)
# No errors should be raised and the suite should have passed
self.assertEqual(result.errors, [])
self.assertEqual(result.failures, [])
def __init__(self, single_test=None):
super().__init__()
if single_test is None:
self.addTest(
defaultTestLoader.loadTestsFromTestCase(
VectorConverterFailTest))
converter_tests = [single_test] if single_test is not None else [
{
'converter_class': rr_vector.ScalarConverter,
'sample_data': 2.5,
'conv_data': array([2.5]),
'dim': 1,
'keys': (0, )
},
{
'converter_class': rr_vector.NdArrayConverter,
'sample_data': array([2, 3.5]),
'conv_data': array([2, 3.5]),
'dim': 2,
'keys': (0, 1)
},
{
'converter_class': rr_vector.ListConverter,
'sample_data': [2, 3.5],
'conv_data': array([2, 3.5]),
'dim': 2,
'keys': (0, 1)
},
{
'converter_class': rr_vector.TupleConverter,
'sample_data': (2, 3.5),
'conv_data': array([2, 3.5]),
'dim': 2,
'keys': (0, 1)
},
{
'converter_class': rr_vector.DictConverter,
'sample_data': {
'a': 2,
'b': 3.5
},
'conv_data': array([2, 3.5]),
'dim': 2,
'keys': ('a', 'b')
},
]
for test in converter_tests:
self.add_test(test)
def main(path="."):
wasSuccessful = True
suites = TestSuite()
#path = os.path.abspath(path)
print "path='%s'" % path
if type(path) is type([]):
paths = [os.path.abspath(p) for p in path]
[sys.path.append(p) for p in paths]
else:
if os.path.split(path)[1] == "apps":
paths = []
sys.path.append(path)
for file in os.listdir(path):
p = os.path.join(path, file)
if os.path.isdir(p) and not file.startswith("."):
paths.append(p)
sys.path.append(p)
print
print "**********************"
print "%s" % paths
print "**********************"
print
else:
sys.path.append(path)
paths = [path]
for path in paths:
os.chdir(path)
print
print "**********************"
print "Processing '%s'" % path
print "**********************"
print
testClasses = getAllTestClasses(path=path)
for filename, testClassName, testClass in testClasses:
suite = defaultTestLoader.loadTestsFromTestCase(testClass)
print "file='%s', class='%s', test=%s" % (filename, testClassName,
suite.countTestCases())
#result = TextTestRunner(verbosity=1).run(suite)
#if not result.wasSuccessful:
# wasSuccessful = False
suites.addTest(suite)
result = TextTestRunner(verbosity=1).run(suites)
if result.wasSuccessful == False:
wasSuccessful = False
if wasSuccessful:
print "Completed all tests OK."
return True
else:
print "*** One or more tests Failed! ***"
return result
def main(path="."):
wasSuccessful = True
suites = TestSuite()
#path = os.path.abspath(path)
print "path='%s'" % path
if type(path) is type([]):
paths = [os.path.abspath(p) for p in path]
[sys.path.append(p) for p in paths]
else:
if os.path.split(path)[1]=="apps":
paths = []
sys.path.append(path)
for file in os.listdir(path):
p = os.path.join(path, file)
if os.path.isdir(p) and not file.startswith("."):
paths.append(p)
sys.path.append(p)
print
print "**********************"
print "%s" % paths
print "**********************"
print
else:
sys.path.append(path)
paths = [path]
for path in paths:
os.chdir(path)
print
print "**********************"
print "Processing '%s'" % path
print "**********************"
print
testClasses = getAllTestClasses(path=path)
for filename, testClassName, testClass in testClasses:
suite = defaultTestLoader.loadTestsFromTestCase(testClass)
print "file='%s', class='%s', test=%s" % (filename, testClassName, suite.countTestCases())
#result = TextTestRunner(verbosity=1).run(suite)
#if not result.wasSuccessful:
# wasSuccessful = False
suites.addTest(suite)
result = TextTestRunner(verbosity=1).run(suites)
if result.wasSuccessful==False:
wasSuccessful = False
if wasSuccessful:
print "Completed all tests OK."
return True
else:
print "*** One or more tests Failed! ***"
return result
def RunTests():
global TestLoader, TextTestRunner
tests = [
TestSpeech2Text,
TestTemplateGen,
]
for testItem in tests:
testItem.MemoryCtx = MemoryCtx
suite = defaultTestLoader.loadTestsFromTestCase(testItem)
res = TextTestRunner(verbosity=2).run(suite)
if not res.wasSuccessful():
raise Exception("Unit test failed")
def test_with_stdout(self):
class LoudTestCase(TestCase):
def test(self):
print('True is true, who knew!')
self.assertTrue(True)
loud_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(LoudTestCase)
)
with self.assertRaises(AssertionError):
StdoutCapturingTestRunner(verbosity=0).run_suite(
loud_suite,
stream=StringIO()
)
def RunTests():
global TestLoader, TextTestRunner
tests = [
TestTextDecomposition,
TestAgentMethods,
]
for testItem in tests:
testItem.MemoryCtx = MemoryCtx
testItem.Module = Module
suite = defaultTestLoader.loadTestsFromTestCase(testItem)
res = TextTestRunner(verbosity=2).run(suite)
if not res.wasSuccessful():
raise Exception("Unit test failed")
def RunTests():
global TestLoader, TextTestRunner, MemoryCtx
tests = [
TestScAddr,
TestScType,
TestScMemoryContext,
TestScSet,
TestEvents,
TestScHelper,
]
for testItem in tests:
testItem.MemoryCtx = MemoryCtx
testItem.module = module
suite = defaultTestLoader.loadTestsFromTestCase(testItem)
res = TextTestRunner(verbosity=2).run(suite)
if not res.wasSuccessful():
raise Exception("Unit test failed")
def test_with_no_stdout(self):
class QuietTestCase(TestCase):
def test(self):
self.assertTrue(True)
quiet_suite = TestSuite(
tests=defaultTestLoader.loadTestsFromTestCase(QuietTestCase)
)
# Supress test case output while this runs so we don't get weird
# test-case-in-our-test-case messaging
result = StdoutCapturingTestRunner().run_suite(
quiet_suite,
stream=StringIO()
)
# No errors should be raised and the suite should have passed
self.assertEqual(result.errors, [])
self.assertEqual(result.failures, [])
def RunTests():
global TestLoader, TextTestRunner, MemoryCtx
tests = [
TestScAddr,
TestScType,
TestScMemoryContext,
TestScSet,
TestEvents,
TestScHelper,
]
for testItem in tests:
testItem.MemoryCtx = MemoryCtx
testItem.module = module
suite = defaultTestLoader.loadTestsFromTestCase(testItem)
res = TextTestRunner(verbosity=2).run(suite)
if not res.wasSuccessful():
raise Exception("Unit test failed")
def main(path="."):
wasSuccessful = True
suites = TestSuite()
testClasses = getAllTestClasses(path=path)
for filename, testClassName, testClass in testClasses:
suite = defaultTestLoader.loadTestsFromTestCase(testClass)
print "file='%s', class='%s', test=%s" % (filename, testClassName,
suite.countTestCases())
#result = TextTestRunner(verbosity=1).run(suite)
#if not result.wasSuccessful:
# wasSuccessful = False
suites.addTest(suite)
result = TextTestRunner(verbosity=1).run(suites)
wasSuccessful = result.wasSuccessful
if wasSuccessful:
print "Completed all tests OK."
return True
else:
print "*** One or more tests Failed! ***"
return result
def selftest(logger):
selftest_started = time.perf_counter()
result = SelfTestResult()
test_suite = TestSuite()
for test_case in SELFTEST_CASES:
test_suite.addTest(defaultTestLoader.loadTestsFromTestCase(test_case))
test_suite.run(result)
result.log_results(logger)
successful_tests = result.successful_test_count()
count_mismatch = successful_tests != SELFTEST_COUNT
if result.wasSuccessful() and count_mismatch:
# only print this if all tests succeeded
logger.error("self test count (%d != %d) mismatch, either test discovery is broken or a test was added "
"without updating borg.selftest",
successful_tests, SELFTEST_COUNT)
if not result.wasSuccessful() or count_mismatch:
logger.error("self test failed\n"
"This is a bug either in Borg or in the package / distribution you use.")
sys.exit(2)
assert False, "sanity assertion failed: ran beyond sys.exit()"
selftest_elapsed = time.perf_counter() - selftest_started
logger.debug("%d self tests completed in %.2f seconds", successful_tests, selftest_elapsed)
def main(path="."):
wasSuccessful = True
suites = TestSuite()
#path = os.path.abspath(path)
path = fs.absPath(path)
print "path='%s'" % path
if fs.split(path)[1] == "apps":
paths = []
#for file in os.listdir(path):
for file in fs.list(path):
#p = os.path.join(path, file)
p = fs.join(path, file)
#if os.path.isdir(p) and not file.startswith("."):
if fs.isDirectory(p) and not file.startswith("."):
paths.append(p)
else:
paths = [path]
for path in paths:
#No chdir method id FileSystem
os.chdir(path)
print "Processing '%s'" % path
testClasses = getAllTestClasses(path=path)
for filename, testClassName, testClass in testClasses:
suite = defaultTestLoader.loadTestsFromTestCase(testClass)
print "file='%s', class='%s', test=%s" % (filename, testClassName,
suite.countTestCases())
#result = TextTestRunner(verbosity=1).run(suite)
#if not result.wasSuccessful:
# wasSuccessful = False
suites.addTest(suite)
result = TextTestRunner(verbosity=1).run(suites)
if result.wasSuccessful == False:
wasSuccessful = False
if wasSuccessful:
print "Completed all tests OK."
return True
else:
print "*** One or more tests Failed! ***"
return result
def main(path="."):
wasSuccessful = True
suites = TestSuite()
#path = os.path.abspath(path)
path = fs.absPath(path)
print "path='%s'" % path
if fs.split(path)[1]=="apps":
paths = []
#for file in os.listdir(path):
for file in fs.list(path):
#p = os.path.join(path, file)
p = fs.join(path, file)
#if os.path.isdir(p) and not file.startswith("."):
if fs.isDirectory(p) and not file.startswith("."):
paths.append(p)
else:
paths = [path]
for path in paths:
#No chdir method id FileSystem
os.chdir(path)
print "Processing '%s'" % path
testClasses = getAllTestClasses(path=path)
for filename, testClassName, testClass in testClasses:
suite = defaultTestLoader.loadTestsFromTestCase(testClass)
print "file='%s', class='%s', test=%s" % (filename, testClassName, suite.countTestCases())
#result = TextTestRunner(verbosity=1).run(suite)
#if not result.wasSuccessful:
# wasSuccessful = False
suites.addTest(suite)
result = TextTestRunner(verbosity=1).run(suites)
if result.wasSuccessful==False:
wasSuccessful = False
if wasSuccessful:
print "Completed all tests OK."
return True
else:
print "*** One or more tests Failed! ***"
return result
def _execute_test(cls, test: FirmwareTestClass,
router: Router) -> TestResult:
if not isinstance(router, Router):
raise ValueError("Chosen Router is not a real Router...")
# proofed: this method runs in other process as the server
logging.debug("%sExecute test " + str(test) + " on " + str(router),
LoggerSetup.get_log_deep(2))
test_suite = defaultTestLoader.loadTestsFromTestCase(test)
# prepare all test cases
for test_case in test_suite:
logging.debug("%sTestCase " + str(test_case),
LoggerSetup.get_log_deep(4))
test_case.prepare(router)
result = TestResult()
cls.__setns(router)
try:
result = test_suite.run(
result) # TODO if debug set, run as debug()
except Exception as e:
logging.error("%sTestCase raised an exception",
LoggerSetup.get_log_deep(3))
logging.error("%s" + str(e), LoggerSetup.get_log_deep(3))
finally:
# I'm sry for this dirty hack, but if you don't do this you get an
# "TypeError: cannot serialize '_io.TextIOWrapper' object" because sys.stdout is not serializeable...
result._original_stdout = None
result._original_stderr = None
logging.debug("%sResult from test " + str(result),
LoggerSetup.get_log_deep(3))
return result
from unittest import defaultTestLoader from TransactionManager import TransactionManagerBase test_cases = [TransactionManagerBase] tests = [defaultTestLoader.loadTestsFromTestCase(test) for test in test_cases]
def suite():
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestWildcardMatching))
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestFindCommonPrefix))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(SequenceFileTests))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestURLUtilities))
return suite
import requests
result = requests.get('http://localhost:5000/todo/api/v1.0/tasks/1')
self.assertEqual(result.status_code, 200)
def test_get_not_exists_task(self):
import json
import requests
result = requests.get('http://localhost:5000/todo/api/v1.0/tasks/100')
self.assertEqual(json.loads(result.text), {'error': 'Not found'})
class DDeleteTestCase(TestCase):
def test_delete_task(self):
import requests
result = requests.delete('http://localhost:5000/todo/api/v1.0/tasks/1')
self.assertEqual(result.status_code, 200)
if __name__ == '__main__':
suite = list()
suite.append(defaultTestLoader.loadTestsFromTestCase(AMainTestCase))
suite.append(defaultTestLoader.loadTestsFromTestCase(BPostPutTestCase))
suite.append(defaultTestLoader.loadTestsFromTestCase(CGetTestCase))
suite.append(defaultTestLoader.loadTestsFromTestCase(DDeleteTestCase))
todoTestSuite = TestSuite()
todoTestSuite.addTests(suite)
runner = TextTestRunner(verbosity=2)
runner.run(todoTestSuite)
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testSrf2Fastq))
return suite
def suite():
return defaultTestLoader.loadTestsFromTestCase(ConverterTester)
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestVersion))
return suite
def suite():
suite = TestSuite()
suite.addTests(
defaultTestLoader.loadTestsFromTestCase(TestEncoded))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testQueueCommands))
return suite
import os
import sys
sys.path.insert(0, os.path.abspath('..'))
import unittest
from unittest import defaultTestLoader as dtl
from utils.storage import *
from utils.html import *
from utils.url import *
from web.chain import *
from web.reverse import *
from web.convs import *
from web.filter import *
from forms.convs import *
from forms.fields import *
from forms.forms import *
from forms.media import *
suite = unittest.TestSuite()
for item in locals().values():
if isinstance(item, type) and issubclass(item, unittest.TestCase):
suite.addTest(dtl.loadTestsFromTestCase(item))
if __name__ == '__main__':
unittest.TextTestRunner(verbosity=2).run(suite)
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testGenomeMapper))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(InventoryTestCase))
return suite
def suite():
return defaultTestLoader.loadTestsFromTestCase(HashTableTester)
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFMagic))
return suite
def run(verbosity=2):
suite = [
defaultTestLoader.loadTestsFromTestCase(VimeoTests),
defaultTestLoader.loadTestsFromTestCase(YouTubeTests),
]
return TextTestRunner(verbosity=verbosity).run(TestSuite(suite))
def suite():
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestInputState))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
return suite
def run_testcase(testcase_class):
"""Run all the tests in a TestCase and return them."""
suite = defaultTestLoader.loadTestsFromTestCase(testcase_class)
tests = list(suite._tests)
result = TextTestRunner().run(suite)
return tests, result
