# -*- Python -*-
# Twisted, the Framework of Your Internet
# Copyright (C) 2001 Matthew W. Lefkowitz
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser General Public
# License as published by the Free Software Foundation.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from __future__ import nested_scopes
__version__ = "$Revision: 1.16 $"[11:-2]
from twisted.python import reflect
from twisted.trial import unittest, reporter, util, runner
from StringIO import StringIO
import sys
import os
class TestTraceback(unittest.TestCase):
def testExtractTB(self):
"""Making sure unittest doesn't show up in traceback."""
suite = unittest.TestSuite()
testCase = self.FailingTest()
result = unittest.Tester(testCase.__class__, testCase,
testCase.testThatWillFail,
runner.runTest).run()
failType, (eType, eVal, tb) = result
stackList = util.extract_tb(tb)
self.failUnlessEqual(len(stackList), 1)
self.failUnlessEqual(stackList[0][2], 'testThatWillFail')
# Hidden in here so the failing test doesn't get sucked into the bigsuite.
class FailingTest(unittest.TestCase):
def testThatWillFail(self):
self.fail("Broken by design.")
###################
# trial.remote
from twisted.protocols import loopback
from twisted.trial import remote
from twisted.spread import banana, jelly
_negotiate = '\x01\x80\x04\x82none'
_encStart = '\x03\x80\x05\x82tuple\x05\x82start\x02\x80\x05\x82tuple\x01\x81'
class RemoteReporter:
expectedTests = None
def __init__(self):
self.errors = []
self.importErrors = []
def remote_start(self, expectedTests, times=None):
self.expectedTests = expectedTests
def remote_reportResults(self, testClass, methodName, resultType,
results, times=None):
assert resultType == reporter.ERROR
if resultType == reporter.ERROR:
self.errors.append((testClass, methodName, results))
def remote_reportImportError(self, name, failure, times=None):
self.importErrors.append((name, failure))
class OneShotDecoder(remote.DecodeReport):
def expressionReceived(self, lst):
remote.DecodeReport.expressionReceived(self, lst)
self.transport.loseConnection()
class JellyReporterWithHook(remote.JellyReporter):
def makeConnection(self, transport):
remote.JellyReporter.makeConnection(self, transport)
self._runHook()
class TestJellyReporter(unittest.TestCase):
def setUp(self):
self.stream = StringIO()
self.reporter = remote.JellyReporter(self.stream)
self.reporter.doSendTimes = False
def testStart(self):
self.reporter.start(1)
self.failUnlessEqual(_negotiate + _encStart, self.stream.getvalue())
def testError(self):
try:
monkey / 0
except Exception:
self.reporter.reportResults("aTestClass", "aMethod",
reporter.ERROR,
sys.exc_info())
class TestRemoteReporter(unittest.TestCase):
def setUp(self):
self.reporter = RemoteReporter()
self.decoder = remote.DecodeReport(self.reporter)
self.decoder.dataReceived(_negotiate)
def testStart(self):
self.decoder.dataReceived(_encStart)
self.failUnlessEqual(self.reporter.expectedTests, 1)
class LoopbackTests(unittest.TestCase):
def setUp(self):
self.sendReporter = JellyReporterWithHook()
self.reporter = RemoteReporter()
self.decoder = OneShotDecoder(self.reporter)
def testStart(self):
self.sendReporter._runHook = lambda : self.sendReporter.start(1)
loopback.loopback(self.sendReporter, self.decoder)
self.failUnlessEqual(self.reporter.expectedTests, 1)
def testError(self):
try:
monkey / 0
except Exception:
self.sendReporter._runHook = lambda : (
self.sendReporter.reportResults("aTestClass", "aMethod",
reporter.ERROR,
sys.exc_info()))
loopback.loopback(self.sendReporter, self.decoder)
self.failUnlessEqual(len(self.reporter.errors), 1)
self.failUnlessEqual(self.reporter.errors[0][:2], ("aTestClass",
"aMethod"))
f = self.reporter.errors[0][-1]
self.failUnlessEqual(f.type, reflect.qual(NameError))
def testImportError(self):
try:
import nosuchmoduleasthis
except ImportError, exc:
self.sendReporter._runHook = lambda : (
self.sendReporter.reportImportError("nosuchmoduleasthis", exc))
loopback.loopback(self.sendReporter, self.decoder)
self.failUnlessEqual(len(self.reporter.importErrors), 1)
f = self.reporter.importErrors[0][-1]
self.failUnlessEqual(self.reporter.importErrors[0][0],
"nosuchmoduleasthis")
self.failUnlessEqual(f.type, ImportError)
class TestTests(unittest.TestCase):
# first, the things we're going to test
class Tests(unittest.TestCase):
def __init__(self):
self.setupRun = 0
self.teardownRun = 0
def setUp(self):
self.setupRun += 1
def tearDown(self):
self.teardownRun += 1
def testSuccess_pass(self):
pass
def testFail_fail(self):
self.fail("failed")
def testFailIf_pass(self):
self.failIf(0, "failed")
def testFailIf_fail(self):
self.failIf(1, "failed")
def testFailUnless_pass(self):
self.failUnless(1, "failed")
def testFailUnless_fail(self):
self.failUnless(0, "failed")
def testFailUnlessRaises_pass(self):
def boom():
raise ValueError
self.failUnlessRaises(ValueError, boom)
def testFailUnlessRaises1_fail(self):
def boom():
raise IndexError
self.failUnlessRaises(ValueError, boom)
def testFailUnlessRaises2_fail(self):
def boom():
pass
self.failUnlessRaises(ValueError, boom)
def testFailUnlessEqual_pass(self):
self.failUnlessEqual(1, 1, "failed")
def testFailUnlessEqual_fail(self):
self.failUnlessEqual(1, 2, "failed")
def testFailIfEqual_fail(self):
self.failIfEqual(1, 1, "failed")
def testFailIfEqual_pass(self):
self.failIfEqual(1, 2, "failed")
def testFailUnlessIdentical_pass(self):
a = [1,2]
b = a
self.failUnlessIdentical(a, b, "failed")
def testFailUnlessIdentical1_fail(self):
a = [1,2]
b = [1,2]
self.failUnlessIdentical(a, b, "failed")
def testFailUnlessIdentical2_fail(self):
a = [1,2]
b = [3,4]
self.failUnlessIdentical(a, b, "failed")
def testApproximates1_pass(self):
a = 1.0
b = 1.2
self.assertApproximates(a, b, .3, "failed")
def testApproximates2_pass(self):
a = 1.0
b = 1.2
self.assertApproximates(b, a, .3, "failed")
def testApproximates3_fail(self):
a = 1.0
b = 1.2
self.assertApproximates(a, b, .1, "failed")
def testApproximates4_fail(self):
a = 1.0
b = 1.2
self.assertApproximates(b, a, .1, "failed")
def testSkip1_skip(self):
raise unittest.SkipTest("skip me")
def testSkip2_skip(self):
pass
testSkip2_skip.skip = "skip me"
def testTodo1_exfail(self):
self.fail("deliberate failure")
testTodo1_exfail.todo = "expected to fail"
def testTodo2_exfail(self):
raise ValueError
testTodo2_exfail.todo = "expected to fail"
def testTodo3_unexpass(self):
pass # unexpected success
testTodo3_unexpass.todo = "expected to fail"
def checkResults(self, rep, method):
self.failIf(rep.imports, "%s caused import error" % method)
self.failUnless(rep.numTests == 1,
"%s had multiple tests" % method)
if method[-5:] == "_pass":
self.failIf(rep.errors)
self.failIf(rep.failures)
self.failIf(rep.skips)
self.failIf(rep.expectedFailures)
self.failIf(rep.unexpectedSuccesses)
if method[-5:] == "_fail":
self.failIf(rep.errors)
self.failUnless(len(rep.failures) == 1,
"%s had %d failures" % (method,
len(rep.failures)))
self.failIf(rep.skips)
self.failIf(rep.expectedFailures)
self.failIf(rep.unexpectedSuccesses)
if method[-6:] == "_error":
self.failUnless(len(rep.errors) == 1,
"%s had %d errors" % (method,
len(rep.errors)))
self.failIf(rep.failures)
self.failIf(rep.skips)
self.failIf(rep.expectedFailures)
self.failIf(rep.unexpectedSuccesses)
if method[-5:] == "_skip":
self.failIf(rep.errors)
self.failIf(rep.failures)
self.failUnless(len(rep.skips) == 1,
"%s had %d skips" % (method,
len(rep.skips)))
self.failIf(rep.expectedFailures)
self.failIf(rep.unexpectedSuccesses)
if method[-7:] == "_exfail":
self.failIf(rep.errors)
self.failIf(rep.failures)
self.failIf(rep.skips)
self.failUnless(len(rep.expectedFailures) == 1,
"%s had %d expectedFailures" % \
(method, len(rep.expectedFailures)))
self.failIf(rep.unexpectedSuccesses)
if method[-9:] == "_unexpass":
self.failIf(rep.errors)
self.failIf(rep.failures)
self.failIf(rep.skips)
self.failIf(rep.expectedFailures)
self.failUnless(len(rep.unexpectedSuccesses) == 1,
"%s had %d unexpectedSuccesses" % \
(method, len(rep.unexpectedSuccesses)))
def testTests(self):
suite = unittest.TestSuite()
suffixes = reflect.prefixedMethodNames(TestTests.Tests, "test")
for suffix in suffixes:
method = "test" + suffix
testCase = self.Tests()
# if one of these test cases fails, switch to TextReporter to
# see what happened
rep = reporter.Reporter()
#reporter = reporter.TextReporter()
#print "running '%s'" % method
rep.start(1)
result = unittest.Tester(testCase.__class__, testCase,
getattr(testCase, method),
lambda x: x()).run()
rep.reportResults(testCase.__class__, getattr(self.Tests, method),
*result)
# TODO: verify that case.setUp == 1 and case.tearDown == 1
try:
self.checkResults(rep, method)
except unittest.FailTest:
# with TextReporter, this will show the traceback
print
print "problem in method '%s'" % method
reporter.stop()
raise
class UtilityTestCase(unittest.TestCase):
def testMktmp(self):
tmp = self.mktemp()
tmp1 = self.mktemp()
exp = os.path.join('twisted.test.test_trial', 'UtilityTestCase', 'testMktmp')
self.failIfEqual(tmp, tmp1)
self.failUnless(os.path.exists(exp))
self.failUnless(os.path.isdir(exp))
syntax highlighted by Code2HTML, v. 0.9.1