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