# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.python.log}. """ from __future__ import division, absolute_import, print_function from twisted.python.compat import _PY3, NativeStringIO as StringIO import os, sys, time, logging, warnings, calendar from twisted.trial import unittest from twisted.python import log, failure class FakeWarning(Warning): """ A unique L{Warning} subclass used by tests for interactions of L{twisted.python.log} with the L{warnings} module. """ class LogTest(unittest.SynchronousTestCase): def setUp(self): self.catcher = [] self.observer = self.catcher.append log.addObserver(self.observer) self.addCleanup(log.removeObserver, self.observer) def testObservation(self): catcher = self.catcher log.msg("test", testShouldCatch=True) i = catcher.pop() self.assertEqual(i["message"][0], "test") self.assertEqual(i["testShouldCatch"], True) self.assertIn("time", i) self.assertEqual(len(catcher), 0) def testContext(self): catcher = self.catcher log.callWithContext({"subsystem": "not the default", "subsubsystem": "a", "other": "c"}, log.callWithContext, {"subsubsystem": "b"}, log.msg, "foo", other="d") i = catcher.pop() self.assertEqual(i['subsubsystem'], 'b') self.assertEqual(i['subsystem'], 'not the default') self.assertEqual(i['other'], 'd') self.assertEqual(i['message'][0], 'foo') def testErrors(self): for e, ig in [("hello world","hello world"), (KeyError(), KeyError), (failure.Failure(RuntimeError()), RuntimeError)]: log.err(e) i = self.catcher.pop() self.assertEqual(i['isError'], 1) self.flushLoggedErrors(ig) def testErrorsWithWhy(self): for e, ig in [("hello world","hello world"), (KeyError(), KeyError), (failure.Failure(RuntimeError()), RuntimeError)]: log.err(e, 'foobar') i = self.catcher.pop() self.assertEqual(i['isError'], 1) self.assertEqual(i['why'], 'foobar') self.flushLoggedErrors(ig) def test_erroneousErrors(self): """ Exceptions raised by log observers are logged but the observer which raised the exception remains registered with the publisher. These exceptions do not prevent the event from being sent to other observers registered with the publisher. """ L1 = [] L2 = [] def broken(events): 1 // 0 for observer in [L1.append, broken, L2.append]: log.addObserver(observer) self.addCleanup(log.removeObserver, observer) for i in range(3): # Reset the lists for simpler comparison. L1[:] = [] L2[:] = [] # Send out the event which will break one of the observers. log.msg("Howdy, y'all.") # The broken observer should have caused this to be logged. excs = self.flushLoggedErrors(ZeroDivisionError) del self.catcher[:] self.assertEqual(len(excs), 1) # Both other observers should have seen the message. self.assertEqual(len(L1), 2) self.assertEqual(len(L2), 2) # The order is slightly wrong here. The first event should be # delivered to all observers; then, errors should be delivered. self.assertEqual(L1[1]['message'], ("Howdy, y'all.",)) self.assertEqual(L2[0]['message'], ("Howdy, y'all.",)) def test_doubleErrorDoesNotRemoveObserver(self): """ If logging causes an error, make sure that if logging the fact that logging failed also causes an error, the log observer is not removed. """ events = [] errors = [] publisher = log.LogPublisher() class FailingObserver(object): calls = 0 def log(self, msg, **kwargs): # First call raises RuntimeError: self.calls += 1 if self.calls < 2: raise RuntimeError("Failure #%s" % (self.calls,)) else: events.append(msg) observer = FailingObserver() publisher.addObserver(observer.log) self.assertEqual(publisher.observers, [observer.log]) try: # When observer throws, the publisher attempts to log the fact by # calling self._err()... which also fails with recursion error: oldError = publisher._err def failingErr(failure, why, **kwargs): errors.append(failure.value) raise RuntimeError("Fake recursion error") publisher._err = failingErr publisher.msg("error in first observer") finally: publisher._err = oldError # Observer should still exist; we do this in finally since before # bug was fixed the test would fail due to uncaught exception, so # we want failing assert too in that case: self.assertEqual(publisher.observers, [observer.log]) # The next message should succeed: publisher.msg("but this should succeed") self.assertEqual(observer.calls, 2) self.assertEqual(len(events), 1) self.assertEqual(events[0]['message'], ("but this should succeed",)) self.assertEqual(len(errors), 1) self.assertIsInstance(errors[0], RuntimeError) def test_showwarning(self): """ L{twisted.python.log.showwarning} emits the warning as a message to the Twisted logging system. """ publisher = log.LogPublisher() publisher.addObserver(self.observer) publisher.showwarning( FakeWarning("unique warning message"), FakeWarning, "warning-filename.py", 27) event = self.catcher.pop() self.assertEqual( event['format'] % event, 'warning-filename.py:27: twisted.test.test_log.FakeWarning: ' 'unique warning message') self.assertEqual(self.catcher, []) # Python 2.6 requires that any function used to override the # warnings.showwarning API accept a "line" parameter or a # deprecation warning is emitted. publisher.showwarning( FakeWarning("unique warning message"), FakeWarning, "warning-filename.py", 27, line=object()) event = self.catcher.pop() self.assertEqual( event['format'] % event, 'warning-filename.py:27: twisted.test.test_log.FakeWarning: ' 'unique warning message') self.assertEqual(self.catcher, []) def test_warningToFile(self): """ L{twisted.python.log.showwarning} passes warnings with an explicit file target on to the underlying Python warning system. """ # log.showwarning depends on _oldshowwarning being set, which only # happens in startLogging(), which doesn't happen if you're not # running under trial. So this test only passes by accident of runner # environment. if log._oldshowwarning is None: raise unittest.SkipTest("Currently this test only runs under trial.") message = "another unique message" category = FakeWarning filename = "warning-filename.py" lineno = 31 output = StringIO() log.showwarning(message, category, filename, lineno, file=output) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno)) # In Python 2.6, warnings.showwarning accepts a "line" argument which # gives the source line the warning message is to include. if sys.version_info >= (2, 6): line = "hello world" output = StringIO() log.showwarning(message, category, filename, lineno, file=output, line=line) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno, line)) def test_publisherReportsBrokenObserversPrivately(self): """ Log publisher does not use the global L{log.err} when reporting broken observers. """ errors = [] def logError(eventDict): if eventDict.get("isError"): errors.append(eventDict["failure"].value) def fail(eventDict): raise RuntimeError("test_publisherLocalyReportsBrokenObservers") publisher = log.LogPublisher() publisher.addObserver(logError) publisher.addObserver(fail) publisher.msg("Hello!") self.assertEqual(publisher.observers, [logError, fail]) self.assertEqual(len(errors), 1) self.assertIsInstance(errors[0], RuntimeError) class FakeFile(list): def write(self, bytes): self.append(bytes) def flush(self): pass class EvilStr: def __str__(self): 1//0 class EvilRepr: def __str__(self): return "Happy Evil Repr" def __repr__(self): 1//0 class EvilReprStr(EvilStr, EvilRepr): pass class LogPublisherTestCaseMixin: def setUp(self): """ Add a log observer which records log events in C{self.out}. Also, make sure the default string encoding is ASCII so that L{testSingleUnicode} can test the behavior of logging unencodable unicode messages. """ self.out = FakeFile() self.lp = log.LogPublisher() self.flo = log.FileLogObserver(self.out) self.lp.addObserver(self.flo.emit) try: str(u'\N{VULGAR FRACTION ONE HALF}') except UnicodeEncodeError: # This is the behavior we want - don't change anything. self._origEncoding = None else: if _PY3: self._origEncoding = None return reload(sys) self._origEncoding = sys.getdefaultencoding() sys.setdefaultencoding('ascii') def tearDown(self): """ Verify that everything written to the fake file C{self.out} was a C{str}. Also, restore the default string encoding to its previous setting, if it was modified by L{setUp}. """ for chunk in self.out: self.failUnless(isinstance(chunk, str), "%r was not a string" % (chunk,)) if self._origEncoding is not None: sys.setdefaultencoding(self._origEncoding) del sys.setdefaultencoding class LogPublisherTestCase(LogPublisherTestCaseMixin, unittest.SynchronousTestCase): def testSingleString(self): self.lp.msg("Hello, world.") self.assertEqual(len(self.out), 1) def testMultipleString(self): # Test some stupid behavior that will be deprecated real soon. # If you are reading this and trying to learn how the logging # system works, *do not use this feature*. self.lp.msg("Hello, ", "world.") self.assertEqual(len(self.out), 1) def test_singleUnicode(self): """ L{log.LogPublisher.msg} does not accept non-ASCII Unicode on Python 2, logging an error instead. On Python 3, where Unicode is default message type, the message is logged normally. """ message = u"Hello, \N{VULGAR FRACTION ONE HALF} world." self.lp.msg(message) self.assertEqual(len(self.out), 1) if _PY3: self.assertIn(message, self.out[0]) else: self.assertIn('with str error', self.out[0]) self.assertIn('UnicodeEncodeError', self.out[0]) class FileObserverTestCase(LogPublisherTestCaseMixin, unittest.SynchronousTestCase): """ Tests for L{log.FileObserver}. """ def test_getTimezoneOffset(self): """ Attempt to verify that L{FileLogObserver.getTimezoneOffset} returns correct values for the current C{TZ} environment setting. Do this by setting C{TZ} to various well-known values and asserting that the reported offset is correct. """ localDaylightTuple = (2006, 6, 30, 0, 0, 0, 4, 181, 1) utcDaylightTimestamp = time.mktime(localDaylightTuple) localStandardTuple = (2007, 1, 31, 0, 0, 0, 2, 31, 0) utcStandardTimestamp = time.mktime(localStandardTuple) originalTimezone = os.environ.get('TZ', None) try: # Test something west of UTC os.environ['TZ'] = 'America/New_York' time.tzset() self.assertEqual( self.flo.getTimezoneOffset(utcDaylightTimestamp), 14400) self.assertEqual( self.flo.getTimezoneOffset(utcStandardTimestamp), 18000) # Test something east of UTC os.environ['TZ'] = 'Europe/Berlin' time.tzset() self.assertEqual( self.flo.getTimezoneOffset(utcDaylightTimestamp), -7200) self.assertEqual( self.flo.getTimezoneOffset(utcStandardTimestamp), -3600) # Test a timezone that doesn't have DST os.environ['TZ'] = 'Africa/Johannesburg' time.tzset() self.assertEqual( self.flo.getTimezoneOffset(utcDaylightTimestamp), -7200) self.assertEqual( self.flo.getTimezoneOffset(utcStandardTimestamp), -7200) finally: if originalTimezone is None: del os.environ['TZ'] else: os.environ['TZ'] = originalTimezone time.tzset() if getattr(time, 'tzset', None) is None: test_getTimezoneOffset.skip = ( "Platform cannot change timezone, cannot verify correct offsets " "in well-known timezones.") def test_timeFormatting(self): """ Test the method of L{FileLogObserver} which turns a timestamp into a human-readable string. """ when = calendar.timegm((2001, 2, 3, 4, 5, 6, 7, 8, 0)) # Pretend to be in US/Eastern for a moment self.flo.getTimezoneOffset = lambda when: 18000 self.assertEqual(self.flo.formatTime(when), '2001-02-02 23:05:06-0500') # Okay now we're in Eastern Europe somewhere self.flo.getTimezoneOffset = lambda when: -3600 self.assertEqual(self.flo.formatTime(when), '2001-02-03 05:05:06+0100') # And off in the Pacific or someplace like that self.flo.getTimezoneOffset = lambda when: -39600 self.assertEqual(self.flo.formatTime(when), '2001-02-03 15:05:06+1100') # One of those weird places with a half-hour offset timezone self.flo.getTimezoneOffset = lambda when: 5400 self.assertEqual(self.flo.formatTime(when), '2001-02-03 02:35:06-0130') # Half-hour offset in the other direction self.flo.getTimezoneOffset = lambda when: -5400 self.assertEqual(self.flo.formatTime(when), '2001-02-03 05:35:06+0130') # Test an offset which is between 0 and 60 minutes to make sure the # sign comes out properly in that case. self.flo.getTimezoneOffset = lambda when: 1800 self.assertEqual(self.flo.formatTime(when), '2001-02-03 03:35:06-0030') # Test an offset between 0 and 60 minutes in the other direction. self.flo.getTimezoneOffset = lambda when: -1800 self.assertEqual(self.flo.formatTime(when), '2001-02-03 04:35:06+0030') # If a strftime-format string is present on the logger, it should # use that instead. Note we don't assert anything about day, hour # or minute because we cannot easily control what time.strftime() # thinks the local timezone is. self.flo.timeFormat = '%Y %m' self.assertEqual(self.flo.formatTime(when), '2001 02') def test_microsecondTimestampFormatting(self): """ L{FileLogObserver.formatTime} supports a value of C{timeFormat} which includes C{"%f"}, a L{datetime}-only format specifier for microseconds. """ self.flo.timeFormat = '%f' self.assertEqual("600000", self.flo.formatTime(12345.6)) def test_loggingAnObjectWithBroken__str__(self): #HELLO, MCFLY self.lp.msg(EvilStr()) self.assertEqual(len(self.out), 1) # Logging system shouldn't need to crap itself for this trivial case self.assertNotIn('UNFORMATTABLE', self.out[0]) def test_formattingAnObjectWithBroken__str__(self): self.lp.msg(format='%(blat)s', blat=EvilStr()) self.assertEqual(len(self.out), 1) self.assertIn('Invalid format string or unformattable object', self.out[0]) def test_brokenSystem__str__(self): self.lp.msg('huh', system=EvilStr()) self.assertEqual(len(self.out), 1) self.assertIn('Invalid format string or unformattable object', self.out[0]) def test_formattingAnObjectWithBroken__repr__Indirect(self): self.lp.msg(format='%(blat)s', blat=[EvilRepr()]) self.assertEqual(len(self.out), 1) self.assertIn('UNFORMATTABLE OBJECT', self.out[0]) def test_systemWithBroker__repr__Indirect(self): self.lp.msg('huh', system=[EvilRepr()]) self.assertEqual(len(self.out), 1) self.assertIn('UNFORMATTABLE OBJECT', self.out[0]) def test_simpleBrokenFormat(self): self.lp.msg(format='hooj %s %s', blat=1) self.assertEqual(len(self.out), 1) self.assertIn('Invalid format string or unformattable object', self.out[0]) def test_ridiculousFormat(self): self.lp.msg(format=42, blat=1) self.assertEqual(len(self.out), 1) self.assertIn('Invalid format string or unformattable object', self.out[0]) def test_evilFormat__repr__And__str__(self): self.lp.msg(format=EvilReprStr(), blat=1) self.assertEqual(len(self.out), 1) self.assertIn('PATHOLOGICAL', self.out[0]) def test_strangeEventDict(self): """ This kind of eventDict used to fail silently, so test it does. """ self.lp.msg(message='', isError=False) self.assertEqual(len(self.out), 0) def _startLoggingCleanup(self): """ Cleanup after a startLogging() call that mutates the hell out of some global state. """ origShowwarnings = log._oldshowwarning self.addCleanup(setattr, log, "_oldshowwarning", origShowwarnings) self.addCleanup(setattr, sys, 'stdout', sys.stdout) self.addCleanup(setattr, sys, 'stderr', sys.stderr) def test_startLogging(self): """ startLogging() installs FileLogObserver and overrides sys.stdout and sys.stderr. """ origStdout, origStderr = sys.stdout, sys.stderr self._startLoggingCleanup() # When done with test, reset stdout and stderr to current values: fakeFile = StringIO() observer = log.startLogging(fakeFile) self.addCleanup(observer.stop) log.msg("Hello!") self.assertIn("Hello!", fakeFile.getvalue()) self.assertIsInstance(sys.stdout, log.StdioOnnaStick) self.assertEqual(sys.stdout.isError, False) encoding = getattr(origStdout, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stdout.encoding, encoding) self.assertIsInstance(sys.stderr, log.StdioOnnaStick) self.assertEqual(sys.stderr.isError, True) encoding = getattr(origStderr, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stderr.encoding, encoding) def test_startLoggingTwice(self): """ There are some obscure error conditions that can occur when logging is started twice. See http://twistedmatrix.com/trac/ticket/3289 for more information. """ self._startLoggingCleanup() # The bug is particular to the way that the t.p.log 'global' function # handle stdout. If we use our own stream, the error doesn't occur. If # we use our own LogPublisher, the error doesn't occur. sys.stdout = StringIO() def showError(eventDict): if eventDict['isError']: sys.__stdout__.write(eventDict['failure'].getTraceback()) log.addObserver(showError) self.addCleanup(log.removeObserver, showError) observer = log.startLogging(sys.stdout) self.addCleanup(observer.stop) # At this point, we expect that sys.stdout is a StdioOnnaStick object. self.assertIsInstance(sys.stdout, log.StdioOnnaStick) fakeStdout = sys.stdout observer = log.startLogging(sys.stdout) self.assertIdentical(sys.stdout, fakeStdout) def test_startLoggingOverridesWarning(self): """ startLogging() overrides global C{warnings.showwarning} such that warnings go to Twisted log observers. """ self._startLoggingCleanup() # Ugggh, pretend we're starting from newly imported module: log._oldshowwarning = None fakeFile = StringIO() observer = log.startLogging(fakeFile) self.addCleanup(observer.stop) warnings.warn("hello!") output = fakeFile.getvalue() self.assertIn("UserWarning: hello!", output) class PythonLoggingObserverTestCase(unittest.SynchronousTestCase): """ Test the bridge with python logging module. """ def setUp(self): self.out = StringIO() rootLogger = logging.getLogger("") self.originalLevel = rootLogger.getEffectiveLevel() rootLogger.setLevel(logging.DEBUG) self.hdlr = logging.StreamHandler(self.out) fmt = logging.Formatter(logging.BASIC_FORMAT) self.hdlr.setFormatter(fmt) rootLogger.addHandler(self.hdlr) self.lp = log.LogPublisher() self.obs = log.PythonLoggingObserver() self.lp.addObserver(self.obs.emit) def tearDown(self): rootLogger = logging.getLogger("") rootLogger.removeHandler(self.hdlr) rootLogger.setLevel(self.originalLevel) logging.shutdown() def test_singleString(self): """ Test simple output, and default log level. """ self.lp.msg("Hello, world.") self.assertIn("Hello, world.", self.out.getvalue()) self.assertIn("INFO", self.out.getvalue()) def test_errorString(self): """ Test error output. """ self.lp.msg(failure=failure.Failure(ValueError("That is bad.")), isError=True) self.assertIn("ERROR", self.out.getvalue()) def test_formatString(self): """ Test logging with a format. """ self.lp.msg(format="%(bar)s oo %(foo)s", bar="Hello", foo="world") self.assertIn("Hello oo world", self.out.getvalue()) def test_customLevel(self): """ Test the logLevel keyword for customizing level used. """ self.lp.msg("Spam egg.", logLevel=logging.DEBUG) self.assertIn("Spam egg.", self.out.getvalue()) self.assertIn("DEBUG", self.out.getvalue()) self.out.seek(0, 0) self.out.truncate() self.lp.msg("Foo bar.", logLevel=logging.WARNING) self.assertIn("Foo bar.", self.out.getvalue()) self.assertIn("WARNING", self.out.getvalue()) def test_strangeEventDict(self): """ Verify that an event dictionary which is not an error and has an empty message isn't recorded. """ self.lp.msg(message='', isError=False) self.assertEqual(self.out.getvalue(), '') class PythonLoggingIntegrationTestCase(unittest.SynchronousTestCase): """ Test integration of python logging bridge. """ def test_startStopObserver(self): """ Test that start and stop methods of the observer actually register and unregister to the log system. """ oldAddObserver = log.addObserver oldRemoveObserver = log.removeObserver l = [] try: log.addObserver = l.append log.removeObserver = l.remove obs = log.PythonLoggingObserver() obs.start() self.assertEqual(l[0], obs.emit) obs.stop() self.assertEqual(len(l), 0) finally: log.addObserver = oldAddObserver log.removeObserver = oldRemoveObserver def test_inheritance(self): """ Test that we can inherit L{log.PythonLoggingObserver} and use super: that's basically a validation that L{log.PythonLoggingObserver} is new-style class. """ class MyObserver(log.PythonLoggingObserver): def emit(self, eventDict): super(MyObserver, self).emit(eventDict) obs = MyObserver() l = [] oldEmit = log.PythonLoggingObserver.emit try: log.PythonLoggingObserver.emit = l.append obs.emit('foo') self.assertEqual(len(l), 1) finally: log.PythonLoggingObserver.emit = oldEmit class DefaultObserverTestCase(unittest.SynchronousTestCase): """ Test the default observer. """ def test_failureLogger(self): """ The reason argument passed to log.err() appears in the report generated by DefaultObserver. """ self.catcher = [] self.observer = self.catcher.append log.addObserver(self.observer) self.addCleanup(log.removeObserver, self.observer) obs = log.DefaultObserver() obs.stderr = StringIO() obs.start() self.addCleanup(obs.stop) reason = "The reason." log.err(Exception(), reason) errors = self.flushLoggedErrors() self.assertIn(reason, obs.stderr.getvalue()) self.assertEqual(len(errors), 1) class StdioOnnaStickTestCase(unittest.SynchronousTestCase): """ StdioOnnaStick should act like the normal sys.stdout object. """ def setUp(self): self.resultLogs = [] log.addObserver(self.resultLogs.append) def tearDown(self): log.removeObserver(self.resultLogs.append) def getLogMessages(self): return ["".join(d['message']) for d in self.resultLogs] def test_write(self): """ Writing to a StdioOnnaStick instance results in Twisted log messages. Log messages are generated every time a '\n' is encountered. """ stdio = log.StdioOnnaStick() stdio.write("Hello there\nThis is a test") self.assertEqual(self.getLogMessages(), ["Hello there"]) stdio.write("!\n") self.assertEqual(self.getLogMessages(), ["Hello there", "This is a test!"]) def test_metadata(self): """ The log messages written by StdioOnnaStick have printed=1 keyword, and by default are not errors. """ stdio = log.StdioOnnaStick() stdio.write("hello\n") self.assertEqual(self.resultLogs[0]['isError'], False) self.assertEqual(self.resultLogs[0]['printed'], True) def test_writeLines(self): """ Writing lines to a StdioOnnaStick results in Twisted log messages. """ stdio = log.StdioOnnaStick() stdio.writelines(["log 1", "log 2"]) self.assertEqual(self.getLogMessages(), ["log 1", "log 2"]) def test_print(self): """ When StdioOnnaStick is set as sys.stdout, prints become log messages. """ oldStdout = sys.stdout sys.stdout = log.StdioOnnaStick() self.addCleanup(setattr, sys, "stdout", oldStdout) print("This", end=" ") print("is a test") self.assertEqual(self.getLogMessages(), ["This is a test"]) def test_error(self): """ StdioOnnaStick created with isError=True log messages as errors. """ stdio = log.StdioOnnaStick(isError=True) stdio.write("log 1\n") self.assertEqual(self.resultLogs[0]['isError'], True) def test_unicode(self): """ StdioOnnaStick converts unicode prints to byte strings on Python 2, in order to be compatible with the normal stdout/stderr objects. On Python 3, the prints are left unmodified. """ unicodeString = u"Hello, \N{VULGAR FRACTION ONE HALF} world." stdio = log.StdioOnnaStick(encoding="utf-8") self.assertEqual(stdio.encoding, "utf-8") stdio.write(unicodeString + u"\n") stdio.writelines([u"Also, " + unicodeString]) oldStdout = sys.stdout sys.stdout = stdio self.addCleanup(setattr, sys, "stdout", oldStdout) # This should go to the log, utf-8 encoded too: print(unicodeString) if _PY3: self.assertEqual(self.getLogMessages(), [unicodeString, u"Also, " + unicodeString, unicodeString]) else: self.assertEqual(self.getLogMessages(), [unicodeString.encode("utf-8"), (u"Also, " + unicodeString).encode("utf-8"), unicodeString.encode("utf-8")])