Viewing file: test_loader.py (20.1 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
# Copyright (c) 2008-2010 Twisted Matrix Laboratories. # See LICENSE for details.
""" Tests for loading tests by name. """
import os import shutil import sys
from twisted.python import util from twisted.python.hashlib import md5 from twisted.trial.test import packages from twisted.trial import runner, reporter, unittest from twisted.trial.itrial import ITestCase
from twisted.python.modules import getModule
def testNames(tests): """ Return the id of each test within the given test suite or case. """ names = [] for test in unittest._iterateTests(tests): names.append(test.id()) return names
class FinderTest(packages.PackageTest): def setUp(self): packages.PackageTest.setUp(self) self.loader = runner.TestLoader()
def tearDown(self): packages.PackageTest.tearDown(self)
def test_findPackage(self): sample1 = self.loader.findByName('twisted') import twisted as sample2 self.failUnlessEqual(sample1, sample2)
def test_findModule(self): sample1 = self.loader.findByName('twisted.trial.test.sample') import sample as sample2 self.failUnlessEqual(sample1, sample2)
def test_findFile(self): path = util.sibpath(__file__, 'sample.py') sample1 = self.loader.findByName(path) import sample as sample2 self.failUnlessEqual(sample1, sample2)
def test_findObject(self): sample1 = self.loader.findByName('twisted.trial.test.sample.FooTest') import sample self.failUnlessEqual(sample.FooTest, sample1)
def test_findNonModule(self): self.failUnlessRaises(AttributeError, self.loader.findByName, 'twisted.trial.test.nonexistent')
def test_findNonPackage(self): self.failUnlessRaises(ValueError, self.loader.findByName, 'nonextant')
def test_findNonFile(self): path = util.sibpath(__file__, 'nonexistent.py') self.failUnlessRaises(ValueError, self.loader.findByName, path)
class FileTest(packages.SysPathManglingTest): """ Tests for L{runner.filenameToModule}. """ def test_notFile(self): self.failUnlessRaises(ValueError, runner.filenameToModule, 'doesntexist')
def test_moduleInPath(self): sample1 = runner.filenameToModule(util.sibpath(__file__, 'sample.py')) import sample as sample2 self.failUnlessEqual(sample2, sample1)
def test_moduleNotInPath(self): """ If passed the path to a file containing the implementation of a module within a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the module defined by that file anyway. """ # "test_sample" isn't actually the name of this module. However, # filenameToModule can't seem to figure that out. So clean up this # mis-named module. It would be better if this weren't necessary # and filenameToModule either didn't exist or added a correctly # named module to sys.modules. self.addCleanup(sys.modules.pop, 'test_sample', None)
self.mangleSysPath(self.oldPath) sample1 = runner.filenameToModule( os.path.join(self.parent, 'goodpackage', 'test_sample.py')) self.mangleSysPath(self.newPath) from goodpackage import test_sample as sample2 self.failUnlessEqual(os.path.splitext(sample2.__file__)[0], os.path.splitext(sample1.__file__)[0])
def test_packageInPath(self): package1 = runner.filenameToModule(os.path.join(self.parent, 'goodpackage')) import goodpackage self.failUnlessEqual(goodpackage, package1)
def test_packageNotInPath(self): """ If passed the path to a directory which represents a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the package defined by that directory anyway. """ # "__init__" isn't actually the name of the package! However, # filenameToModule is pretty stupid and decides that is its name # after all. Make sure it gets cleaned up. See the comment in # test_moduleNotInPath for possible courses of action related to # this. self.addCleanup(sys.modules.pop, "__init__")
self.mangleSysPath(self.oldPath) package1 = runner.filenameToModule( os.path.join(self.parent, 'goodpackage')) self.mangleSysPath(self.newPath) import goodpackage self.failUnlessEqual(os.path.splitext(goodpackage.__file__)[0], os.path.splitext(package1.__file__)[0])
def test_directoryNotPackage(self): self.failUnlessRaises(ValueError, runner.filenameToModule, util.sibpath(__file__, 'directory'))
def test_filenameNotPython(self): self.failUnlessRaises(ValueError, runner.filenameToModule, util.sibpath(__file__, 'notpython.py'))
def test_filenameMatchesPackage(self): filename = os.path.join(self.parent, 'goodpackage.py') fd = open(filename, 'w') fd.write(packages.testModule) fd.close() try: module = runner.filenameToModule(filename) self.failUnlessEqual(filename, module.__file__) finally: os.remove(filename)
def test_directory(self): """ Test loader against a filesystem directory. It should handle 'path' and 'path/' the same way. """ path = util.sibpath(__file__, 'goodDirectory') os.mkdir(path) f = file(os.path.join(path, '__init__.py'), "w") f.close() try: module = runner.filenameToModule(path) self.assert_(module.__name__.endswith('goodDirectory')) module = runner.filenameToModule(path + os.path.sep) self.assert_(module.__name__.endswith('goodDirectory')) finally: shutil.rmtree(path)
class LoaderTest(packages.SysPathManglingTest):
def setUp(self): self.loader = runner.TestLoader() packages.SysPathManglingTest.setUp(self)
def test_sortCases(self): import sample suite = self.loader.loadClass(sample.AlphabetTest) self.failUnlessEqual(['test_a', 'test_b', 'test_c'], [test._testMethodName for test in suite._tests]) newOrder = ['test_b', 'test_c', 'test_a'] sortDict = dict(zip(newOrder, range(3))) self.loader.sorter = lambda x : sortDict.get(x.shortDescription(), -1) suite = self.loader.loadClass(sample.AlphabetTest) self.failUnlessEqual(newOrder, [test._testMethodName for test in suite._tests])
def test_loadMethod(self): import sample suite = self.loader.loadMethod(sample.FooTest.test_foo) self.failUnlessEqual(1, suite.countTestCases()) self.failUnlessEqual('test_foo', suite._testMethodName)
def test_loadFailingMethod(self): # test added for issue1353 import erroneous suite = self.loader.loadMethod(erroneous.TestRegularFail.test_fail) result = reporter.TestResult() suite.run(result) self.failUnlessEqual(result.testsRun, 1) self.failUnlessEqual(len(result.failures), 1)
def test_loadNonMethod(self): import sample self.failUnlessRaises(TypeError, self.loader.loadMethod, sample) self.failUnlessRaises(TypeError, self.loader.loadMethod, sample.FooTest) self.failUnlessRaises(TypeError, self.loader.loadMethod, "string") self.failUnlessRaises(TypeError, self.loader.loadMethod, ('foo', 'bar'))
def test_loadClass(self): import sample suite = self.loader.loadClass(sample.FooTest) self.failUnlessEqual(2, suite.countTestCases()) self.failUnlessEqual(['test_bar', 'test_foo'], [test._testMethodName for test in suite._tests])
def test_loadNonClass(self): import sample self.failUnlessRaises(TypeError, self.loader.loadClass, sample) self.failUnlessRaises(TypeError, self.loader.loadClass, sample.FooTest.test_foo) self.failUnlessRaises(TypeError, self.loader.loadClass, "string") self.failUnlessRaises(TypeError, self.loader.loadClass, ('foo', 'bar'))
def test_loadNonTestCase(self): import sample self.failUnlessRaises(ValueError, self.loader.loadClass, sample.NotATest)
def test_loadModule(self): import sample suite = self.loader.loadModule(sample) self.failUnlessEqual(7, suite.countTestCases())
def test_loadNonModule(self): import sample self.failUnlessRaises(TypeError, self.loader.loadModule, sample.FooTest) self.failUnlessRaises(TypeError, self.loader.loadModule, sample.FooTest.test_foo) self.failUnlessRaises(TypeError, self.loader.loadModule, "string") self.failUnlessRaises(TypeError, self.loader.loadModule, ('foo', 'bar'))
def test_loadPackage(self): import goodpackage suite = self.loader.loadPackage(goodpackage) self.failUnlessEqual(7, suite.countTestCases())
def test_loadNonPackage(self): import sample self.failUnlessRaises(TypeError, self.loader.loadPackage, sample.FooTest) self.failUnlessRaises(TypeError, self.loader.loadPackage, sample.FooTest.test_foo) self.failUnlessRaises(TypeError, self.loader.loadPackage, "string") self.failUnlessRaises(TypeError, self.loader.loadPackage, ('foo', 'bar'))
def test_loadModuleAsPackage(self): import sample ## XXX -- should this instead raise a ValueError? -- jml self.failUnlessRaises(TypeError, self.loader.loadPackage, sample)
def test_loadPackageRecursive(self): import goodpackage suite = self.loader.loadPackage(goodpackage, recurse=True) self.failUnlessEqual(14, suite.countTestCases())
def test_loadAnythingOnModule(self): import sample suite = self.loader.loadAnything(sample) self.failUnlessEqual(sample.__name__, suite._tests[0]._tests[0].__class__.__module__)
def test_loadAnythingOnClass(self): import sample suite = self.loader.loadAnything(sample.FooTest) self.failUnlessEqual(2, suite.countTestCases())
def test_loadAnythingOnMethod(self): import sample suite = self.loader.loadAnything(sample.FooTest.test_foo) self.failUnlessEqual(1, suite.countTestCases())
def test_loadAnythingOnPackage(self): import goodpackage suite = self.loader.loadAnything(goodpackage) self.failUnless(isinstance(suite, self.loader.suiteFactory)) self.failUnlessEqual(7, suite.countTestCases())
def test_loadAnythingOnPackageRecursive(self): import goodpackage suite = self.loader.loadAnything(goodpackage, recurse=True) self.failUnless(isinstance(suite, self.loader.suiteFactory)) self.failUnlessEqual(14, suite.countTestCases())
def test_loadAnythingOnString(self): # the important thing about this test is not the string-iness # but the non-handledness. self.failUnlessRaises(TypeError, self.loader.loadAnything, "goodpackage")
def test_importErrors(self): import package suite = self.loader.loadPackage(package, recurse=True) result = reporter.Reporter() suite.run(result) self.failUnlessEqual(False, result.wasSuccessful()) self.failUnlessEqual(2, len(result.errors)) errors = [test.id() for test, error in result.errors] errors.sort() self.failUnlessEqual(errors, ['package.test_bad_module', 'package.test_import_module'])
def test_differentInstances(self): """ L{TestLoader.loadClass} returns a suite with each test method represented by a different instances of the L{TestCase} they are defined on. """ class DistinctInstances(unittest.TestCase): def test_1(self): self.first = 'test1Run'
def test_2(self): self.assertFalse(hasattr(self, 'first'))
suite = self.loader.loadClass(DistinctInstances) result = reporter.Reporter() suite.run(result) self.assertTrue(result.wasSuccessful())
def test_loadModuleWith_test_suite(self): """ Check that C{test_suite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite suite = self.loader.loadModule(mockcustomsuite) self.failUnlessEqual(0, suite.countTestCases()) self.failUnlessEqual("MyCustomSuite", getattr(suite, 'name', None))
def test_loadModuleWith_testSuite(self): """ Check that C{testSuite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite2 suite = self.loader.loadModule(mockcustomsuite2) self.assertEqual(0, suite.countTestCases()) self.assertEqual("MyCustomSuite", getattr(suite, 'name', None))
def test_loadModuleWithBothCustom(self): """ Check that if C{testSuite} and C{test_suite} are both present in a module then C{testSuite} gets priority. """ from twisted.trial.test import mockcustomsuite3 suite = self.loader.loadModule(mockcustomsuite3) self.assertEqual('testSuite', getattr(suite, 'name', None))
def test_customLoadRaisesAttributeError(self): """ Make sure that any C{AttributeError}s raised by C{testSuite} are not swallowed by L{TestLoader}. """ def testSuite(): raise AttributeError('should be reraised') from twisted.trial.test import mockcustomsuite2 mockcustomsuite2.testSuite, original = (testSuite, mockcustomsuite2.testSuite) try: self.assertRaises(AttributeError, self.loader.loadModule, mockcustomsuite2) finally: mockcustomsuite2.testSuite = original
# XXX - duplicated and modified from test_script def assertSuitesEqual(self, test1, test2): names1 = testNames(test1) names2 = testNames(test2) names1.sort() names2.sort() self.assertEqual(names1, names2)
def test_loadByNamesDuplicate(self): """ Check that loadByNames ignores duplicate names """ module = 'twisted.trial.test.test_test_visitor' suite1 = self.loader.loadByNames([module, module], True) suite2 = self.loader.loadByName(module, True) self.assertSuitesEqual(suite1, suite2)
def test_loadDifferentNames(self): """ Check that loadByNames loads all the names that it is given """ modules = ['goodpackage', 'package.test_module'] suite1 = self.loader.loadByNames(modules) suite2 = runner.TestSuite(map(self.loader.loadByName, modules)) self.assertSuitesEqual(suite1, suite2)
class ZipLoadingTest(LoaderTest): def setUp(self): from twisted.test.test_paths import zipit LoaderTest.setUp(self) zipit(self.parent, self.parent+'.zip') self.parent += '.zip' self.mangleSysPath(self.oldPath+[self.parent])
class PackageOrderingTest(packages.SysPathManglingTest): if sys.version_info < (2, 4): skip = ( "Python 2.3 import semantics make this behavior incorrect on that " "version of Python as well as difficult to test. The second " "import of a package which raised an exception the first time it " "was imported will succeed on Python 2.3, whereas it will fail on " "later versions of Python. Trial does not account for this, so " "this test fails with inconsistencies between the expected and " "the received loader errors.")
def setUp(self): self.loader = runner.TestLoader() self.topDir = self.mktemp() parent = os.path.join(self.topDir, "uberpackage") os.makedirs(parent) file(os.path.join(parent, "__init__.py"), "wb").close() packages.SysPathManglingTest.setUp(self, parent) self.mangleSysPath(self.oldPath + [self.topDir])
def _trialSortAlgorithm(self, sorter): """ Right now, halfway by accident, trial sorts like this:
1. all modules are grouped together in one list and sorted.
2. within each module, the classes are grouped together in one list and sorted.
3. finally within each class, each test method is grouped together in a list and sorted.
This attempts to return a sorted list of testable thingies following those rules, so that we can compare the behavior of loadPackage.
The things that show as 'cases' are errors from modules which failed to import, and test methods. Let's gather all those together. """ pkg = getModule('uberpackage') testModules = [] for testModule in pkg.walkModules(): if testModule.name.split(".")[-1].startswith("test_"): testModules.append(testModule) sortedModules = sorted(testModules, key=sorter) # ONE for modinfo in sortedModules: # Now let's find all the classes. module = modinfo.load(None) if module is None: yield modinfo else: testClasses = [] for attrib in modinfo.iterAttributes(): if runner.isTestCase(attrib.load()): testClasses.append(attrib) sortedClasses = sorted(testClasses, key=sorter) # TWO for clsinfo in sortedClasses: testMethods = [] for attr in clsinfo.iterAttributes(): if attr.name.split(".")[-1].startswith('test'): testMethods.append(attr) sortedMethods = sorted(testMethods, key=sorter) # THREE for methinfo in sortedMethods: yield methinfo
def loadSortedPackages(self, sorter=runner.name): """ Verify that packages are loaded in the correct order. """ import uberpackage self.loader.sorter = sorter suite = self.loader.loadPackage(uberpackage, recurse=True) # XXX: Work around strange, unexplained Zope crap. # jml, 2007-11-15. suite = unittest.decorate(suite, ITestCase) resultingTests = list(unittest._iterateTests(suite)) manifest = list(self._trialSortAlgorithm(sorter)) for number, (manifestTest, actualTest) in enumerate( zip(manifest, resultingTests)): self.assertEqual( manifestTest.name, actualTest.id(), "#%d: %s != %s" % (number, manifestTest.name, actualTest.id())) self.assertEqual(len(manifest), len(resultingTests))
def test_sortPackagesDefaultOrder(self): self.loadSortedPackages()
def test_sortPackagesSillyOrder(self): def sillySorter(s): # This has to work on fully-qualified class names and class # objects, which is silly, but it's the "spec", such as it is. # if isinstance(s, type) or isinstance(s, types.ClassType): # return s.__module__+'.'+s.__name__ n = runner.name(s) d = md5(n).hexdigest() return d self.loadSortedPackages(sillySorter)
|