def setUp(self):
self.runner = gmultiprocess.GeventedMultiProcessTestRunner(
#stream=_WritelnDecorator(sys.stdout),
verbosity=10,
loaderClass=TestLoader,
config=Config())
self.loader = TestLoader()
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_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_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 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 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_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 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 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_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 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_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 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 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 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(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 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 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 run():
import argparse
parser = argparse.ArgumentParser(description='Run TestBenches.')
parser.add_argument('--max_configs', type=int)
parser.add_argument('--run_desert', action='store_true')
parser.add_argument('model_file')
parser.add_argument('nose_options', nargs=argparse.REMAINDER)
command_line_args = parser.parse_args()
project = Dispatch("Mga.MgaProject")
mga_file = command_line_args.model_file
if mga_file.endswith('.xme'):
project = Dispatch("Mga.MgaProject")
parser = Dispatch("Mga.MgaParser")
resolver = Dispatch("Mga.MgaResolver")
resolver.IsInteractive = False
parser.Resolver = resolver
mga_file = os.path.splitext(
command_line_args.model_file)[0] + ".mga"
project.Create("MGA=" + os.path.abspath(mga_file), "CyPhyML")
parser.ParseProject(project, command_line_args.model_file)
else:
# n.b. without abspath, things break (e.g. CyPhy2CAD)
project.OpenEx(
"MGA=" + os.path.abspath(command_line_args.model_file),
"CyPhyML", None)
project.BeginTransactionInNewTerr()
try:
if command_line_args.run_desert:
desert = Dispatch("MGA.Interpreter.DesignSpaceHelper")
desert.Initialize(project)
filter = project.CreateFilter()
filter.Kind = "DesignContainer"
# FIXME wont work right for TBs that point to non-root design sace
designContainers = [
tb for tb in project.AllFCOs(filter)
if not tb.IsLibObject and tb.ParentFolder is not None
]
for designContainer in designContainers:
desert.InvokeEx(project, designContainer,
Dispatch("MGA.MgaFCOs"), 128)
def add_fail(masterContext, configName, message):
def fail(self):
raise ValueError(message)
fail.__name__ = str('test_' + masterContext.Name + "__" +
configName)
setattr(TestBenchTest, fail.__name__, fail)
def add_test(masterContext, mi_config, config):
def testTestBench(self):
self._testTestBench(masterContext, master, mi_config)
# testTestBench.__name__ = str('test_' + masterContext.Name + "_" + masterContext.ID + "__" + config.Name)
testTestBench.__name__ = str('test_' + masterContext.Name +
"__" + config.Name)
setattr(TestBenchTest, testTestBench.__name__, testTestBench)
master = Dispatch(
"CyPhyMasterInterpreter.CyPhyMasterInterpreterAPI")
master.Initialize(project)
modelKinds = set(
("TestBench", "CADTestBench", "KinematicTestBench",
"BlastTestBench", "BallisticTestBench", "CarTestBench",
"CFDTestBench", "ParametricExploration"))
# masterContexts = [tb for tb in itertools.chain(*(project.AllFCOs(filter) for filter in filters)) if not tb.IsLibObject]
masterContexts = list(
crawlForKinds(project.RootFolder,
("ParametricExplorationFolder", "Testing"),
modelKinds))
print repr([t.Name for t in masterContexts])
for masterContext in masterContexts:
configs = None
if masterContext.Meta.Name == "ParametricExploration":
tbs = [
tb for tb in masterContext.ChildFCOs
if tb.MetaBase.Name == 'TestBenchRef'
and tb.Referred is not None
]
if not tbs:
configs = [masterContext]
else:
testBench = tbs[0].Referred
else:
testBench = masterContext
if not configs:
suts = [
sut for sut in testBench.ChildFCOs
if sut.MetaRole.Name == 'TopLevelSystemUnderTest'
]
if len(suts) == 0:
add_fail(
masterContext, 'invalid',
'Error: TestBench "{}" has no TopLevelSystemUnderTest'
.format(testBench.Name))
continue
if len(suts) > 1:
add_fail(
masterContext, 'invalid',
'Error: TestBench "{}" has more than one TopLevelSystemUnderTest'
.format(testBench.Name))
continue
sut = suts[0]
if sut.Referred.MetaBase.Name == 'ComponentAssembly':
configs = [sut.Referred]
else:
configurations = [
config for config in sut.Referred.ChildFCOs
if config.MetaBase.Name == 'Configurations'
]
if not configurations:
add_fail(
masterContext, 'invalid',
'Error: design has no Configurations models. Try using the --run_desert option'
)
continue
configurations = configurations[0]
cwcs = [
cwc for cwc in configurations.ChildFCOs
if cwc.MetaBase.Name == 'CWC' and cwc.Name
]
if not cwcs:
raise ValueError(
'Error: could not find CWCs for "{}"'.format(
testBench.Name))
configs = list(cwcs)
# FIXME cfg2 > cfg10
configs.sort(key=operator.attrgetter('Name'))
configs = configs[slice(0,
command_line_args.max_configs)]
for config in configs:
mi_config = Dispatch(
"CyPhyMasterInterpreter.ConfigurationSelectionLight")
# GME id, or guid, or abs path or path to Test bench or SoT or PET
mi_config.ContextId = masterContext.ID
mi_config.SetSelectedConfigurationIds([config.ID])
# mi_config.KeepTemporaryModels = True
mi_config.PostToJobManager = False
add_test(masterContext, mi_config, config)
finally:
project.CommitTransaction()
config = Config(files=all_config_files(),
plugins=BuiltinPluginManager())
config.configure(argv=['nose'] + command_line_args.nose_options)
loader = TestLoader(config=config)
tests = [loader.loadTestsFromTestClass(TestBenchTest)]
try:
nose.core.TestProgram(suite=tests,
argv=['nose'] +
command_line_args.nose_options,
exit=True,
testLoader=loader,
config=config)
finally:
# project.Save(project.ProjectConnStr + "_debug.mga", True)
project.Close(True)
def run_tests(self, test_class):
res = TestResult()
loader = TestLoader()
suite = loader.loadTestsFromTestClass(test_class)
suite(res)
return res
def run_exit():
testLoader = TestLoader(importer=OdooImporter())
return main(testLoader=testLoader)
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))
#
# 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)
from simple_tests import SimpleTests
from nose.loader import TestLoader
from teamcity.unittestpy import TeamcityTestRunner
if __name__ == '__main__':
test_loader = TestLoader().loadTestsFromTestClass(SimpleTests)
TeamcityTestRunner().run(test_loader)
