我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用unittest.TestProgram()。
def testWarning(self): """Test the warnings argument""" # see #10535 class FakeTP(unittest.TestProgram): def parseArgs(self, *args, **kw): pass def runTests(self, *args, **kw): pass warnoptions = sys.warnoptions[:] try: sys.warnoptions[:] = [] # no warn options, no arg -> default self.assertEqual(FakeTP().warnings, 'default') # no warn options, w/ arg -> arg value self.assertEqual(FakeTP(warnings='ignore').warnings, 'ignore') sys.warnoptions[:] = ['somevalue'] # warn options, no arg -> None # warn options, w/ arg -> arg value self.assertEqual(FakeTP().warnings, None) self.assertEqual(FakeTP(warnings='ignore').warnings, 'ignore') finally: sys.warnoptions[:] = warnoptions
def main(*args, **kwargs): # pylint: disable=g-doc-args """Executes a set of Python unit tests. Usually this function is called without arguments, so the unittest.TestProgram instance will get created with the default settings, so it will run all test methods of all TestCase classes in the __main__ module. Args: args: Positional arguments passed through to unittest.TestProgram.__init__. kwargs: Keyword arguments passed through to unittest.TestProgram.__init__. """ # pylint: enable=g-doc-args _RunInApp(RunTests, args, kwargs)
def test_defaultTest_with_iterable(self): class FakeRunner(object): def run(self, test): self.test = test return True old_argv = sys.argv sys.argv = ['faketest'] runner = FakeRunner() program = unittest.TestProgram( testRunner=runner, exit=False, defaultTest=['unittest.test', 'unittest.test2'], testLoader=self.FooBarLoader()) sys.argv = old_argv self.assertEqual(['unittest.test', 'unittest.test2'], program.testNames)
def __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=None, impl=None): unittest.TestProgram.__init__(self, module=module, defaultTest=defaultTest, argv=argv, testRunner=testRunner, testLoader=RHTestLoader(impl))
def runTests(self): if self.testRunner is None: try: import xmlrunner self.testRunner = xmlrunner.XMLTestRunner(verbosity=self.verbosity) except ImportError: self.testRunner = unittest.TextTestRunner(verbosity=self.verbosity) unittest.TestProgram.runTests(self)
def __init__(self, spd_file, module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=None, impl=None): self.spd_file = spd_file self.impl = impl self.results = [] if testLoader is None: testLoader = rhunittest.RHTestLoader(impl) unittest.TestProgram.__init__(self, module, defaultTest, argv, testRunner, testLoader)
def get_ut_verbosity(): """ Return the verbosity setting of the currently running unittest program, or 0 if none is running. """ frame = _find_frame_by_self(unittest.TestProgram) if frame is None: return 0 self = frame.f_locals.get('self') return self.verbosity
def testNoExit(self): result = object() test = object() class FakeRunner(object): def run(self, test): self.test = test return result runner = FakeRunner() oldParseArgs = unittest.TestProgram.parseArgs def restoreParseArgs(): unittest.TestProgram.parseArgs = oldParseArgs unittest.TestProgram.parseArgs = lambda *args: None self.addCleanup(restoreParseArgs) def removeTest(): del unittest.TestProgram.test unittest.TestProgram.test = test self.addCleanup(removeTest) program = unittest.TestProgram(testRunner=runner, exit=False, verbosity=2) self.assertEqual(program.result, result) self.assertEqual(runner.test, test) self.assertEqual(program.verbosity, 2)
def test_command_line_handling_parseArgs(self): # Haha - take that uninstantiable class program = object.__new__(unittest.TestProgram) args = [] def do_discovery(argv): args.extend(argv) program._do_discovery = do_discovery program.parseArgs(['something', 'discover']) self.assertEqual(args, []) program.parseArgs(['something', 'discover', 'foo', 'bar']) self.assertEqual(args, ['foo', 'bar'])
def test_command_line_handling_do_discovery_too_many_arguments(self): class Stop(Exception): pass def usageExit(): raise Stop program = object.__new__(unittest.TestProgram) program.usageExit = usageExit program.testLoader = None with self.assertRaises(Stop): # too many args program._do_discovery(['one', 'two', 'three', 'four'])
def test_command_line_handling_do_discovery_uses_default_loader(self): program = object.__new__(unittest.TestProgram) class Loader(object): args = [] def discover(self, start_dir, pattern, top_level_dir): self.args.append((start_dir, pattern, top_level_dir)) return 'tests' program.testLoader = Loader() program._do_discovery(['-v']) self.assertEqual(Loader.args, [('.', 'test*.py', None)])
def run(*arg, **kw): """Collect and run tests, returning success or failure. The arguments to `run()` are the same as to `main()`: * module: All tests are in this module (default: None) * defaultTest: Tests to load (default: '.') * argv: Command line arguments (default: None; sys.argv is read) * testRunner: Test runner instance (default: None) * testLoader: Test loader instance (default: None) * env: Environment; ignored if config is provided (default: None; os.environ is read) * config: :class:`nose.config.Config` instance (default: None) * suite: Suite or list of tests to run (default: None). Passing a suite or lists of tests will bypass all test discovery and loading. *ALSO NOTE* that if you pass a unittest.TestSuite instance as the suite, context fixtures at the class, module and package level will not be used, and many plugin hooks will not be called. If you want normal nose behavior, either pass a list of tests, or a fully-configured :class:`nose.suite.ContextSuite`. * plugins: List of plugins to use; ignored if config is provided (default: load plugins with DefaultPluginManager) * addplugins: List of **extra** plugins to use. Pass a list of plugin instances in this argument to make custom plugins available while still using the DefaultPluginManager. With the exception that the ``exit`` argument is always set to False. """ kw['exit'] = False return TestProgram(*arg, **kw).success
def runmodule(name='__main__', **kw): """Collect and run tests in a single module only. Defaults to running tests in __main__. Additional arguments to TestProgram may be passed as keyword arguments. """ main(defaultTest=name, **kw)
def runTests(self): # clobber existing runner - *sob* - it shouldn't be this hard self.testRunner = TestRunner(verbosity=self.verbosity) unittest.TestProgram.runTests(self) # A convenient entry-point - if used, 'SKIPPED' exceptions will be supressed.
def testmain(*args, **kw): new_kw = kw.copy() if 'testLoader' not in new_kw: new_kw['testLoader'] = TestLoader() program_class = new_kw.get('testProgram', TestProgram) program_class(*args, **new_kw)
def _generate_ending(self): return self.ENDING_TMPL ############################################################################## # Facilities for running tests from the command line ############################################################################## # Note: Reuse unittest.TestProgram to launch test. In the future we may # build our own launcher to support more specific command line # parameters like test title, CSS, etc.
def runTests(self): # Pick HTMLTestRunner as the default test runner. # base class's testRunner parameter is not useful because it means # we have to instantiate HTMLTestRunner before we know self.verbosity. if self.testRunner is None: self.testRunner = HTMLTestRunner(verbosity=self.verbosity) unittest.TestProgram.runTests(self)
def __new__(mcs, name, bases, classdict, **kwargs): """__new__ method of metaclass.""" # TODO: maybe this could be just put in the base class instead of in # the meta class. def assert_X_from_iterables(self, x=lambda: True, *args, **kwargs): func = getattr(self, x.__name__, x) for i, zipargs in enumerate(zip(*args)): with self.subTest(iteration=i, arguments=zipargs): func(*zipargs) return None classdict['assert_X_from_iterables'] = assert_X_from_iterables @property def verbose(cls): """Return the verbosity setting of the currently running unittest. This function 'scans' the frame looking for a 'cls' variable. Returns: int: the verbosity level. 0 if this is the __main__ file 1 if run with unittests module without verbosity (default in TestProgram) 2 if run with unittests module with verbosity """ frame = inspect.currentframe() # Scans frames from innermost to outermost for a TestProgram # instance. This python object has a verbosity defined in it. while frame: cls = frame.f_locals.get('cls') if isinstance(cls, unittest.TestProgram): return cls.verbose # Proceed to one outer frame. frame = frame.f_back return 0 # METACLASS: set verbosity. classdict['verbose'] = verbose return type.__new__(mcs, name, bases, classdict)
def make_test_program_class(extra_tests): """ Return a subclass of unittest.TestProgram. """ # The function unittest.main() is an alias for unittest.TestProgram's # constructor. TestProgram's constructor does the following: # # 1. calls self.parseArgs(argv), # 2. which in turn calls self.createTests(). # 3. then the constructor calls self.runTests(). # # The createTests() method sets the self.test attribute by calling one # of self.testLoader's "loadTests" methods. Each loadTest method returns # a unittest.TestSuite instance. Thus, self.test is set to a TestSuite # instance prior to calling runTests(). class PystacheTestProgram(TestProgram): """ Instantiating an instance of this class runs all tests. """ def createTests(self): """ Load tests and set self.test to a unittest.TestSuite instance Compare-- http://docs.python.org/library/unittest.html#unittest.TestSuite """ super(PystacheTestProgram, self).createTests() self.test.addTests(extra_tests) return PystacheTestProgram # Do not include "test" in this function's name to avoid it getting # picked up by nosetests.
