def test_Mqtt(self):
l_package = runner.TestLoader().loadPackage(I_test)
l_ret = reporter.Reporter(realtime=True)
l_package.run(l_ret)
l_ret.done()
#
print('\n====================\n*** test_Drivers ***\n{}\n'.format(l_ret))
def test_Scheduling(self):
l_package = runner.TestLoader().loadPackage(I_test)
l_ret = reporter.Reporter()
l_package.run(l_ret)
l_ret.done()
#
print('\n====================\n*** test_Scheduling ***\n{}\n'.format(l_ret))
def test_Internet(self):
l_package = runner.TestLoader().loadPackage(I_test)
l_ret = reporter.Reporter()
l_package.run(l_ret)
l_ret.done()
l_ret.printErrors()
#
print('\n====================\n*** test_Internet ***\n{}\n'.format(l_ret))
def getErrorFrames(self, test):
stream = StringIO.StringIO()
result = reporter.Reporter(stream)
test.run(result)
bads = result.failures + result.errors
assert len(bads) == 1
assert bads[0][0] == test
return result._trimFrames(bads[0][1].frames)
def test_patchRestoredAfterRun(self):
"""
Any monkey patches introduced by a test using C{patch()} are reverted
after the test has run.
"""
self.test.patch(self, 'objectToPatch', self.patchedValue)
self.test.run(reporter.Reporter())
self.assertEqual(self.objectToPatch, self.originalValue)
def test_errorByDefault(self):
"""
C{DirtyReactorAggregateError}s are reported as errors with the default
Reporter.
"""
result = reporter.Reporter(stream=self.output)
result.addError(self.test, self.dirtyError)
self.assertEqual(len(result.errors), 1)
self.assertEqual(result.errors[0][1], self.dirtyError)
def test_warningsEnabled(self):
"""
C{DirtyReactorErrors}s are reported as warnings when using the
L{UncleanWarningsReporterWrapper}.
"""
result = UncleanWarningsReporterWrapper(
reporter.Reporter(stream=self.output))
self.assertWarns(UserWarning, self.dirtyError.getErrorMessage(),
reporter.__file__, result.addError, self.test,
self.dirtyError)
def setUp(self):
try:
raise RuntimeError('foo')
except RuntimeError:
self.f = Failure()
self.f.frames = [[
'foo', 'foo/bar.py', 5, [('x', 5)], [('y', 'orange')]
], ['qux', 'foo/bar.py', 10, [('a', 'two')], [('b', 'MCMXCIX')]]]
self.stream = StringIO.StringIO()
self.result = reporter.Reporter(self.stream)
def test_successivePatches(self):
"""
Successive patches are applied and reverted just like a single patch.
"""
self.test.patch(self, 'objectToPatch', self.patchedValue)
self.assertEqual(self.objectToPatch, self.patchedValue)
self.test.patch(self, 'objectToPatch', 'second value')
self.assertEqual(self.objectToPatch, 'second value')
self.test.run(reporter.Reporter())
self.assertEqual(self.objectToPatch, self.originalValue)
def test_warningsMaskErrors(self):
"""
C{DirtyReactorErrors}s are I{not} reported as errors if the
L{UncleanWarningsReporterWrapper} is used.
"""
result = UncleanWarningsReporterWrapper(
reporter.Reporter(stream=self.output))
self.assertWarns(UserWarning, self.dirtyError.getErrorMessage(),
reporter.__file__, result.addError, self.test,
self.dirtyError)
self.assertEquals(result._originalReporter.errors, [])
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_importErrors(self):
import package # type: ignore[import]
suite = self.loader.loadPackage(package, recurse=True)
result = reporter.Reporter()
suite.run(result)
self.assertEqual(False, result.wasSuccessful())
self.assertEqual(2, len(result.errors))
errors = [test.id() for test, error in result.errors]
errors.sort()
self.assertEqual(
errors, ["package.test_bad_module", "package.test_import_module"])
def test_dealsWithThreeTuples(self):
"""
Some annoying stuff can pass three-tuples to addError instead of
Failures (like PyUnit). The wrapper, of course, handles this case,
since it is a part of L{twisted.trial.itrial.IReporter}! But it does
not convert L{DirtyReactorError} to warnings in this case, because
nobody should be passing those in the form of three-tuples.
"""
result = UncleanWarningsReporterWrapper(
reporter.Reporter(stream=self.output))
result.addError(self.test,
(self.dirtyError.type, self.dirtyError.value, None))
self.assertEqual(len(result._originalReporter.errors), 1)
self.assertEquals(result._originalReporter.errors[0][1].type,
self.dirtyError.type)
self.assertEquals(result._originalReporter.errors[0][1].value,
self.dirtyError.value)
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(pyunit.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 setUp(self):
self.loader = runner.TestLoader()
self.output = StringIO.StringIO()
self.result = UncleanWarningsReporterWrapper(
reporter.Reporter(self.output))
def setUp(self):
self.reporter = reporter.Reporter()
self.loader = runner.TestLoader()
def setUp(self):
self.result = reporter.Reporter(StringIO.StringIO())
self.loader = runner.TestLoader()
def test_noFrames(self):
result = reporter.Reporter(None)
self.assertEqual([], result._trimFrames([]))
def test_oneFrame(self):
result = reporter.Reporter(None)
self.assertEqual(['fake frame'], result._trimFrames(['fake frame']))
def setUp(self):
self.reporter = reporter.Reporter()
self.loader = pyunit.TestLoader()
def setUp(self):
"""
Setup our test case
"""
self.result = reporter.Reporter(NativeStringIO())
self.loader = runner.TestLoader()
def setUp(self):
from twisted.trial.test import sample
self.stream = StringIO.StringIO()
self.result = reporter.Reporter(self.stream)
self.test = sample.FooTest('test_foo')
def setUp(self):
output = StringIO.StringIO()
self.result = reporter.Reporter(output, realtime=True)
def setUp(self):
"""
Setup our test case
"""
self.reporter = reporter.Reporter()
self.loader = pyunit.TestLoader()
def runTests(self, suite):
output = StringIO.StringIO()
result = reporter.Reporter(output)
suite.run(result)
result.printErrors()
return output.getvalue()
