def setUp(self):
self.plugin = prof.Profiler(session=session.Session())
# stub out and save the cProfile and pstats modules
self.cProfile = prof.cProfile
self.pstats = prof.pstats
prof.cProfile = Stub()
prof.pstats = Stub()
def setUp(self):
self.session = session.Session()
self.result = result.PluggableTestResult(self.session)
self.plugin = buffer.OutputBufferPlugin(session=self.session)
self.plugin.register()
class Test(TestCase):
def test_out(self):
six.print_("hello")
raise {}["oops"]
def test_err(self):
six.print_("goodbye", file=sys.stderr)
self.case = Test
class Watcher(events.Plugin):
def __init__(self):
self.events = []
def testOutcome(self, event):
self.events.append(event)
self.watcher = Watcher(session=self.session)
self.watcher.register()
def test_session_config_cacheing(self):
"""Test cacheing of config sections works"""
# Create new session (generic one likely already cached
# depending on test order)
cache_sess = session.Session()
cache_sess.loadConfigFiles(support_file("cfg", "a.cfg"))
# First access to given section, should read from config file
firstaccess = cache_sess.get("a")
assert firstaccess.as_int("a") == 1
# Hack cached Config object internals to make the stored value
# something different
cache_sess.configCache["a"]._mvd["a"] = "0"
newitems = []
for item in cache_sess.configCache["a"]._items:
if item != ("a", "1"):
newitems.append(item)
else:
newitems.append(("a", "0"))
cache_sess.configCache["a"]._items = newitems
# Second access to given section, confirm returns cached value
# rather than parsing config file again
secondaccess = cache_sess.get("a")
assert secondaccess.as_int("a") == 0
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(session=self.session)
self.plugin = TestCaseLoader(session=self.session)
class Mod(object):
pass
self.module = Mod()
class A(TestCase):
def test(self):
pass
class B(TestCase):
def runTest(self):
pass
class C(TestCase):
def foo(self):
pass
class Test(object):
def test(self):
pass
self.module.A = A
self.module.B = B
self.module.C = C
self.module.Test = Test
def document(self, rst, plugin):
ssn = session.Session()
ssn.configClass = ssn.config = config = ConfigBucket()
ssn.pluginargs = opts = OptBucket()
plugin_name = plugin.__name__
config = ssn.config
obj = plugin(session=ssn)
try:
obj.pluginsLoaded(events.PluginsLoadedEvent([obj]))
except AttributeError:
pass
# config options
if config.vars:
self.add_config(rst, config, plugin)
# command-line options
if opts.opts:
self.headline(rst, u"Command-line options")
for opt in opts:
for line in opt.options():
rst.append(line, AD)
rst.append("", AD)
# class __doc__
self.headline(rst, u"Plugin class reference: %s" % plugin_name)
rst.append(u".. autoclass :: %s" % plugin_name, AD)
rst.append(u" :members:", AD)
rst.append(u"", AD)
def setUp(self):
self.session = session.Session()
self.result = result.PluggableTestResult(self.session)
self.plugin = failfast.FailFast(session=self.session)
self.plugin.register()
class Test(TestCase):
def test(self):
pass
def test_err(self):
raise Exception("oops")
def test_fail(self):
assert False
@unittest.expectedFailure
def test_fail_expected(self):
assert False
@unittest.skipIf(True, "Always skip")
def test_skip(self):
pass
self.case = Test
def setUp(self):
super(TestJunitXmlPlugin, self).setUp()
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.result = result.PluggableTestResult(self.session)
self.plugin = junitxml.JUnitXmlReporter(session=self.session)
self.plugin.register()
class Test(unittest.TestCase):
def test(self):
pass
def test_fail(self):
assert False
def test_err(self):
1/0
def test_skip(self):
raise unittest.SkipTest('skip')
def test_gen(self):
def check(a, b):
self.assertEqual(a, b)
yield check, 1, 1
yield check, 1, 2
@tools.params(1, 2, 3)
def test_params(self, p):
self.assertEqual(p, 2)
self.case = Test
def setUp(self):
self.session = session.Session()
self.result = result.PluggableTestResult(self.session)
self.plugin = outcomes.Outcomes(session=self.session)
self.plugin.register()
class Test(TestCase):
def test_e1(self):
raise KeyError("k")
def test_e2(self):
raise TypeError("x")
def test_e3(self):
raise IOError("o")
self.case = Test
class Watcher(events.Plugin):
def __init__(self):
self.outcomes = {}
def testOutcome(self, event):
self.outcomes.setdefault(event.outcome, []).append(event)
self.watcher = Watcher(session=self.session)
self.watcher.register()
def setUp(self):
super(TestJunitXmlPlugin, self).setUp()
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.result = result.PluggableTestResult(self.session)
self.plugin = junitxml.JUnitXmlReporter(session=self.session)
self.plugin.register()
#unittest2 needs this
if not hasattr(self, 'assertRegexp'):
self.assertRegex = self.assertRegexpMatches
class Test(unittest.TestCase):
def test(self):
pass
def test_fail(self):
assert False
def test_err(self):
1/0
def test_skip(self):
raise unittest.SkipTest('skip')
def test_bad_xml(self):
raise RuntimeError(TestJunitXmlPlugin.BAD_FOR_XML_U)
def test_bad_xml_b(self):
raise RuntimeError(TestJunitXmlPlugin.BAD_FOR_XML_B)
def test_gen(self):
def check(a, b):
self.assertEqual(a, b)
yield check, 1, 1
yield check, 1, 2
@tools.params(1, 2, 3)
def test_params(self, p):
self.assertEqual(p, 2)
self.case = Test
def import_session(rlog, session_export):
ssn = session.Session()
ssn.config = session_export['config']
ssn.hooks = RecordingPluginInterface()
ssn.verbosity = session_export['verbosity']
ssn.startDir = session_export['startDir']
ssn.topLevelDir = session_export['topLevelDir']
ssn.prepareSysPath()
loader_ = loader.PluggableTestLoader(ssn)
ssn.testLoader = loader_
result_ = result.PluggableTestResult(ssn)
ssn.testResult = result_
runner_ = runner.PluggableTestRunner(ssn) # needed??
ssn.testRunner = runner_
# load and register plugins, forcing multiprocess to the end
ssn.plugins = [
plugin(session=ssn) for plugin in session_export['pluginClasses']
if plugin is not MultiProcess
]
rlog.debug("Plugins loaded: %s", ssn.plugins)
for plugin in ssn.plugins:
plugin.register()
rlog.debug("Registered %s in subprocess", plugin)
# instantiating the plugin will register it.
ssn.plugins.append(MultiProcess(session=ssn))
rlog.debug("Registered %s in subprocess", MultiProcess)
ssn.plugins[-1].pluginsLoaded(events.PluginsLoadedEvent(ssn.plugins))
return ssn
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(session=self.session)
self.plugin = TestClassLoader(session=self.session)
class Mod(object):
pass
self.module = Mod()
class TestA(object):
def test(self):
pass
class TestB(object):
def runTest(self):
pass
class TestC(object):
def foo(self):
pass
class Test(TestCase):
def test(self):
pass
self.module.TestA = TestA
self.module.TestB = TestB
self.module.TestC = TestC
self.module.Test = Test
def procserver(session_export, conn):
# init logging system
rlog = multiprocessing.log_to_stderr()
rlog.setLevel(session_export['logLevel'])
# make a real session from the "session" we got
ssn = session.Session()
ssn.config = session_export['config']
ssn.hooks = RecordingPluginInterface()
ssn.verbosity = session_export['verbosity']
ssn.startDir = session_export['startDir']
ssn.topLevelDir = session_export['topLevelDir']
ssn.prepareSysPath()
loader_ = loader.PluggableTestLoader(ssn)
ssn.testLoader = loader_
result_ = result.PluggableTestResult(ssn)
ssn.testResult = result_
runner_ = runner.PluggableTestRunner(ssn) # needed??
ssn.testRunner = runner_
# load and register plugins
ssn.plugins = [
plugin(session=ssn) for plugin in session_export['pluginClasses']
]
rlog.debug("Plugins loaded: %s", ssn.plugins)
for plugin in ssn.plugins:
plugin.register()
rlog.debug("Registered %s in subprocess", plugin)
if isinstance(conn, collections.Sequence):
conn = connection.Client(conn[:2], authkey=conn[2])
event = SubprocessEvent(loader_, result_, runner_, ssn.plugins, conn)
res = ssn.hooks.startSubprocess(event)
if event.handled and not res:
conn.send(None)
conn.close()
ssn.hooks.stopSubprocess(event)
return
# receive and run tests
executor = event.executeTests
for testid in gentests(conn):
if testid is None:
break
# XXX to handle weird cases like layers, need to
# deal with the case that testid is something other
# than a simple string.
test = event.loader.loadTestsFromName(testid)
# xxx try/except?
rlog.debug("Execute test %s (%s)", testid, test)
executor(test, event.result)
events = [e for e in ssn.hooks.flush()]
conn.send((testid, events))
rlog.debug("Log for %s returned", testid)
conn.send(None)
conn.close()
ssn.hooks.stopSubprocess(event)
def setUp(self):
super(TestJunitXmlPlugin, self).setUp()
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.result = result.PluggableTestResult(self.session)
self.plugin = junitxml.JUnitXmlReporter(session=self.session)
self.plugin.register()
# Python 2.7 needs this
# assertRegexpMatches() was renamed to assertRegex() in 3.2
if not hasattr(self, 'assertRegex'):
self.assertRegex = self.assertRegexpMatches
class Test(unittest.TestCase):
def test(self):
pass
def test_chdir(self):
TEMP_SUBFOLDER = 'test_chdir'
os.mkdir(TEMP_SUBFOLDER)
os.chdir(TEMP_SUBFOLDER)
def test_fail(self):
assert False
def test_err(self):
1 / 0
def test_skip(self):
self.skipTest('skip')
def test_skip_no_reason(self):
self.skipTest('')
def test_bad_xml(self):
raise RuntimeError(TestJunitXmlPlugin.BAD_FOR_XML_U)
def test_bad_xml_b(self):
raise RuntimeError(TestJunitXmlPlugin.BAD_FOR_XML_B)
def test_gen(self):
def check(a, b):
self.assertEqual(a, b)
yield check, 1, 1
yield check, 1, 2
@tools.params(1, 2, 3)
def test_params(self, p):
self.assertEqual(p, 2)
def test_with_log(self):
logging.info('log message')
self.case = Test
def test_load_plugins_from_module_does_not_load_plain_Plugins(self):
class fakemod:
pass
f = fakemod()
f.A = events.Plugin
s = session.Session()
s.loadPluginsFromModule(f)
self.assertEqual(len(s.plugins), 0)
def setUp(self):
class DummyCase(TestCase):
def test_a(self):
pass
self.suite = unittest.TestSuite()
self.caseClass = DummyCase
self.session = session.Session()
self.plugin = dundertest.DunderTestFilter(session=self.session)
self.plugin.register()
def setUp(self):
self.err = sys.stderr
self.buf = six.StringIO()
sys.stderr = self.buf
self.addCleanup(self.restore_stderr)
self.session = session.Session()
self.print_hooks_plugin = printhooks.PrintHooks(session=self.session)
self.plugin_a = TestPluginA(session=self.session)
self.plugin_b = TestPluginB(session=self.session)
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.expect = [
(0, ('call', (0, 1))),
(1, ('call', (1, 2))),
(2, ('call', (2, 3))),
]
self.plugin = generators.Generators(session=self.session)
# need testcase loader to make the initial response to load from module
self.tcl = testcases.TestCaseLoader(session=self.session)
def _collector(self, result_):
ssn = session.Session()
ldr = loader.PluggableTestLoader(ssn)
rnr = runner.PluggableTestRunner(ssn)
ssn.loadConfigFiles('unittest.cfg', 'nose2.cfg', 'setup.cfg')
ssn.prepareSysPath()
ssn.loadPlugins(PluggableTestProgram.defaultPlugins)
test = ldr.loadTestsFromNames([], None)
rslt = rnr.run(test)
return rslt.wasSuccessful()
def test_load_plugins_from_module_does_not_duplicate_always_on_plugins(
self):
class fakemod:
pass
f = fakemod()
class A(events.Plugin):
alwaysOn = True
f.A = A
s = session.Session()
s.loadPluginsFromModule(f)
self.assertEqual(len(s.plugins), 1)
def setUp(self):
class TC_1(TestCase):
tags = ['a', 'b']
def test_a(self):
pass
test_a.a = 1
test_a.c = 0
def test_b(self):
pass
test_b.b = 1
self.TC_1 = TC_1
self.session = session.Session()
self.plugin = attrib.AttributeSelector(session=self.session)
self.plugin.register()
def test_load_plugins_from_module_can_load_plugins(self):
class fakemod:
pass
f = fakemod()
class A(events.Plugin):
pass
f.A = A
s = session.Session()
s.loadPluginsFromModule(f)
assert s.plugins
a = s.plugins[0]
self.assertEqual(a.session, s)
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(session=self.session)
self.plugin = TestClassLoader(session=self.session)
class Mod(object):
pass
self.module = Mod()
class TestA(object):
def __init__(self):
raise RuntimeError("Something bad happened!")
def test(self):
pass
self.module.TestA = TestA
def __init__(self):
self.endpoint = self.config.as_str('endpoint', '')
self.screenshots_var = self.config.as_str('screenshots_var', '')
self.return_job_file = self.config.as_str('return_job_file', '')
self.show_errors = self.config.as_bool('show_errors', '')
self.session_obj = session.Session()
self.test_prefix = self.session_obj.testMethodPrefix
self.uuid = str(uuid.uuid4())
self.success = 0
self.errors = 0
self.failed = 0
self.skipped = 0
self.timeTaken = 0
self.start = None
self.stop = None
self.test_outcome = None
self.attrs = []
self.tests = None
self.addArgument(
self.attrs, None, "rte",
"With --rte \"your_environment\" option you can send "
"environment name or info to Testgr server")
group = self.session.pluginargs
group.add_argument('--rt-job-report',
action='store_true',
dest='rt_job_report',
help='Send Testgr job result via email')
group.add_argument(
'--rt-custom-data',
dest='rt_custom_data',
help=
'With --rt-custom-data {\"key\": \"value\"} option you can send additional data to '
'Testgr server')
group.add_argument(
'--rt-return-job',
dest='rt_return_job',
action="store_true",
help='With --rt-return-job option you can return job UUID')
def setUp(self):
self.session = session.Session()
self.plugin = debugger.Debugger(session=self.session)
self.result = result.PluggableTestResult(self.session)
class Test(TestCase):
def test(self):
pass
def test_err(self):
raise Exception("oops")
def test_fail(self):
assert False
self.case = Test
self.pdb = self.plugin.pdb
self.plugin.pdb = StubPdb()
self.plugin.register()
super(TestCase, self).setUp()
def setUp(self):
self.session = session.Session()
self.result = result.PluggableTestResult(self.session)
self.plugin = buffer.OutputBufferPlugin(session=self.session)
self.plugin.register()
class Test(TestCase):
printed_nonascii_str = util.safe_decode("test 日本").encode("utf-8")
printed_unicode = six.u("hello")
def test_out(self):
six.print_("hello")
raise {}["oops"]
def test_err(self):
six.print_("goodbye", file=sys.stderr)
def test_mixed_unicode_and_nonascii_str(self):
six.print_(self.printed_nonascii_str)
six.print_(self.printed_unicode)
six.print_(self.printed_nonascii_str, file=sys.stderr)
six.print_(self.printed_unicode, file=sys.stderr)
raise {}["oops"]
self.case = Test
class Watcher(events.Plugin):
def __init__(self):
self.events = []
def testOutcome(self, event):
self.events.append(event)
self.watcher = Watcher(session=self.session)
self.watcher.register()
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.plugin = parameters.Parameters(session=self.session)
# need testcase loader to make the initial response to load from module
self.tcl = testcases.TestCaseLoader(session=self.session)
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.plugin = functions.Functions(session=self.session)
def setUp(self):
self.session = session.Session()
self.plugin = mp.MultiProcess(session=self.session)
def setUp(self):
self.session = session.Session()
self.loader = loader.PluggableTestLoader(self.session)
self.plugin = doctests.DocTestLoader(session=self.session)
super(UnitTestDocTestLoader, self).setUp()
def setUp(self):
super(TestMpPlugin, self).setUp()
self.session = session.Session()
self.plugin = MultiProcess(session=self.session)
self.plugin.testRunTimeout = 2
