twisted/trial/test/test_log.py

   1 # Copyright (c) Twisted Matrix Laboratories.
   2 # See LICENSE for details.
   3
   4 """
   5 Test the interaction between trial and errors logged during test run.
   6 """
   7
   8 import time
   9
  10 from twisted.internet import reactor, task
  11 from twisted.python import failure, log
  12 from twisted.trial import unittest, reporter
  13
  14
  15 def makeFailure():
  16     """
  17     Return a new, realistic failure.
  18     """
  19     try:
  20         1/0
  21     except ZeroDivisionError:
  22         f = failure.Failure()
  23     return f
  24
  25
  26 class Mask(object):
  27     """
  28     Hide C{MockTest}s from Trial's automatic test finder.
  29     """
  30
  31     class MockTest(unittest.TestCase):
  32         def test_silent(self):
  33             """
  34             Don't log any errors.
  35             """
  36
  37         def test_single(self):
  38             """
  39             Log a single error.
  40             """
  41             log.err(makeFailure())
  42
  43         def test_double(self):
  44             """
  45             Log two errors.
  46             """
  47             log.err(makeFailure())
  48             log.err(makeFailure())
  49
  50         def test_inCallback(self):
  51             """
  52             Log an error in an asynchronous callback.
  53             """
  54             return task.deferLater(reactor, 0, lambda: log.err(makeFailure()))
  55
  56
  57 class TestObserver(unittest.TestCase):
  58     """
  59     Tests for L{unittest._LogObserver}, a helper for the implementation of
  60     L{TestCase.flushLoggedErrors}.
  61     """
  62     def setUp(self):
  63         self.result = reporter.TestResult()
  64         self.observer = unittest._LogObserver()
  65
  66
  67     def test_msg(self):
  68         """
  69         Test that a standard log message doesn't go anywhere near the result.
  70         """
  71         self.observer.gotEvent({'message': ('some message',),
  72                                 'time': time.time(), 'isError': 0,
  73                                 'system': '-'})
  74         self.assertEqual(self.observer.getErrors(), [])
  75
  76
  77     def test_error(self):
  78         """
  79         Test that an observed error gets added to the result
  80         """
  81         f = makeFailure()
  82         self.observer.gotEvent({'message': (),
  83                                 'time': time.time(), 'isError': 1,
  84                                 'system': '-', 'failure': f,
  85                                 'why': None})
  86         self.assertEqual(self.observer.getErrors(), [f])
  87
  88
  89     def test_flush(self):
  90         """
  91         Check that flushing the observer with no args removes all errors.
  92         """
  93         self.test_error()
  94         flushed = self.observer.flushErrors()
  95         self.assertEqual(self.observer.getErrors(), [])
  96         self.assertEqual(len(flushed), 1)
  97         self.assertTrue(flushed[0].check(ZeroDivisionError))
  98
  99
 100     def _makeRuntimeFailure(self):
 101         return failure.Failure(RuntimeError('test error'))
 102
 103
 104     def test_flushByType(self):
 105         """
 106         Check that flushing the observer remove all failures of the given type.
 107         """
 108         self.test_error() # log a ZeroDivisionError to the observer
 109         f = self._makeRuntimeFailure()
 110         self.observer.gotEvent(dict(message=(), time=time.time(), isError=1,
 111                                     system='-', failure=f, why=None))
 112         flushed = self.observer.flushErrors(ZeroDivisionError)
 113         self.assertEqual(self.observer.getErrors(), [f])
 114         self.assertEqual(len(flushed), 1)
 115         self.assertTrue(flushed[0].check(ZeroDivisionError))
 116
 117
 118     def test_ignoreErrors(self):
 119         """
 120         Check that C{_ignoreErrors} actually causes errors to be ignored.
 121         """
 122         self.observer._ignoreErrors(ZeroDivisionError)
 123         f = makeFailure()
 124         self.observer.gotEvent({'message': (),
 125                                 'time': time.time(), 'isError': 1,
 126                                 'system': '-', 'failure': f,
 127                                 'why': None})
 128         self.assertEqual(self.observer.getErrors(), [])
 129
 130
 131     def test_clearIgnores(self):
 132         """
 133         Check that C{_clearIgnores} ensures that previously ignored errors
 134         get captured.
 135         """
 136         self.observer._ignoreErrors(ZeroDivisionError)
 137         self.observer._clearIgnores()
 138         f = makeFailure()
 139         self.observer.gotEvent({'message': (),
 140                                 'time': time.time(), 'isError': 1,
 141                                 'system': '-', 'failure': f,
 142                                 'why': None})
 143         self.assertEqual(self.observer.getErrors(), [f])
 144
 145
 146
 147 class LogErrors(unittest.TestCase):
 148     """
 149     High-level tests demonstrating the expected behaviour of logged errors
 150     during tests.
 151     """
 152
 153     def setUp(self):
 154         self.result = reporter.TestResult()
 155
 156     def tearDown(self):
 157         self.flushLoggedErrors(ZeroDivisionError)
 158
 159     def test_singleError(self):
 160         """
 161         Test that a logged error gets reported as a test error.
 162         """
 163         test = Mask.MockTest('test_single')
 164         test(self.result)
 165         self.assertEqual(len(self.result.errors), 1)
 166         self.assertTrue(self.result.errors[0][1].check(ZeroDivisionError),
 167                         self.result.errors[0][1])
 168
 169     def test_twoErrors(self):
 170         """
 171         Test that when two errors get logged, they both get reported as test
 172         errors.
 173         """
 174         test = Mask.MockTest('test_double')
 175         test(self.result)
 176         self.assertEqual(len(self.result.errors), 2)
 177
 178     def test_inCallback(self):
 179         """
 180         Test that errors logged in callbacks get reported as test errors.
 181         """
 182         test = Mask.MockTest('test_inCallback')
 183         test(self.result)
 184         self.assertEqual(len(self.result.errors), 1)
 185         self.assertTrue(self.result.errors[0][1].check(ZeroDivisionError),
 186                         self.result.errors[0][1])
 187
 188     def test_errorsIsolated(self):
 189         """
 190         Check that an error logged in one test doesn't fail the next test.
 191         """
 192         t1 = Mask.MockTest('test_single')
 193         t2 = Mask.MockTest('test_silent')
 194         t1(self.result)
 195         t2(self.result)
 196         self.assertEqual(len(self.result.errors), 1)
 197         self.assertEqual(self.result.errors[0][0], t1)