def __init__(self,
config=None,
importer=None,
workingDir=None,
selector=JUnitSelector):
"""Initialize a test loader
"""
TestLoader.__init__(self, config, importer, workingDir, selector)
log.debug("JUnitTestLoader.__init__(): config = %s", config)
if hasattr(config.options, 'compiled_root'):
self.compiledTestsRoot = config.options.compiled_root
if os.name == "nt":
self.compiledTestsRoot = self.compiledTestsRoot.replace(
"/", "\\")
log.debug("Compiled root is %s, os is %s", self.compiledTestsRoot,
os.name)
# Each element of config.options.attr is a comma-separated list of
# enabled of disabled test tags
target_expression = ''
for expression in config.options.eval_attr:
if target_expression:
target_expression = target_expression + '&'
target_expression = target_expression + '(' + expression + ')'
self.tags = process_expression(target_expression)
if not self.tags:
self.tags = 'checkin&!interactive'
log.debug("JUnitTestLoader.__init__(): Set default test tasgs")
log.debug("JUnitTestLoader.__init__(): self.tags: %s", self.tags)
def test_next_batch_with_classes(self):
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(ContextSuite(
tests=[l.makeTest(T_fixt), l.makeTest(T)])))
print(tests)
self.assertEqual(len(tests), 3)
def _collect_tests_from_dir(self):
""" Uses nose's collect plugin"""
# from pprint import pprint
# APP_ENGINE_TESTS_DIR = "/home/marcial/repos/flask_docker/src_panic_app/panic/tests/noses/test_appengine"
from nose.config import Config
conf = Config()
from nose.loader import TestLoader
loader = TestLoader()
from nose.plugins.collect import CollectOnly, TestSuiteFactory, TestSuite
collect = CollectOnly()
collect.conf = conf
collect.prepareTestLoader(loader)
tests = loader.loadTestsFromDir(self.dir)
suite = TestSuite()
suite.addTests(tests)
# from nose.core import TextTestRunner
# TextTestRunner().run(suite)
# ....:for test in suite._tests[0]._tests[0]:
# ....: print test.id()
found = []
self.traverse_recursive(suite, found)
return found
def setUp(self):
self.runner = gmultiprocess.GeventedMultiProcessTestRunner(
#stream=_WritelnDecorator(sys.stdout),
verbosity=10,
loaderClass=TestLoader,
config=Config())
self.loader = TestLoader()
def test_load_nested_generator(self):
from nose.config import Config
from nose.loader import TestLoader
where = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'support', 'issue006'))
l = TestLoader()
testmod = next(iter(l.loadTestsFromName(where)))
print(testmod)
testmod.setUp()
testcase = next(iter(testmod))
expect = [['tests.Test1.test_nested_generator'],
[
'tests.Test1.test_nested_generator_mult(1,)',
'tests.Test1.test_nested_generator_mult(2,)',
'tests.Test1.test_nested_generator_mult(3,)'
],
[
'tests.Test1.test_normal_generator(1,)',
'tests.Test1.test_normal_generator(2,)'
]]
for test in testcase:
tests = list(map(str, test))
print(tests)
self.assertEqual(tests, expect.pop(0))
def run_test(self):
rf = os.path.join(self.run_dir, 'RunFinished')
self.run_finished = os.path.exists(rf)
tl = TestLoader()
tl.config.plugins = PluginManager(plugins=self.plugins)
suite = tl.loadTestsFromDir(self.run_dir)
nose.run(argv=self.args, suite=suite)
def test_next_batch_can_split_set(self):
mod_with_fixt2 = imp.new_module('mod_with_fixt2')
sys.modules['mod_with_fixt2'] = mod_with_fixt2
def setup():
pass
class Test(T):
pass
class Test_fixt(T_fixt):
pass
mod_with_fixt2.Test = Test
mod_with_fixt2.Test_fixt = Test_fixt
mod_with_fixt2.setup = setup
mod_with_fixt2._multiprocess_can_split_ = True
Test.__module__ = 'mod_with_fixt2'
Test_fixt.__module__ = 'mod_with_fixt2'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_with_fixt2)))
print(tests)
self.assertEqual(len(tests), 3)
def test_load_in_def_order(self):
from nose.loader import TestLoader
where = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'support', 'bug105'))
l = TestLoader()
testmod = l.loadTestsFromDir(where).next()
print
testmod
testmod.setUp()
def fix(t):
s = str(t)
if ': ' in s:
return s[s.index(': ') + 2:]
return s
tests = map(fix, testmod)
print
tests
self.assertEqual(tests, [
'tests.test_z', 'tests.test_a', 'tests.test_dz', 'tests.test_mdz',
'tests.test_b'
])
def test_next_batch_can_split_set(self):
mod_with_fixt2 = imp.new_module('mod_with_fixt2')
sys.modules['mod_with_fixt2'] = mod_with_fixt2
def setup():
pass
class Test(T):
pass
class Test_fixt(T_fixt):
pass
mod_with_fixt2.Test = Test
mod_with_fixt2.Test_fixt = Test_fixt
mod_with_fixt2.setup = setup
mod_with_fixt2._multiprocess_can_split_ = True
Test.__module__ = 'mod_with_fixt2'
Test_fixt.__module__ = 'mod_with_fixt2'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_with_fixt2)))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_classes(self):
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(
r.nextBatch(ContextSuite(
tests=[l.makeTest(T_fixt), l.makeTest(T)])))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_generator_method(self):
class Tg:
def test_gen(self):
for i in range(0, 3):
yield self.check, i
def check(self, val):
pass
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.makeTest(Tg)))
print tests
print [r.address(t) for t in tests]
def test_generator_yield_value(self):
from nose.loader import TestLoader
def test():
pass
def gen():
yield test
loader = TestLoader()
suite = loader.loadTestsFromGenerator(gen, module=None)
testcase = next(iter(suite))
self.assertEqual(testcase.test.test, test)
def run_nose():
tl = TestLoader()
ts = tl.loadTestsFromDir(tl.workingDir)
rlst = TextTestRunner(stream=sys.stderr, descriptions=1, verbosity=2)
tests = []
for test in ts :
tests += test
for test in tests :
if type(test) == Test :
test.runTest(rlst)
#import pdb;pdb.set_trace()
return rlst
def test_generator_yield_value(self):
from nose.loader import TestLoader
def test():
pass
def gen():
yield test
loader = TestLoader()
suite = loader.loadTestsFromGenerator(gen, module=None)
testcase = iter(suite).next()
self.assertEqual(testcase.test.test, test)
def test_next_batch_with_generator_method(self):
class Tg:
def test_gen(self):
for i in range(0, 3):
yield self.check, i
def check(self, val):
pass
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.makeTest(Tg)))
print tests
print[r.address(t) for t in tests]
self.assertEqual(len(tests), 1)
def test_multiprocess_unsafe(self):
mod_unsafe = imp.new_module('mod_unsafe')
sys.modules['mod_unsafe'] = mod_unsafe
class Test(T):
pass
mod_unsafe._multiprocess_ = False
mod_unsafe.Test = Test
Test.__module__ = 'mod_unsafe'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_unsafe)))
print tests
self.assertEqual(len(tests), 2)
def run_my_tests():
all_tests = ()
#for path in paths:
all_tests = itertools.chain(all_tests,
TestLoader().loadTestsFromDir(paths))
suite = LazySuite(all_tests)
run(suite=suite)
def loadTestsFromFile(self, filename):
"""
We'll exploit the knowledge of the selector implementation details:
since the selector 'wants' only root build.xml file for JUnit-based
tests, we can safely check initials and then fall back to inherited
behavior or collect output for all tests.
"""
log.debug("JUnitTestLoader.loadTestsFromFile(%s)", filename)
if not filename.startswith(self.compiledTestsRoot):
log.debug("JUnitTestLoader.loadTestsFromFile(): fall back to predefined behavior")
log.debug("JUnitTestLoader.loadTestsFromFile(): compiledTestsRoot is %s", self.compiledTestsRoot)
return TestLoader.loadTestsFromFile(self, filename)
commandLine = self.prepareCommandLine()
try:
testOutput = self.executeTests(commandLine)
except Exception as e:
log.debug("Building JUnit test suite failed with message: %s",
str(e))
return self.suiteClass(Failure(Exception,"Couldn't build compiled test suite."))
log.debug("JUnitTestLoader.loadTestsFromFile(): got ant output:\n%s",
testOutput)
singleTestOutput, singleTestExceptions = self.filterTestOutput(testOutput)
log.debug("JUnitTestLoader.loadTestsFromFile(): JUnit filtered output:")
for line in singleTestOutput:
log.debug("%s\n", line)
log.debug("JUnitTestLoader.loadTestsFromFile(): %s",
"JUnit filtered output finished.")
loadedTests = self.makeTestCases(singleTestOutput,
singleTestExceptions)
log.debug("JUnitTestLoader.loadTestsFromFile(): loaded tests %s",
loadedTests)
log.debug("JUnitTestLoader.loadTestsFromFile(): suite class is %s",
repr(self.suiteClass))
return self.suiteClass(loadedTests)
def run_my_tests():
all_tests = ()
for path in paths:
all_tests = itertools.chain(all_tests, TestLoader().loadTestsFromDir(path))
suite = LazySuite(all_tests)
nose.run(suite=suite, argv=["--with-coverage", "--cover-html", "--cover-package=pyredux"])
def setUp(self):
self.runner = gmultiprocess.GeventedMultiProcessTestRunner(
#stream=_WritelnDecorator(sys.stdout),
verbosity=10,
loaderClass=TestLoader,
config=Config()
)
self.loader = TestLoader()
def run_my_tests():
all_tests = ()
all_tests = itertools.chain(all_tests, TestLoader().loadTestsFromDir('.'))
suite = LazySuite(all_tests)
run(suite=suite,
argv=[
'run_all.py', '--cover-branches', '--with-coverage', '--cover-html'
])
def test_next_batch_with_module_fixt(self):
mod_with_fixt = imp.new_module('mod_with_fixt')
sys.modules['mod_with_fixt'] = mod_with_fixt
def teardown():
pass
class Test(T):
pass
mod_with_fixt.Test = Test
mod_with_fixt.teardown = teardown
Test.__module__ = 'mod_with_fixt'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_with_fixt)))
print tests
self.assertEqual(len(tests), 1)
def test_next_batch_with_module_fixt(self):
mod_with_fixt = imp.new_module('mod_with_fixt')
sys.modules['mod_with_fixt'] = mod_with_fixt
def teardown():
pass
class Test(T):
pass
mod_with_fixt.Test = Test
mod_with_fixt.teardown = teardown
Test.__module__ = 'mod_with_fixt'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_with_fixt)))
print(tests)
self.assertEqual(len(tests), 1)
def find_tests(self, *names):
"""
Use nosetests to find the tests using the default naming rules.
:param names: one or more names where a name can be a file, directory, module, or any object within a module
"""
from nose.loader import Config, TestLoader
suite = TestLoader(Config(includeExe=True),
selector=K2TestSelector()).loadTestsFromNames(names)
return self._test_cases_from_suite(suite)
def test_next_batch_with_module(self):
mod_no_fixt = imp.new_module('mod_no_fixt')
sys.modules['mod_no_fixt'] = mod_no_fixt
class Test2(T):
pass
class Test_fixt(T_fixt):
pass
mod_no_fixt.Test = Test2
Test2.__module__ = 'mod_no_fixt'
mod_no_fixt.Test_fixt = Test_fixt
Test_fixt.__module__ = 'mod_no_fixt'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_no_fixt)))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_module(self):
mod_no_fixt = imp.new_module('mod_no_fixt')
sys.modules['mod_no_fixt'] = mod_no_fixt
class Test2(T):
pass
class Test_fixt(T_fixt):
pass
mod_no_fixt.Test = Test2
Test2.__module__ = 'mod_no_fixt'
mod_no_fixt.Test_fixt = Test_fixt
Test_fixt.__module__ = 'mod_no_fixt'
r = multiprocess.MultiProcessTestRunner()
l = TestLoader()
tests = list(r.nextBatch(l.loadTestsFromModule(mod_no_fixt)))
print(tests)
self.assertEqual(len(tests), 3)
def xmltest(self):
"""
Runs each specified tests by using python unittest to execute
and reports results through stdout and junit xml format.
:return:
"""
p = parameterized(self.clean_names(self.tests_to_run()))
test_main = p(test_individual)
suite = TestLoader().loadTestsFromGenerator(test_main, __name__)
testRunner = xmlrunner.XMLTestRunner(output='test-reports')
testRunner.run(suite)
def test_units():
import coverage
import nose
from nose.loader import TestLoader
_remove_coverage()
cov = coverage.coverage(branch=True, source=['chatmotor'])
cov.start()
nose.run(suite=TestLoader().loadTestsFromName("tests/unit"))
cov.stop()
cov.save()
local('coverage report -m')
def test_load_in_def_order(self):
from nose.loader import TestLoader
where = os.path.abspath(os.path.join(os.path.dirname(__file__),
'support', 'bug105'))
l = TestLoader()
testmod = next(l.loadTestsFromDir(where))
print(testmod)
testmod.setUp()
def fix(t):
s = str(t)
if ': ' in s:
return s[s.index(': ')+2:]
return s
tests = list(map(fix, testmod))
print(tests)
self.assertEqual(tests, ['tests.test_z', 'tests.test_a',
'tests.test_dz', 'tests.test_mdz',
'tests.test_b'])
def __init__(self, config = None, importer = None,
workingDir = None, selector = JUnitSelector):
"""Initialize a test loader
"""
TestLoader.__init__(self, config, importer, workingDir, selector)
log.debug("JUnitTestLoader.__init__(): config = %s", config)
if hasattr(config.options, 'compiled_root'):
self.compiledTestsRoot = config.options.compiled_root
if os.name == "nt":
self.compiledTestsRoot = self.compiledTestsRoot.replace("/", "\\")
log.debug("Compiled root is %s, os is %s", self.compiledTestsRoot, os.name)
# Each element of config.options.attr is a comma-separated list of
# enabled of disabled test tags
target_expression = ''
for expression in config.options.eval_attr:
if target_expression:
target_expression = target_expression + '&'
target_expression = target_expression + '(' + expression + ')'
self.tags = process_expression(target_expression)
if not self.tags:
self.tags = 'checkin&!interactive'
log.debug("JUnitTestLoader.__init__(): Set default test tasgs")
log.debug("JUnitTestLoader.__init__(): self.tags: %s", self.tags)
def run_test():
try:
loader = TestLoader()
run(argv=[
"--nocapture", "--nologcapture", "--where=/root/tests",
"--with-coverage", "--cover-erase",
"--cover-package=/root/src/train", "--cover-xml",
"--cover-xml-file=/root/tests/results/coverage.xml",
"--with-xunit", "--xunit-file=/root/tests/results/nosetests.xml"
],
testLoader=loader)
except (KeyboardInterrupt):
sys.exit(0)
def __init__(self, config = None, importer = None,
workingDir = None, selector = Selector):
"""Initialize a test loader
"""
TestLoader.__init__(self, config, importer, workingDir, selector)
log.debug("CTestTestLoader.__init__(): config = %s", config)
if hasattr(config.options, 'compiled_root'):
self.compiledTestsRoot = config.options.compiled_root
log.debug("Compiled root is %s", self.compiledTestsRoot)
# Each element of config.options.attr is a comma-separated list of
# enabled of disabled test tags
target_expression = ''
for expression in config.options.eval_attr:
if target_expression:
target_expression = target_expression + '&'
target_expression = target_expression + '(' + expression + ')'
self.tags = process_expression(target_expression)
Selector.tags = self.tags
log.debug("CTestTestLoader.__init__(): set tags for Selector")
if not self.tags:
self.tags = 'shareable&!interactive'
log.debug("CTestTestLoader.__init__(): Set default test tasgs")
log.debug("CTestTestLoader.__init__(): self.tags: %s", self.tags)
def loadTestsFromName(self, name, module=None):
"""This is needs when using multithread pluggin to re-create the
class as generate in loadTestsFromTestCase"""
driver = None
prefix = None
for d in self.drivers:
if name.startswith(d.name):
prefix = "%s_" % d.name
name = name[len(prefix):]
driver = d
continue
if not driver or not module:
return
parts = name.split(".")
class_name = parts[0]
method_name = None
if len(parts) >= 2:
method_name = parts[1]
test_case_class = getattr(module, class_name)
assert isinstance(test_case_class, object)
class A(test_case_class):
pass
new_class = A
new_class.driver = driver
new_class.__name__ = "%s%s" % (prefix, class_name)
new_class.__module__ = test_case_class.__module__
if method_name:
yield new_class(method_name)
else:
loader = TestLoader()
test_case_names = loader.getTestCaseNames(new_class)
if not test_case_names and hasattr(new_class, 'runTest'):
test_case_names = ['runTest']
yield loader.suiteClass(map(new_class, test_case_names))
class Tests(TestCase):
def setUp(self):
from nose_fixes.plugin import Plugin
plugin = Plugin()
plugin.test_suite_func = 'test_suite'
self.l = TestLoader()
plugin.prepareTestLoader(self.l)
def test_suite(self):
suite = object()
def test_suite():
# return a suite
return suite
mod = new_module('with_test_suite')
mod.test_suite = test_suite
self.assertTrue(self.l.loadTestsFromModule(mod) is suite)
def test_no_suite(self):
def test_sweet():
# a tester of sweets ;-)
assert True!=False
mod = new_module('without_test_suite')
mod.test_sweet = test_sweet
suite = self.l.loadTestsFromModule(mod)
tests = [t for t in suite]
self.assertEqual(len(tests), 1)
test = tests[0]
self.assertTrue(isinstance(test, Test))
self.assertEqual(repr(test), 'Test(without_test_suite.test_sweet)')
def test_load_nested_generator(self):
from nose.config import Config
from nose.loader import TestLoader
where = os.path.abspath(os.path.join(os.path.dirname(__file__),
'support', 'issue006'))
l = TestLoader()
testmod = iter(l.loadTestsFromName(where)).next()
print testmod
testmod.setUp()
testcase = iter(testmod).next()
expect = [
['tests.Test1.test_nested_generator'],
['tests.Test1.test_nested_generator_mult(1,)',
'tests.Test1.test_nested_generator_mult(2,)',
'tests.Test1.test_nested_generator_mult(3,)'],
['tests.Test1.test_normal_generator(1,)',
'tests.Test1.test_normal_generator(2,)']
]
for test in testcase:
tests = map(str, test)
print tests
self.assertEqual(tests, expect.pop(0))
def load_tests(self, dotted_name_of_tests):
"""Returns a TestSuite of all tests in the named scope.
The dotted name may specify a package, module, class, or method.
All tests within the named scope will be recursively collected into
a single TestSuite, which is returned.
"""
module, clazz, method = find_python_objects(dotted_name_of_tests)
error_msg_prefix = ("Parameter '" + self.pname_run + "=" +
dotted_name_of_tests + "': ")
self._verify_python_objects(
module, clazz, method, unittest.defaultTestLoader.testMethodPrefix,
error_msg_prefix)
'''LOG.info(inspect.stack()[0][3] + ": module= " + module.__name__
+ ", class= "
+ ("None" if clazz is None else clazz.__name__)
+ ", method= "
+ ("None" if method is None else method.__name__))'''
testsuite = None
if clazz is None:
# Use nose TestLoader b/c unittest.loadTestsFromModule didn't work
testsuite = TestLoader().loadTestsFromModule(module)
#testsuite = unittest.defaultTestLoader.loadTestsFromModule(module)
if testsuite.countTestCases() < 1:
raise ValueError(error_msg_prefix + "No tests in module")
else:
if method is None:
testsuite = unittest.defaultTestLoader.loadTestsFromTestCase(
clazz)
'''LOG.info("Loaded from class '" + clazz.__name__ + "'= "
+ str(testsuite.countTestCases()))
if testsuite.countTestCases() < 1:
raise ValueError(error_msg_prefix + "No tests in class")'''
else:
testsuite = unittest.TestSuite(tests=[clazz(method.__name__)])
return testsuite
def loadTestsFromName(self, name, module=None):
"""This is needs when using multithread pluggin to re-create the
class as generate in loadTestsFromTestCase"""
driver = None
prefix = None
for d in self.drivers:
if name.startswith(d.name):
prefix = "%s_" % d.name
name = name[len(prefix):]
driver = d
continue
if not driver or not module:
return
parts = name.split(".")
class_name = parts[0]
method_name = None
if len(parts) >= 2:
method_name = parts[1]
test_case_class = getattr(module, class_name)
assert isinstance(test_case_class, object)
class A(test_case_class):
pass
new_class = A
new_class.driver = driver
new_class.__name__ = "%s%s" % (prefix, class_name)
new_class.__module__ = test_case_class.__module__
if method_name:
yield new_class(method_name)
else:
loader = TestLoader()
test_case_names = loader.getTestCaseNames(new_class)
if not test_case_names and hasattr(new_class, 'runTest'):
test_case_names = ['runTest']
yield loader.suiteClass(map(new_class, test_case_names))
def run(self, test_name, test_module):
target = "%s:%s" % (test_module, test_name)
test_suite = TestLoader().loadTestsFromName(target)
report = StringIO()
runner = TextTestRunner(report)
result = runner.run(test_suite)
ret = {"pass": result.wasSuccessful()}
for failure in result.failures:
ret.update({"stack": failure[1]})
ret.update({"log": report.getvalue()})
for error in result.errors:
ret.update({"error": error[1]})
return ret
def loadTestsFromFile(self, filename):
"""
We'll exploit the knowledge of the selector implementation details:
since the selector 'wants' only root build.xml file for JUnit-based
tests, we can safely check initials and then fall back to inherited
behavior or collect output for all tests.
"""
log.debug("JUnitTestLoader.loadTestsFromFile(%s)", filename)
if not filename.startswith(self.compiledTestsRoot):
log.debug(
"JUnitTestLoader.loadTestsFromFile(): fall back to predefined behavior"
)
log.debug(
"JUnitTestLoader.loadTestsFromFile(): compiledTestsRoot is %s",
self.compiledTestsRoot)
return TestLoader.loadTestsFromFile(self, filename)
commandLine = self.prepareCommandLine()
try:
testOutput = self.executeTests(commandLine)
except Exception as e:
log.debug("Building JUnit test suite failed with message: %s",
str(e))
return self.suiteClass(
Failure(Exception, "Couldn't build compiled test suite."))
log.debug("JUnitTestLoader.loadTestsFromFile(): got ant output:\n%s",
testOutput)
singleTestOutput, singleTestExceptions = self.filterTestOutput(
testOutput)
log.debug(
"JUnitTestLoader.loadTestsFromFile(): JUnit filtered output:")
for line in singleTestOutput:
log.debug("%s\n", line)
log.debug("JUnitTestLoader.loadTestsFromFile(): %s",
"JUnit filtered output finished.")
loadedTests = self.makeTestCases(singleTestOutput,
singleTestExceptions)
log.debug("JUnitTestLoader.loadTestsFromFile(): loaded tests %s",
loadedTests)
log.debug("JUnitTestLoader.loadTestsFromFile(): suite class is %s",
repr(self.suiteClass))
return self.suiteClass(loadedTests)
def loadTestsFromFile(self, filename):
log.debug("CTestTestLoader.loadTestsFromFile(%s)", filename)
doesStartWith = False
try:
doesStartWith = pathStartsWith(filename, self.compiledTestsRoot)
except:
doesStartWith = False
if not doesStartWith:
log.debug("CTestTestLoader.loadTestsFromFile(): fall back to predefined behavior")
return TestLoader.loadTestsFromFile(self, filename)
tests = list()
tagset = set(self.tags.split(','))
testRunnerInfo = getItemByFileName(filename)
log.debug("testRunnerInfo now is: %s", repr(testRunnerInfo))
if testRunnerInfo:
tests = testRunnerInfo.tests
log.debug("CTestTestLoader.loadTestsFromFile(): have tests: '%s'" % tests)
loadedTests = self.makeTestCases(filename, tests, testRunnerInfo.env)
log.debug("CTestTestLoader.loadTestsFromFile(%s): loaded tests %s",
filename, loadedTests)
log.debug("CTestTestLoader.loadTestsFromFile(): suite class is %s",
repr(self.suiteClass))
return self.suiteClass(loadedTests)
def __init__(self, *args, **kwargs):
super(WTRLoader, self).__init__(*args, **kwargs)
self.logger = logging.getLogger(__file__)
self.test_loader = TestLoader()
def create_test_suite():
this_dir = os.path.dirname(os.path.abspath(__file__))
return LazySuite(TestLoader().loadTestsFromDir(this_dir))
class TestMultiProcessTestRunner(unittest.TestCase):
def setUp(self):
self.runner = gmultiprocess.GeventedMultiProcessTestRunner(
#stream=_WritelnDecorator(sys.stdout),
verbosity=10,
loaderClass=TestLoader,
config=Config()
)
self.loader = TestLoader()
def test_next_batch_with_classes(self):
tests = list(self.runner.get_test_batch(
ContextSuite(
tests=[
self.loader.makeTest(T_fixt),
self.loader.makeTest(T)
]
)
))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_module_fixt(self):
mod_with_fixt = imp.new_module('mod_with_fixt')
sys.modules['mod_with_fixt'] = mod_with_fixt
def teardown():
pass
class Test(T):
pass
mod_with_fixt.Test = Test
mod_with_fixt.teardown = teardown
Test.__module__ = 'mod_with_fixt'
tests = list(self.runner.get_test_batch(
self.loader.loadTestsFromModule(mod_with_fixt)
))
print tests
self.assertEqual(len(tests), 1)
def test_next_batch_with_module(self):
mod_no_fixt = imp.new_module('mod_no_fixt')
sys.modules['mod_no_fixt'] = mod_no_fixt
class Test2(T):
pass
class Test_fixt(T_fixt):
pass
mod_no_fixt.Test = Test2
Test2.__module__ = 'mod_no_fixt'
mod_no_fixt.Test_fixt = Test_fixt
Test_fixt.__module__ = 'mod_no_fixt'
tests = list(self.runner.get_test_batch(
self.loader.loadTestsFromModule(mod_no_fixt)
))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_generator_method(self):
class Tg:
def test_gen(self):
for i in range(0, 3):
yield self.check, i
def check(self, val):
pass
tests = list(self.runner.get_test_batch(self.loader.makeTest(Tg)))
print tests
print [gmultiprocess.get_test_case_address(t) for t in tests]
def setUp(self):
from nose_fixes.plugin import Plugin
plugin = Plugin()
plugin.test_suite_func = 'test_suite'
self.l = TestLoader()
plugin.prepareTestLoader(self.l)
def run_tests(self, test_class):
res = TestResult()
loader = TestLoader()
suite = loader.loadTestsFromTestClass(test_class)
suite(res)
return res
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from nose.loader import TestLoader
from nose import run
from nose.suite import LazySuite
TESTS = {'generic': ['test_database'], 'versioned': ['test_v2_0']}
all_tests = TestLoader().loadTestsFromNames(TESTS["generic"] +
TESTS["versioned"])
latest_tests = TestLoader().loadTestsFromNames(TESTS["generic"] +
[TESTS["versioned"][-1]])
def runner(tests):
def _run():
suite = LazySuite(tests)
run(suite=suite)
return _run
run_all = runner(all_tests)
run_latest = runner(latest_tests)
def run_exit():
testLoader = TestLoader(importer=OdooImporter())
return main(testLoader=testLoader)
class TestMultiProcessTestRunner(unittest.TestCase):
def setUp(self):
self.runner = gmultiprocess.GeventedMultiProcessTestRunner(
#stream=_WritelnDecorator(sys.stdout),
verbosity=10,
loaderClass=TestLoader,
config=Config())
self.loader = TestLoader()
def test_next_batch_with_classes(self):
tests = list(
self.runner.get_test_batch(
ContextSuite(tests=[
self.loader.makeTest(T_fixt),
self.loader.makeTest(T)
])))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_module_fixt(self):
mod_with_fixt = imp.new_module('mod_with_fixt')
sys.modules['mod_with_fixt'] = mod_with_fixt
def teardown():
pass
class Test(T):
pass
mod_with_fixt.Test = Test
mod_with_fixt.teardown = teardown
Test.__module__ = 'mod_with_fixt'
tests = list(
self.runner.get_test_batch(
self.loader.loadTestsFromModule(mod_with_fixt)))
print tests
self.assertEqual(len(tests), 1)
def test_next_batch_with_module(self):
mod_no_fixt = imp.new_module('mod_no_fixt')
sys.modules['mod_no_fixt'] = mod_no_fixt
class Test2(T):
pass
class Test_fixt(T_fixt):
pass
mod_no_fixt.Test = Test2
Test2.__module__ = 'mod_no_fixt'
mod_no_fixt.Test_fixt = Test_fixt
Test_fixt.__module__ = 'mod_no_fixt'
tests = list(
self.runner.get_test_batch(
self.loader.loadTestsFromModule(mod_no_fixt)))
print tests
self.assertEqual(len(tests), 3)
def test_next_batch_with_generator_method(self):
class Tg:
def test_gen(self):
for i in range(0, 3):
yield self.check, i
def check(self, val):
pass
tests = list(self.runner.get_test_batch(self.loader.makeTest(Tg)))
print tests
print[gmultiprocess.get_test_case_address(t) for t in tests]
self.assertEqual(len(tests), 1)
def test_next_batch_can_split_set(self):
mod_with_fixt2 = imp.new_module('mod_with_fixt2')
sys.modules['mod_with_fixt2'] = mod_with_fixt2
def setup():
pass
class Test(T):
pass
class Test_fixt(T_fixt):
pass
mod_with_fixt2.Test = Test
mod_with_fixt2.Test_fixt = Test_fixt
mod_with_fixt2.setup = setup
mod_with_fixt2._multiprocess_can_split_ = True
Test.__module__ = 'mod_with_fixt2'
Test_fixt.__module__ = 'mod_with_fixt2'
tests = list(
self.runner.get_test_batch(
self.loader.loadTestsFromModule(mod_with_fixt2)))
print tests
self.assertEqual(len(tests), 3)
def test_runner_collect_tests(self):
test = ContextSuite(tests=[
self.loader.makeTest(T_fixt),
self.loader.makeTest(T),
case.Test(TC('runTest'))
])
kw = dict(tasks_queue=[], tasks_list=[], to_teardown=[], result=None)
self.runner.collect_tasks(test, **kw)
# Tasks Queue
should_be_tasks = ['T_fixt', 'T.test_a', 'T.test_b', 'TC.runTest']
tasks = [addr.split(':')[-1] for addr, args in kw['tasks_queue']]
self.assertEqual(tasks, should_be_tasks)
# Tasks List
should_be_tasks = [
'T_fixt',
'T.test_a()', # args is a tuple. appended as string to base addr
'T.test_b()', # args is a tuple. appended as string to base addr
'TC.runTest'
]
tasks = [addr.split(':')[-1] for addr in kw['tasks_list']]
self.assertEqual(tasks, should_be_tasks)