diff options
Diffstat (limited to 'Lib/unittest/test/test_loader.py')
| -rw-r--r-- | Lib/unittest/test/test_loader.py | 552 |
1 files changed, 129 insertions, 423 deletions
diff --git a/Lib/unittest/test/test_loader.py b/Lib/unittest/test/test_loader.py index bc54bf0..d46ddc8 100644 --- a/Lib/unittest/test/test_loader.py +++ b/Lib/unittest/test/test_loader.py @@ -1,38 +1,12 @@ -import functools 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 +import unittest class Test_TestLoader(unittest.TestCase): - ### Basic object tests - ################################################################ - - def test___init__(self): - loader = unittest.TestLoader() - self.assertEqual([], loader.errors) - ### Tests for TestLoader.loadTestsFromTestCase ################################################################ @@ -176,7 +150,6 @@ class Test_TestLoader(unittest.TestCase): # 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): @@ -195,145 +168,10 @@ class Test_TestLoader(unittest.TestCase): 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.*']) + suite = loader.loadTestsFromModule(m, use_load_tests=False) + self.assertEqual(load_tests_args, []) def test_loadTestsFromModule__faulty_load_tests(self): m = types.ModuleType('m') @@ -346,16 +184,9 @@ class Test_TestLoader(unittest.TestCase): 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) + self.assertRaisesRegexp(TypeError, "some failure", test.m) ################################################################ ### /Tests for TestLoader.loadTestsFromModule() @@ -374,7 +205,7 @@ class Test_TestLoader(unittest.TestCase): try: loader.loadTestsFromName('') - except ValueError as e: + except ValueError, e: self.assertEqual(str(e), "Empty module name") else: self.fail("TestLoader.loadTestsFromName failed to raise ValueError") @@ -388,15 +219,15 @@ class Test_TestLoader(unittest.TestCase): 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 () //')) + # XXX Should this raise ValueError or ImportError? + try: + loader.loadTestsFromName('abc () //') + except ValueError: + pass + except ImportError: + pass + else: + self.fail("TestLoader.loadTestsFromName failed to raise ValueError") # "The specifier name is a ``dotted name'' that may resolve ... to a # module" @@ -405,47 +236,28 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromName('sdasfasfasdf') + except ImportError, e: + self.assertEqual(str(e), "No module named sdasfasfasdf") + else: + self.fail("TestLoader.loadTestsFromName failed to raise ImportError") # "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): + # What happens when the module is found, but the attribute can't? + def test_loadTestsFromName__unknown_attr_name(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) + try: + loader.loadTestsFromName('unittest.sdasfasfasdf') + except AttributeError, e: + self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + else: + self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -457,13 +269,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromName('sdasfasfasdf', unittest) + except AttributeError, e: + self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + else: + self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -479,13 +290,12 @@ class Test_TestLoader(unittest.TestCase): 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, '')) + try: + loader.loadTestsFromName('', unittest) + except AttributeError: + pass + else: + self.fail("Failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -500,15 +310,14 @@ class Test_TestLoader(unittest.TestCase): 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 () //')) + try: + loader.loadTestsFromName('abc () //', unittest) + except ValueError: + pass + except AttributeError: + pass + else: + self.fail("TestLoader.loadTestsFromName failed to raise ValueError") # "The method optionally resolves name relative to the given module" # @@ -614,13 +423,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromName('testcase_1.testfoo', m) + except AttributeError, e: + self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + else: + self.fail("Failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve ... to # ... a callable object which returns a ... TestSuite instance" @@ -704,7 +512,7 @@ class Test_TestLoader(unittest.TestCase): loader = unittest.TestLoader() try: - suite = loader.loadTestsFromName('return_wrong', m) + loader.loadTestsFromName('return_wrong', m) except TypeError: pass else: @@ -738,23 +546,6 @@ class Test_TestLoader(unittest.TestCase): ### 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." # @@ -792,7 +583,7 @@ class Test_TestLoader(unittest.TestCase): try: loader.loadTestsFromNames(['']) - except ValueError as e: + except ValueError, e: self.assertEqual(str(e), "Empty module name") else: self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") @@ -807,15 +598,14 @@ class Test_TestLoader(unittest.TestCase): 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 () //')) + try: + loader.loadTestsFromNames(['abc () //']) + except ValueError: + pass + except ImportError: + pass + 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 @@ -826,13 +616,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromNames(['sdasfasfasdf']) + except ImportError, e: + self.assertEqual(str(e), "No module named sdasfasfasdf") + else: + self.fail("TestLoader.loadTestsFromNames failed to raise ImportError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -843,14 +632,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromNames(['unittest.sdasfasfasdf', 'unittest']) + except AttributeError, e: + self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + else: + self.fail("TestLoader.loadTestsFromNames failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -864,13 +651,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromNames(['sdasfasfasdf'], unittest) + except AttributeError, e: + self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + else: + self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -884,13 +670,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest) + except AttributeError, e: + self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + else: + self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -906,13 +691,12 @@ class Test_TestLoader(unittest.TestCase): 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, '')) + try: + loader.loadTestsFromNames([''], unittest) + except AttributeError: + pass + else: + self.fail("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 @@ -926,15 +710,14 @@ class Test_TestLoader(unittest.TestCase): 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 () //')) + try: + loader.loadTestsFromNames(['abc () //'], unittest) + except AttributeError: + pass + except ValueError: + pass + else: + self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") # "The method optionally resolves name relative to the given module" # @@ -1023,22 +806,6 @@ class Test_TestLoader(unittest.TestCase): 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" # @@ -1052,13 +819,12 @@ class Test_TestLoader(unittest.TestCase): 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) + try: + loader.loadTestsFromNames(['testcase_1.testfoo'], m) + except AttributeError, e: + self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + else: + self.fail("Failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve ... to # ... a callable object which returns a ... TestSuite instance" @@ -1129,7 +895,7 @@ class Test_TestLoader(unittest.TestCase): loader = unittest.TestLoader() try: - suite = loader.loadTestsFromNames(['return_wrong'], m) + loader.loadTestsFromNames(['return_wrong'], m) except TypeError: pass else: @@ -1227,56 +993,6 @@ class Test_TestLoader(unittest.TestCase): names = ['test_1', 'test_2', 'test_3'] self.assertEqual(loader.getTestCaseNames(TestC), names) - # "Return a sorted sequence of method names found within testCaseClass" - # - # If TestLoader.testNamePatterns is set, only tests that match one of these - # patterns should be included. - def test_getTestCaseNames__testNamePatterns(self): - class MyTest(unittest.TestCase): - def test_1(self): pass - def test_2(self): pass - def foobar(self): pass - - loader = unittest.TestLoader() - - loader.testNamePatterns = [] - self.assertEqual(loader.getTestCaseNames(MyTest), []) - - loader.testNamePatterns = ['*1'] - self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1']) - - loader.testNamePatterns = ['*1', '*2'] - self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1', 'test_2']) - - loader.testNamePatterns = ['*My*'] - self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1', 'test_2']) - - loader.testNamePatterns = ['*my*'] - self.assertEqual(loader.getTestCaseNames(MyTest), []) - - # "Return a sorted sequence of method names found within testCaseClass" - # - # If TestLoader.testNamePatterns is set, only tests that match one of these - # patterns should be included. - # - # For backwards compatibility reasons (see bpo-32071), the check may only - # touch a TestCase's attribute if it starts with the test method prefix. - def test_getTestCaseNames__testNamePatterns__attribute_access_regression(self): - class Trap: - def __get__(*ignored): - self.fail('Non-test attribute accessed') - - class MyTest(unittest.TestCase): - def test_1(self): pass - foobar = Trap() - - loader = unittest.TestLoader() - self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1']) - - loader = unittest.TestLoader() - loader.testNamePatterns = [] - self.assertEqual(loader.getTestCaseNames(MyTest), []) - ################################################################ ### /Tests for TestLoader.getTestCaseNames() @@ -1377,7 +1093,7 @@ class Test_TestLoader(unittest.TestCase): # "The default value is 'test'" def test_testMethodPrefix__default_value(self): loader = unittest.TestLoader() - self.assertEqual(loader.testMethodPrefix, 'test') + self.assertTrue(loader.testMethodPrefix == 'test') ################################################################ ### /Tests for TestLoader.testMethodPrefix @@ -1389,7 +1105,7 @@ class Test_TestLoader(unittest.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromTestCase(self): def reversed_cmp(x, y): - return -((x > y) - (x < y)) + return -cmp(x, y) class Foo(unittest.TestCase): def test_1(self): pass @@ -1405,7 +1121,7 @@ class Test_TestLoader(unittest.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromModule(self): def reversed_cmp(x, y): - return -((x > y) - (x < y)) + return -cmp(x, y) m = types.ModuleType('m') class Foo(unittest.TestCase): @@ -1423,7 +1139,7 @@ class Test_TestLoader(unittest.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromName(self): def reversed_cmp(x, y): - return -((x > y) - (x < y)) + return -cmp(x, y) m = types.ModuleType('m') class Foo(unittest.TestCase): @@ -1441,7 +1157,7 @@ class Test_TestLoader(unittest.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromNames(self): def reversed_cmp(x, y): - return -((x > y) - (x < y)) + return -cmp(x, y) m = types.ModuleType('m') class Foo(unittest.TestCase): @@ -1461,7 +1177,7 @@ class Test_TestLoader(unittest.TestCase): # Does it actually affect getTestCaseNames()? def test_sortTestMethodsUsing__getTestCaseNames(self): def reversed_cmp(x, y): - return -((x > y) - (x < y)) + return -cmp(x, y) class Foo(unittest.TestCase): def test_1(self): pass @@ -1474,19 +1190,9 @@ class Test_TestLoader(unittest.TestCase): 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)) - + self.assertTrue(loader.sortTestMethodsUsing is cmp) # "it can be set to None to disable the sort." # @@ -1575,21 +1281,21 @@ class Test_TestLoader(unittest.TestCase): loader = unittest.TestLoader() self.assertIs(loader.suiteClass, unittest.TestSuite) - - def test_partial_functions(self): - def noop(arg): - pass - - class Foo(unittest.TestCase): - pass - - setattr(Foo, 'test_partial', functools.partial(noop, None)) + # 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) - test_names = ['test_partial'] - self.assertEqual(loader.getTestCaseNames(Foo), test_names) - + ref_suite = unittest.TestSuite([MyTestCase('test')]) + self.assertEqual(list(suite), [ref_suite]) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() |