| import sys |
| import types |
| import warnings |
| |
| import unittest |
| |
| # Decorator used in the deprecation tests to reset the warning registry for |
| # test isolation and reproducibility. |
| def warningregistry(func): |
| def wrapper(*args, **kws): |
| missing = [] |
| saved = getattr(warnings, '__warningregistry__', missing).copy() |
| try: |
| return func(*args, **kws) |
| finally: |
| if saved is missing: |
| try: |
| del warnings.__warningregistry__ |
| except AttributeError: |
| pass |
| else: |
| warnings.__warningregistry__ = saved |
| return wrapper |
| |
| |
| class Test_TestLoader(unittest.TestCase): |
| |
| ### Basic object tests |
| ################################################################ |
| |
| def test___init__(self): |
| loader = unittest.TestLoader() |
| self.assertEqual([], loader.errors) |
| |
| ### Tests for TestLoader.loadTestsFromTestCase |
| ################################################################ |
| |
| # "Return a suite of all test cases contained in the TestCase-derived |
| # class testCaseClass" |
| def test_loadTestsFromTestCase(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| |
| tests = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) |
| |
| loader = unittest.TestLoader() |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) |
| |
| # "Return a suite of all test cases contained in the TestCase-derived |
| # class testCaseClass" |
| # |
| # Make sure it does the right thing even if no tests were found |
| def test_loadTestsFromTestCase__no_matches(self): |
| class Foo(unittest.TestCase): |
| def foo_bar(self): pass |
| |
| empty_suite = unittest.TestSuite() |
| |
| loader = unittest.TestLoader() |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite) |
| |
| # "Return a suite of all test cases contained in the TestCase-derived |
| # class testCaseClass" |
| # |
| # What happens if loadTestsFromTestCase() is given an object |
| # that isn't a subclass of TestCase? Specifically, what happens |
| # if testCaseClass is a subclass of TestSuite? |
| # |
| # This is checked for specifically in the code, so we better add a |
| # test for it. |
| def test_loadTestsFromTestCase__TestSuite_subclass(self): |
| class NotATestCase(unittest.TestSuite): |
| pass |
| |
| loader = unittest.TestLoader() |
| try: |
| loader.loadTestsFromTestCase(NotATestCase) |
| except TypeError: |
| pass |
| else: |
| self.fail('Should raise TypeError') |
| |
| # "Return a suite of all test cases contained in the TestCase-derived |
| # class testCaseClass" |
| # |
| # Make sure loadTestsFromTestCase() picks up the default test method |
| # name (as specified by TestCase), even though the method name does |
| # not match the default TestLoader.testMethodPrefix string |
| def test_loadTestsFromTestCase__default_method_name(self): |
| class Foo(unittest.TestCase): |
| def runTest(self): |
| pass |
| |
| loader = unittest.TestLoader() |
| # This has to be false for the test to succeed |
| self.assertFalse('runTest'.startswith(loader.testMethodPrefix)) |
| |
| suite = loader.loadTestsFromTestCase(Foo) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [Foo('runTest')]) |
| |
| ################################################################ |
| ### /Tests for TestLoader.loadTestsFromTestCase |
| |
| ### Tests for TestLoader.loadTestsFromModule |
| ################################################################ |
| |
| # "This method searches `module` for classes derived from TestCase" |
| def test_loadTestsFromModule__TestCase_subclass(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| expected = [loader.suiteClass([MyTestCase('test')])] |
| self.assertEqual(list(suite), expected) |
| |
| # "This method searches `module` for classes derived from TestCase" |
| # |
| # What happens if no tests are found (no TestCase instances)? |
| def test_loadTestsFromModule__no_TestCase_instances(self): |
| m = types.ModuleType('m') |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), []) |
| |
| # "This method searches `module` for classes derived from TestCase" |
| # |
| # What happens if no tests are found (TestCases instances, but no tests)? |
| def test_loadTestsFromModule__no_TestCase_tests(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| self.assertEqual(list(suite), [loader.suiteClass()]) |
| |
| # "This method searches `module` for classes derived from TestCase"s |
| # |
| # What happens if loadTestsFromModule() is given something other |
| # than a module? |
| # |
| # XXX Currently, it succeeds anyway. This flexibility |
| # should either be documented or loadTestsFromModule() should |
| # raise a TypeError |
| # |
| # XXX Certain people are using this behaviour. We'll add a test for it |
| def test_loadTestsFromModule__not_a_module(self): |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| |
| class NotAModule(object): |
| test_2 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(NotAModule) |
| |
| reference = [unittest.TestSuite([MyTestCase('test')])] |
| self.assertEqual(list(suite), reference) |
| |
| |
| # Check that loadTestsFromModule honors (or not) a module |
| # with a load_tests function. |
| @warningregistry |
| def test_loadTestsFromModule__load_tests(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m) |
| self.assertIsInstance(suite, unittest.TestSuite) |
| self.assertEqual(load_tests_args, [loader, suite, None]) |
| # With Python 3.5, the undocumented and unofficial use_load_tests is |
| # ignored (and deprecated). |
| load_tests_args = [] |
| with warnings.catch_warnings(record=False): |
| warnings.simplefilter('ignore') |
| suite = loader.loadTestsFromModule(m, use_load_tests=False) |
| self.assertEqual(load_tests_args, [loader, suite, None]) |
| |
| @warningregistry |
| def test_loadTestsFromModule__use_load_tests_deprecated_positional(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| # The method still works. |
| loader = unittest.TestLoader() |
| # use_load_tests=True as a positional argument. |
| with warnings.catch_warnings(record=True) as w: |
| warnings.simplefilter('always') |
| suite = loader.loadTestsFromModule(m, False) |
| self.assertIsInstance(suite, unittest.TestSuite) |
| # load_tests was still called because use_load_tests is deprecated |
| # and ignored. |
| self.assertEqual(load_tests_args, [loader, suite, None]) |
| # We got a warning. |
| self.assertIs(w[-1].category, DeprecationWarning) |
| self.assertEqual(str(w[-1].message), |
| 'use_load_tests is deprecated and ignored') |
| |
| @warningregistry |
| def test_loadTestsFromModule__use_load_tests_deprecated_keyword(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| # The method still works. |
| loader = unittest.TestLoader() |
| with warnings.catch_warnings(record=True) as w: |
| warnings.simplefilter('always') |
| suite = loader.loadTestsFromModule(m, use_load_tests=False) |
| self.assertIsInstance(suite, unittest.TestSuite) |
| # load_tests was still called because use_load_tests is deprecated |
| # and ignored. |
| self.assertEqual(load_tests_args, [loader, suite, None]) |
| # We got a warning. |
| self.assertIs(w[-1].category, DeprecationWarning) |
| self.assertEqual(str(w[-1].message), |
| 'use_load_tests is deprecated and ignored') |
| |
| @warningregistry |
| def test_loadTestsFromModule__too_many_positional_args(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| loader = unittest.TestLoader() |
| with self.assertRaises(TypeError) as cm, \ |
| warnings.catch_warnings(record=True) as w: |
| warnings.simplefilter('always') |
| loader.loadTestsFromModule(m, False, 'testme.*') |
| # We still got the deprecation warning. |
| self.assertIs(w[-1].category, DeprecationWarning) |
| self.assertEqual(str(w[-1].message), |
| 'use_load_tests is deprecated and ignored') |
| # We also got a TypeError for too many positional arguments. |
| self.assertEqual(type(cm.exception), TypeError) |
| self.assertEqual( |
| str(cm.exception), |
| 'loadTestsFromModule() takes 1 positional argument but 3 were given') |
| |
| @warningregistry |
| def test_loadTestsFromModule__use_load_tests_other_bad_keyword(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| loader = unittest.TestLoader() |
| with warnings.catch_warnings(): |
| warnings.simplefilter('ignore') |
| with self.assertRaises(TypeError) as cm: |
| loader.loadTestsFromModule( |
| m, use_load_tests=False, very_bad=True, worse=False) |
| self.assertEqual(type(cm.exception), TypeError) |
| # The error message names the first bad argument alphabetically, |
| # however use_load_tests (which sorts first) is ignored. |
| self.assertEqual( |
| str(cm.exception), |
| "loadTestsFromModule() got an unexpected keyword argument 'very_bad'") |
| |
| def test_loadTestsFromModule__pattern(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| load_tests_args = [] |
| def load_tests(loader, tests, pattern): |
| self.assertIsInstance(tests, unittest.TestSuite) |
| load_tests_args.extend((loader, tests, pattern)) |
| return tests |
| m.load_tests = load_tests |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m, pattern='testme.*') |
| self.assertIsInstance(suite, unittest.TestSuite) |
| self.assertEqual(load_tests_args, [loader, suite, 'testme.*']) |
| |
| def test_loadTestsFromModule__faulty_load_tests(self): |
| m = types.ModuleType('m') |
| |
| def load_tests(loader, tests, pattern): |
| raise TypeError('some failure') |
| m.load_tests = load_tests |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromModule(m) |
| self.assertIsInstance(suite, unittest.TestSuite) |
| self.assertEqual(suite.countTestCases(), 1) |
| # Errors loading the suite are also captured for introspection. |
| self.assertNotEqual([], loader.errors) |
| self.assertEqual(1, len(loader.errors)) |
| error = loader.errors[0] |
| self.assertTrue( |
| 'Failed to call load_tests:' in error, |
| 'missing error string in %r' % error) |
| test = list(suite)[0] |
| |
| self.assertRaisesRegex(TypeError, "some failure", test.m) |
| |
| ################################################################ |
| ### /Tests for TestLoader.loadTestsFromModule() |
| |
| ### Tests for TestLoader.loadTestsFromName() |
| ################################################################ |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # Is ValueError raised in response to an empty name? |
| def test_loadTestsFromName__empty_name(self): |
| loader = unittest.TestLoader() |
| |
| try: |
| loader.loadTestsFromName('') |
| except ValueError as e: |
| self.assertEqual(str(e), "Empty module name") |
| else: |
| self.fail("TestLoader.loadTestsFromName failed to raise ValueError") |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when the name contains invalid characters? |
| def test_loadTestsFromName__malformed_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('abc () //') |
| error, test = self.check_deferred_error(loader, suite) |
| expected = "Failed to import test module: abc () //" |
| expected_regex = r"Failed to import test module: abc \(\) //" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex( |
| ImportError, expected_regex, getattr(test, 'abc () //')) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to a |
| # module" |
| # |
| # What happens when a module by that name can't be found? |
| def test_loadTestsFromName__unknown_module_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('sdasfasfasdf') |
| expected = "No module named 'sdasfasfasdf'" |
| error, test = self.check_deferred_error(loader, suite) |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when the module is found, but the attribute isn't? |
| def test_loadTestsFromName__unknown_attr_name_on_module(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('unittest.loader.sdasfasfasdf') |
| expected = "module 'unittest.loader' has no attribute 'sdasfasfasdf'" |
| error, test = self.check_deferred_error(loader, suite) |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when the module is found, but the attribute isn't? |
| def test_loadTestsFromName__unknown_attr_name_on_package(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('unittest.sdasfasfasdf') |
| expected = "No module named 'unittest.sdasfasfasdf'" |
| error, test = self.check_deferred_error(loader, suite) |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when we provide the module, but the attribute can't be |
| # found? |
| def test_loadTestsFromName__relative_unknown_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('sdasfasfasdf', unittest) |
| expected = "module 'unittest' has no attribute 'sdasfasfasdf'" |
| error, test = self.check_deferred_error(loader, suite) |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # Does loadTestsFromName raise ValueError when passed an empty |
| # name relative to a provided module? |
| # |
| # XXX Should probably raise a ValueError instead of an AttributeError |
| def test_loadTestsFromName__relative_empty_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromName('', unittest) |
| error, test = self.check_deferred_error(loader, suite) |
| expected = "has no attribute ''" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, getattr(test, '')) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # What happens when an impossible name is given, relative to the provided |
| # `module`? |
| def test_loadTestsFromName__relative_malformed_name(self): |
| loader = unittest.TestLoader() |
| |
| # XXX Should this raise AttributeError or ValueError? |
| suite = loader.loadTestsFromName('abc () //', unittest) |
| error, test = self.check_deferred_error(loader, suite) |
| expected = "module 'unittest' has no attribute 'abc () //'" |
| expected_regex = r"module 'unittest' has no attribute 'abc \(\) //'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex( |
| AttributeError, expected_regex, getattr(test, 'abc () //')) |
| |
| # "The method optionally resolves name relative to the given module" |
| # |
| # Does loadTestsFromName raise TypeError when the `module` argument |
| # isn't a module object? |
| # |
| # XXX Accepts the not-a-module object, ignoring the object's type |
| # This should raise an exception or the method name should be changed |
| # |
| # XXX Some people are relying on this, so keep it for now |
| def test_loadTestsFromName__relative_not_a_module(self): |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| |
| class NotAModule(object): |
| test_2 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('test_2', NotAModule) |
| |
| reference = [MyTestCase('test')] |
| self.assertEqual(list(suite), reference) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # Does it raise an exception if the name resolves to an invalid |
| # object? |
| def test_loadTestsFromName__relative_bad_object(self): |
| m = types.ModuleType('m') |
| m.testcase_1 = object() |
| |
| loader = unittest.TestLoader() |
| try: |
| loader.loadTestsFromName('testcase_1', m) |
| except TypeError: |
| pass |
| else: |
| self.fail("Should have raised TypeError") |
| |
| # "The specifier name is a ``dotted name'' that may |
| # resolve either to ... a test case class" |
| def test_loadTestsFromName__relative_TestCase_subclass(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('testcase_1', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [MyTestCase('test')]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| def test_loadTestsFromName__relative_TestSuite(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testsuite = unittest.TestSuite([MyTestCase('test')]) |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('testsuite', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| self.assertEqual(list(suite), [MyTestCase('test')]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a test method within a test case class" |
| def test_loadTestsFromName__relative_testmethod(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('testcase_1.test', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| self.assertEqual(list(suite), [MyTestCase('test')]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # Does loadTestsFromName() raise the proper exception when trying to |
| # resolve "a test method within a test case class" that doesn't exist |
| # for the given name (relative to a provided module)? |
| def test_loadTestsFromName__relative_invalid_testmethod(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('testcase_1.testfoo', m) |
| expected = "type object 'MyTestCase' has no attribute 'testfoo'" |
| error, test = self.check_deferred_error(loader, suite) |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.testfoo) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a ... TestSuite instance" |
| def test_loadTestsFromName__callable__TestSuite(self): |
| m = types.ModuleType('m') |
| testcase_1 = unittest.FunctionTestCase(lambda: None) |
| testcase_2 = unittest.FunctionTestCase(lambda: None) |
| def return_TestSuite(): |
| return unittest.TestSuite([testcase_1, testcase_2]) |
| m.return_TestSuite = return_TestSuite |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('return_TestSuite', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [testcase_1, testcase_2]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase ... instance" |
| def test_loadTestsFromName__callable__TestCase_instance(self): |
| m = types.ModuleType('m') |
| testcase_1 = unittest.FunctionTestCase(lambda: None) |
| def return_TestCase(): |
| return testcase_1 |
| m.return_TestCase = return_TestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromName('return_TestCase', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [testcase_1]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase ... instance" |
| #***************************************************************** |
| #Override the suiteClass attribute to ensure that the suiteClass |
| #attribute is used |
| def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self): |
| class SubTestSuite(unittest.TestSuite): |
| pass |
| m = types.ModuleType('m') |
| testcase_1 = unittest.FunctionTestCase(lambda: None) |
| def return_TestCase(): |
| return testcase_1 |
| m.return_TestCase = return_TestCase |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass = SubTestSuite |
| suite = loader.loadTestsFromName('return_TestCase', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [testcase_1]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a test method within a test case class" |
| #***************************************************************** |
| #Override the suiteClass attribute to ensure that the suiteClass |
| #attribute is used |
| def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self): |
| class SubTestSuite(unittest.TestSuite): |
| pass |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass=SubTestSuite |
| suite = loader.loadTestsFromName('testcase_1.test', m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| self.assertEqual(list(suite), [MyTestCase('test')]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase or TestSuite instance" |
| # |
| # What happens if the callable returns something else? |
| def test_loadTestsFromName__callable__wrong_type(self): |
| m = types.ModuleType('m') |
| def return_wrong(): |
| return 6 |
| m.return_wrong = return_wrong |
| |
| loader = unittest.TestLoader() |
| try: |
| suite = loader.loadTestsFromName('return_wrong', m) |
| except TypeError: |
| pass |
| else: |
| self.fail("TestLoader.loadTestsFromName failed to raise TypeError") |
| |
| # "The specifier can refer to modules and packages which have not been |
| # imported; they will be imported as a side-effect" |
| def test_loadTestsFromName__module_not_loaded(self): |
| # We're going to try to load this module as a side-effect, so it |
| # better not be loaded before we try. |
| # |
| module_name = 'unittest.test.dummy' |
| sys.modules.pop(module_name, None) |
| |
| loader = unittest.TestLoader() |
| try: |
| suite = loader.loadTestsFromName(module_name) |
| |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), []) |
| |
| # module should now be loaded, thanks to loadTestsFromName() |
| self.assertIn(module_name, sys.modules) |
| finally: |
| if module_name in sys.modules: |
| del sys.modules[module_name] |
| |
| ################################################################ |
| ### Tests for TestLoader.loadTestsFromName() |
| |
| ### Tests for TestLoader.loadTestsFromNames() |
| ################################################################ |
| |
| def check_deferred_error(self, loader, suite): |
| """Helper function for checking that errors in loading are reported. |
| |
| :param loader: A loader with some errors. |
| :param suite: A suite that should have a late bound error. |
| :return: The first error message from the loader and the test object |
| from the suite. |
| """ |
| self.assertIsInstance(suite, unittest.TestSuite) |
| self.assertEqual(suite.countTestCases(), 1) |
| # Errors loading the suite are also captured for introspection. |
| self.assertNotEqual([], loader.errors) |
| self.assertEqual(1, len(loader.errors)) |
| error = loader.errors[0] |
| test = list(suite)[0] |
| return error, test |
| |
| # "Similar to loadTestsFromName(), but takes a sequence of names rather |
| # than a single name." |
| # |
| # What happens if that sequence of names is empty? |
| def test_loadTestsFromNames__empty_name_list(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames([]) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), []) |
| |
| # "Similar to loadTestsFromName(), but takes a sequence of names rather |
| # than a single name." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # What happens if that sequence of names is empty? |
| # |
| # XXX Should this raise a ValueError or just return an empty TestSuite? |
| def test_loadTestsFromNames__relative_empty_name_list(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames([], unittest) |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), []) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # Is ValueError raised in response to an empty name? |
| def test_loadTestsFromNames__empty_name(self): |
| loader = unittest.TestLoader() |
| |
| try: |
| loader.loadTestsFromNames(['']) |
| except ValueError as e: |
| self.assertEqual(str(e), "Empty module name") |
| else: |
| self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when presented with an impossible module name? |
| def test_loadTestsFromNames__malformed_name(self): |
| loader = unittest.TestLoader() |
| |
| # XXX Should this raise ValueError or ImportError? |
| suite = loader.loadTestsFromNames(['abc () //']) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "Failed to import test module: abc () //" |
| expected_regex = r"Failed to import test module: abc \(\) //" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex( |
| ImportError, expected_regex, getattr(test, 'abc () //')) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when no module can be found for the given name? |
| def test_loadTestsFromNames__unknown_module_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames(['sdasfasfasdf']) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "Failed to import test module: sdasfasfasdf" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # What happens when the module can be found, but not the attribute? |
| def test_loadTestsFromNames__unknown_attr_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames( |
| ['unittest.loader.sdasfasfasdf', 'unittest.test.dummy']) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "module 'unittest.loader' has no attribute 'sdasfasfasdf'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # What happens when given an unknown attribute on a specified `module` |
| # argument? |
| def test_loadTestsFromNames__unknown_name_relative_1(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames(['sdasfasfasdf'], unittest) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "module 'unittest' has no attribute 'sdasfasfasdf'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # Do unknown attributes (relative to a provided module) still raise an |
| # exception even in the presence of valid attribute names? |
| def test_loadTestsFromNames__unknown_name_relative_2(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest) |
| error, test = self.check_deferred_error(loader, list(suite)[1]) |
| expected = "module 'unittest' has no attribute 'sdasfasfasdf'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # What happens when faced with the empty string? |
| # |
| # XXX This currently raises AttributeError, though ValueError is probably |
| # more appropriate |
| def test_loadTestsFromNames__relative_empty_name(self): |
| loader = unittest.TestLoader() |
| |
| suite = loader.loadTestsFromNames([''], unittest) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "has no attribute ''" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, getattr(test, '')) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # ... |
| # "The method optionally resolves name relative to the given module" |
| # |
| # What happens when presented with an impossible attribute name? |
| def test_loadTestsFromNames__relative_malformed_name(self): |
| loader = unittest.TestLoader() |
| |
| # XXX Should this raise AttributeError or ValueError? |
| suite = loader.loadTestsFromNames(['abc () //'], unittest) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "module 'unittest' has no attribute 'abc () //'" |
| expected_regex = r"module 'unittest' has no attribute 'abc \(\) //'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex( |
| AttributeError, expected_regex, getattr(test, 'abc () //')) |
| |
| # "The method optionally resolves name relative to the given module" |
| # |
| # Does loadTestsFromNames() make sure the provided `module` is in fact |
| # a module? |
| # |
| # XXX This validation is currently not done. This flexibility should |
| # either be documented or a TypeError should be raised. |
| def test_loadTestsFromNames__relative_not_a_module(self): |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| |
| class NotAModule(object): |
| test_2 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['test_2'], NotAModule) |
| |
| reference = [unittest.TestSuite([MyTestCase('test')])] |
| self.assertEqual(list(suite), reference) |
| |
| # "The specifier name is a ``dotted name'' that may resolve either to |
| # a module, a test case class, a TestSuite instance, a test method |
| # within a test case class, or a callable object which returns a |
| # TestCase or TestSuite instance." |
| # |
| # Does it raise an exception if the name resolves to an invalid |
| # object? |
| def test_loadTestsFromNames__relative_bad_object(self): |
| m = types.ModuleType('m') |
| m.testcase_1 = object() |
| |
| loader = unittest.TestLoader() |
| try: |
| loader.loadTestsFromNames(['testcase_1'], m) |
| except TypeError: |
| pass |
| else: |
| self.fail("Should have raised TypeError") |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a test case class" |
| def test_loadTestsFromNames__relative_TestCase_subclass(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['testcase_1'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| expected = loader.suiteClass([MyTestCase('test')]) |
| self.assertEqual(list(suite), [expected]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a TestSuite instance" |
| def test_loadTestsFromNames__relative_TestSuite(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testsuite = unittest.TestSuite([MyTestCase('test')]) |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['testsuite'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| self.assertEqual(list(suite), [m.testsuite]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to ... a |
| # test method within a test case class" |
| def test_loadTestsFromNames__relative_testmethod(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['testcase_1.test'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| ref_suite = unittest.TestSuite([MyTestCase('test')]) |
| self.assertEqual(list(suite), [ref_suite]) |
| |
| # #14971: Make sure the dotted name resolution works even if the actual |
| # function doesn't have the same name as is used to find it. |
| def test_loadTestsFromName__function_with_different_name_than_method(self): |
| # lambdas have the name '<lambda>'. |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| test = lambda: 1 |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['testcase_1.test'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| ref_suite = unittest.TestSuite([MyTestCase('test')]) |
| self.assertEqual(list(suite), [ref_suite]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to ... a |
| # test method within a test case class" |
| # |
| # Does the method gracefully handle names that initially look like they |
| # resolve to "a test method within a test case class" but don't? |
| def test_loadTestsFromNames__relative_invalid_testmethod(self): |
| m = types.ModuleType('m') |
| class MyTestCase(unittest.TestCase): |
| def test(self): |
| pass |
| m.testcase_1 = MyTestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['testcase_1.testfoo'], m) |
| error, test = self.check_deferred_error(loader, list(suite)[0]) |
| expected = "type object 'MyTestCase' has no attribute 'testfoo'" |
| self.assertIn( |
| expected, error, |
| 'missing error string in %r' % error) |
| self.assertRaisesRegex(AttributeError, expected, test.testfoo) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a ... TestSuite instance" |
| def test_loadTestsFromNames__callable__TestSuite(self): |
| m = types.ModuleType('m') |
| testcase_1 = unittest.FunctionTestCase(lambda: None) |
| testcase_2 = unittest.FunctionTestCase(lambda: None) |
| def return_TestSuite(): |
| return unittest.TestSuite([testcase_1, testcase_2]) |
| m.return_TestSuite = return_TestSuite |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['return_TestSuite'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| expected = unittest.TestSuite([testcase_1, testcase_2]) |
| self.assertEqual(list(suite), [expected]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase ... instance" |
| def test_loadTestsFromNames__callable__TestCase_instance(self): |
| m = types.ModuleType('m') |
| testcase_1 = unittest.FunctionTestCase(lambda: None) |
| def return_TestCase(): |
| return testcase_1 |
| m.return_TestCase = return_TestCase |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['return_TestCase'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| ref_suite = unittest.TestSuite([testcase_1]) |
| self.assertEqual(list(suite), [ref_suite]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase or TestSuite instance" |
| # |
| # Are staticmethods handled correctly? |
| def test_loadTestsFromNames__callable__call_staticmethod(self): |
| m = types.ModuleType('m') |
| class Test1(unittest.TestCase): |
| def test(self): |
| pass |
| |
| testcase_1 = Test1('test') |
| class Foo(unittest.TestCase): |
| @staticmethod |
| def foo(): |
| return testcase_1 |
| m.Foo = Foo |
| |
| loader = unittest.TestLoader() |
| suite = loader.loadTestsFromNames(['Foo.foo'], m) |
| self.assertIsInstance(suite, loader.suiteClass) |
| |
| ref_suite = unittest.TestSuite([testcase_1]) |
| self.assertEqual(list(suite), [ref_suite]) |
| |
| # "The specifier name is a ``dotted name'' that may resolve ... to |
| # ... a callable object which returns a TestCase or TestSuite instance" |
| # |
| # What happens when the callable returns something else? |
| def test_loadTestsFromNames__callable__wrong_type(self): |
| m = types.ModuleType('m') |
| def return_wrong(): |
| return 6 |
| m.return_wrong = return_wrong |
| |
| loader = unittest.TestLoader() |
| try: |
| suite = loader.loadTestsFromNames(['return_wrong'], m) |
| except TypeError: |
| pass |
| else: |
| self.fail("TestLoader.loadTestsFromNames failed to raise TypeError") |
| |
| # "The specifier can refer to modules and packages which have not been |
| # imported; they will be imported as a side-effect" |
| def test_loadTestsFromNames__module_not_loaded(self): |
| # We're going to try to load this module as a side-effect, so it |
| # better not be loaded before we try. |
| # |
| module_name = 'unittest.test.dummy' |
| sys.modules.pop(module_name, None) |
| |
| loader = unittest.TestLoader() |
| try: |
| suite = loader.loadTestsFromNames([module_name]) |
| |
| self.assertIsInstance(suite, loader.suiteClass) |
| self.assertEqual(list(suite), [unittest.TestSuite()]) |
| |
| # module should now be loaded, thanks to loadTestsFromName() |
| self.assertIn(module_name, sys.modules) |
| finally: |
| if module_name in sys.modules: |
| del sys.modules[module_name] |
| |
| ################################################################ |
| ### /Tests for TestLoader.loadTestsFromNames() |
| |
| ### Tests for TestLoader.getTestCaseNames() |
| ################################################################ |
| |
| # "Return a sorted sequence of method names found within testCaseClass" |
| # |
| # Test.foobar is defined to make sure getTestCaseNames() respects |
| # loader.testMethodPrefix |
| def test_getTestCaseNames(self): |
| class Test(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foobar(self): pass |
| |
| loader = unittest.TestLoader() |
| |
| self.assertEqual(loader.getTestCaseNames(Test), ['test_1', 'test_2']) |
| |
| # "Return a sorted sequence of method names found within testCaseClass" |
| # |
| # Does getTestCaseNames() behave appropriately if no tests are found? |
| def test_getTestCaseNames__no_tests(self): |
| class Test(unittest.TestCase): |
| def foobar(self): pass |
| |
| loader = unittest.TestLoader() |
| |
| self.assertEqual(loader.getTestCaseNames(Test), []) |
| |
| # "Return a sorted sequence of method names found within testCaseClass" |
| # |
| # Are not-TestCases handled gracefully? |
| # |
| # XXX This should raise a TypeError, not return a list |
| # |
| # XXX It's too late in the 2.5 release cycle to fix this, but it should |
| # probably be revisited for 2.6 |
| def test_getTestCaseNames__not_a_TestCase(self): |
| class BadCase(int): |
| def test_foo(self): |
| pass |
| |
| loader = unittest.TestLoader() |
| names = loader.getTestCaseNames(BadCase) |
| |
| self.assertEqual(names, ['test_foo']) |
| |
| # "Return a sorted sequence of method names found within testCaseClass" |
| # |
| # Make sure inherited names are handled. |
| # |
| # TestP.foobar is defined to make sure getTestCaseNames() respects |
| # loader.testMethodPrefix |
| def test_getTestCaseNames__inheritance(self): |
| class TestP(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foobar(self): pass |
| |
| class TestC(TestP): |
| def test_1(self): pass |
| def test_3(self): pass |
| |
| loader = unittest.TestLoader() |
| |
| names = ['test_1', 'test_2', 'test_3'] |
| self.assertEqual(loader.getTestCaseNames(TestC), names) |
| |
| ################################################################ |
| ### /Tests for TestLoader.getTestCaseNames() |
| |
| ### Tests for TestLoader.testMethodPrefix |
| ################################################################ |
| |
| # "String giving the prefix of method names which will be interpreted as |
| # test methods" |
| # |
| # Implicit in the documentation is that testMethodPrefix is respected by |
| # all loadTestsFrom* methods. |
| def test_testMethodPrefix__loadTestsFromTestCase(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| |
| tests_1 = unittest.TestSuite([Foo('foo_bar')]) |
| tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) |
| |
| loader = unittest.TestLoader() |
| loader.testMethodPrefix = 'foo' |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1) |
| |
| loader.testMethodPrefix = 'test' |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2) |
| |
| # "String giving the prefix of method names which will be interpreted as |
| # test methods" |
| # |
| # Implicit in the documentation is that testMethodPrefix is respected by |
| # all loadTestsFrom* methods. |
| def test_testMethodPrefix__loadTestsFromModule(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests_1 = [unittest.TestSuite([Foo('foo_bar')])] |
| tests_2 = [unittest.TestSuite([Foo('test_1'), Foo('test_2')])] |
| |
| loader = unittest.TestLoader() |
| loader.testMethodPrefix = 'foo' |
| self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1) |
| |
| loader.testMethodPrefix = 'test' |
| self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2) |
| |
| # "String giving the prefix of method names which will be interpreted as |
| # test methods" |
| # |
| # Implicit in the documentation is that testMethodPrefix is respected by |
| # all loadTestsFrom* methods. |
| def test_testMethodPrefix__loadTestsFromName(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests_1 = unittest.TestSuite([Foo('foo_bar')]) |
| tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) |
| |
| loader = unittest.TestLoader() |
| loader.testMethodPrefix = 'foo' |
| self.assertEqual(loader.loadTestsFromName('Foo', m), tests_1) |
| |
| loader.testMethodPrefix = 'test' |
| self.assertEqual(loader.loadTestsFromName('Foo', m), tests_2) |
| |
| # "String giving the prefix of method names which will be interpreted as |
| # test methods" |
| # |
| # Implicit in the documentation is that testMethodPrefix is respected by |
| # all loadTestsFrom* methods. |
| def test_testMethodPrefix__loadTestsFromNames(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests_1 = unittest.TestSuite([unittest.TestSuite([Foo('foo_bar')])]) |
| tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) |
| tests_2 = unittest.TestSuite([tests_2]) |
| |
| loader = unittest.TestLoader() |
| loader.testMethodPrefix = 'foo' |
| self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_1) |
| |
| loader.testMethodPrefix = 'test' |
| self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_2) |
| |
| # "The default value is 'test'" |
| def test_testMethodPrefix__default_value(self): |
| loader = unittest.TestLoader() |
| self.assertEqual(loader.testMethodPrefix, 'test') |
| |
| ################################################################ |
| ### /Tests for TestLoader.testMethodPrefix |
| |
| ### Tests for TestLoader.sortTestMethodsUsing |
| ################################################################ |
| |
| # "Function to be used to compare method names when sorting them in |
| # getTestCaseNames() and all the loadTestsFromX() methods" |
| def test_sortTestMethodsUsing__loadTestsFromTestCase(self): |
| def reversed_cmp(x, y): |
| return -((x > y) - (x < y)) |
| |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = reversed_cmp |
| |
| tests = loader.suiteClass([Foo('test_2'), Foo('test_1')]) |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) |
| |
| # "Function to be used to compare method names when sorting them in |
| # getTestCaseNames() and all the loadTestsFromX() methods" |
| def test_sortTestMethodsUsing__loadTestsFromModule(self): |
| def reversed_cmp(x, y): |
| return -((x > y) - (x < y)) |
| |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| m.Foo = Foo |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = reversed_cmp |
| |
| tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])] |
| self.assertEqual(list(loader.loadTestsFromModule(m)), tests) |
| |
| # "Function to be used to compare method names when sorting them in |
| # getTestCaseNames() and all the loadTestsFromX() methods" |
| def test_sortTestMethodsUsing__loadTestsFromName(self): |
| def reversed_cmp(x, y): |
| return -((x > y) - (x < y)) |
| |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| m.Foo = Foo |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = reversed_cmp |
| |
| tests = loader.suiteClass([Foo('test_2'), Foo('test_1')]) |
| self.assertEqual(loader.loadTestsFromName('Foo', m), tests) |
| |
| # "Function to be used to compare method names when sorting them in |
| # getTestCaseNames() and all the loadTestsFromX() methods" |
| def test_sortTestMethodsUsing__loadTestsFromNames(self): |
| def reversed_cmp(x, y): |
| return -((x > y) - (x < y)) |
| |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| m.Foo = Foo |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = reversed_cmp |
| |
| tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])] |
| self.assertEqual(list(loader.loadTestsFromNames(['Foo'], m)), tests) |
| |
| # "Function to be used to compare method names when sorting them in |
| # getTestCaseNames()" |
| # |
| # Does it actually affect getTestCaseNames()? |
| def test_sortTestMethodsUsing__getTestCaseNames(self): |
| def reversed_cmp(x, y): |
| return -((x > y) - (x < y)) |
| |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = reversed_cmp |
| |
| test_names = ['test_2', 'test_1'] |
| self.assertEqual(loader.getTestCaseNames(Foo), test_names) |
| |
| # "The default value is the built-in cmp() function" |
| # Since cmp is now defunct, we simply verify that the results |
| # occur in the same order as they would with the default sort. |
| def test_sortTestMethodsUsing__default_value(self): |
| loader = unittest.TestLoader() |
| |
| class Foo(unittest.TestCase): |
| def test_2(self): pass |
| def test_3(self): pass |
| def test_1(self): pass |
| |
| test_names = ['test_2', 'test_3', 'test_1'] |
| self.assertEqual(loader.getTestCaseNames(Foo), sorted(test_names)) |
| |
| |
| # "it can be set to None to disable the sort." |
| # |
| # XXX How is this different from reassigning cmp? Are the tests returned |
| # in a random order or something? This behaviour should die |
| def test_sortTestMethodsUsing__None(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| |
| loader = unittest.TestLoader() |
| loader.sortTestMethodsUsing = None |
| |
| test_names = ['test_2', 'test_1'] |
| self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names)) |
| |
| ################################################################ |
| ### /Tests for TestLoader.sortTestMethodsUsing |
| |
| ### Tests for TestLoader.suiteClass |
| ################################################################ |
| |
| # "Callable object that constructs a test suite from a list of tests." |
| def test_suiteClass__loadTestsFromTestCase(self): |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| |
| tests = [Foo('test_1'), Foo('test_2')] |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass = list |
| self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) |
| |
| # It is implicit in the documentation for TestLoader.suiteClass that |
| # all TestLoader.loadTestsFrom* methods respect it. Let's make sure |
| def test_suiteClass__loadTestsFromModule(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests = [[Foo('test_1'), Foo('test_2')]] |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass = list |
| self.assertEqual(loader.loadTestsFromModule(m), tests) |
| |
| # It is implicit in the documentation for TestLoader.suiteClass that |
| # all TestLoader.loadTestsFrom* methods respect it. Let's make sure |
| def test_suiteClass__loadTestsFromName(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests = [Foo('test_1'), Foo('test_2')] |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass = list |
| self.assertEqual(loader.loadTestsFromName('Foo', m), tests) |
| |
| # It is implicit in the documentation for TestLoader.suiteClass that |
| # all TestLoader.loadTestsFrom* methods respect it. Let's make sure |
| def test_suiteClass__loadTestsFromNames(self): |
| m = types.ModuleType('m') |
| class Foo(unittest.TestCase): |
| def test_1(self): pass |
| def test_2(self): pass |
| def foo_bar(self): pass |
| m.Foo = Foo |
| |
| tests = [[Foo('test_1'), Foo('test_2')]] |
| |
| loader = unittest.TestLoader() |
| loader.suiteClass = list |
| self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests) |
| |
| # "The default value is the TestSuite class" |
| def test_suiteClass__default_value(self): |
| loader = unittest.TestLoader() |
| self.assertIs(loader.suiteClass, unittest.TestSuite) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
