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()