import md5 import os from twisted.python import util from twisted.trial.test import packages from twisted.trial import runner, reporter, unittest from twisted.python.modules import getModule # XXX - this is used in test_script, perhaps it should be in a utility module def testNames(test): """ Return the id of each test within the given test suite or case. """ testIDs = [] def visit(test): testIDs.append(test.id()) test.visit(visit) return testIDs 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): 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): 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): 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) 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 from twisted.trial import reporter 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_loadWithoutForcedGarbageCollection(self): """ Tests loaded by default should not be set to force garbage collection. This test checks 'loadMethod'. """ import sample test = self.loader.loadMethod(sample.FooTest.test_foo) self.assertEqual(test.forceGarbageCollection, False) def test_loadWithForcedGarbageCollection(self): """ If the loader is set to force garbage collection, any tests it loads should also be set to force garbage collection. This test checks 'loadMethod'. """ import sample self.loader.forceGarbageCollection = True test = self.loader.loadMethod(sample.FooTest.test_foo) self.assertEqual(test.forceGarbageCollection, True) def test_loadWithoutForcedGarbageCollectionClass(self): """ Tests loaded by default should not be set to force garbage collection. This test checks 'loadClass'. """ import sample suite = self.loader.loadClass(sample.FooTest) def visitor(case): self.assertEqual(case.forceGarbageCollection, False) suite.visit(visitor) def test_loadWithForcedGarbageCollectionClass(self): """ If the loader is set to force garbage collection, any tests it loads should also be set to force garbage collection. This test checks 'loadClass'. """ import sample self.loader.forceGarbageCollection = True suite = self.loader.loadClass(sample.FooTest) def visitor(case): self.assertEqual(case.forceGarbageCollection, True) suite.visit(visitor) 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_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): loader = runner.TestLoader() 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): def setUp(self): self.resultingTests = [] 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 visitCase(self, case): self.resultingTests.append(case) 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 = util.dsu(testModules, 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 = util.dsu(testClasses, sorter) # TWO for clsinfo in sortedClasses: testMethods = [] for attr in clsinfo.iterAttributes(): if attr.name.split(".")[-1].startswith('test'): testMethods.append(attr) sortedMethods = util.dsu(testMethods, 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) suite.visit(self.visitCase) manifest = list(self._trialSortAlgorithm(sorter)) for number, (manifestTest, actualTest) in enumerate( zip(manifest, self.resultingTests)): self.assertEqual( manifestTest.name, actualTest.id(), "#%d: %s != %s" % (number, manifestTest.name, actualTest.id())) self.assertEqual(len(manifest), len(self.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.new(n).hexdigest() return d self.loadSortedPackages(sillySorter)