import sys | |
import types | |
import unittest | |
class Test_TestLoader(unittest.TestCase): | |
### Tests for TestLoader.loadTestsFromTestCase | |
################################################################ | |
# "Return a suite of all tests 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 tests 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 tests 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 tests 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. | |
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]) | |
load_tests_args = [] | |
suite = loader.loadTestsFromModule(m, use_load_tests=False) | |
self.assertEqual(load_tests_args, []) | |
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) | |
test = list(suite)[0] | |
self.assertRaisesRegexp(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, 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() | |
# 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" | |
# | |
# What happens when a module by that name can't be found? | |
def test_loadTestsFromName__unknown_module_name(self): | |
loader = unittest.TestLoader() | |
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 can't? | |
def test_loadTestsFromName__unknown_attr_name(self): | |
loader = unittest.TestLoader() | |
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 | |
# 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() | |
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 | |
# 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() | |
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 | |
# 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? | |
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" | |
# | |
# Does loadTestsFromName raise TypeError when the `module` argument | |
# isn't a module object? | |
# | |
# XXX Accepts the not-a-module object, ignorning 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() | |
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" | |
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: | |
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() | |
################################################################ | |
# "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, 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? | |
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 | |
# 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() | |
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 | |
# 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() | |
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 | |
# 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() | |
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 | |
# 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() | |
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 | |
# 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() | |
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 | |
# 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? | |
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" | |
# | |
# 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]) | |
# "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() | |
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" | |
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: | |
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.assertTrue(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 -cmp(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 -cmp(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 -cmp(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 -cmp(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 -cmp(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" | |
def test_sortTestMethodsUsing__default_value(self): | |
loader = unittest.TestLoader() | |
self.assertTrue(loader.sortTestMethodsUsing is cmp) | |
# "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.assertTrue(loader.suiteClass is unittest.TestSuite) | |
if __name__ == '__main__': | |
unittest.main() |