def log_exception(self, message, exception, log_level=LOG_LEVEL.ERROR, timestamp=None, **kwargs): """ If the log_level of the printer is greater than DEBUG, it prints only the message. If it is DEBUG or lower, it shows the message along with the traceback of the exception. :param message: The message to print. :param exception: The exception to print. :param log_level: The log_level of this message (not used when logging the traceback. Tracebacks always have a level of DEBUG). :param timestamp: The time at which this log occured. Defaults to the current time. :param kwargs: Keyword arguments to be passed when logging the message (not used when logging the traceback). """ if not isinstance(exception, BaseException): raise TypeError("log_exception can only log derivatives of " "BaseException.") traceback_str = "\n".join( traceback.format_exception(type(exception), exception, exception.__traceback__)) self.log(log_level, message, timestamp=timestamp, **kwargs) self.log_message( LogMessage(LOG_LEVEL.DEBUG, "Exception was:" + "\n" + traceback_str, timestamp=timestamp), **kwargs)
def test_logging(self): uut = ListLogPrinter() ts = datetime.today() ts_str = ts.strftime("%X") uut.log_level = LOG_LEVEL.INFO uut.warn("Test value", timestamp=ts) uut.print("Test 2", timestamp=ts) # Should go to INFO uut.debug("Test 2", timestamp=ts) # Should not be logged self.assertEqual(uut.logs, [ LogMessage(LOG_LEVEL.WARNING, "Test value", timestamp=ts), LogMessage(LOG_LEVEL.INFO, "Test 2", timestamp=ts) ]) self.assertRaises(TypeError, uut.log_message, "message")
class LogPrinterTest(unittest.TestCase): log_message = LogMessage(LOG_LEVEL.ERROR, Constants.COMPLEX_TEST_STRING) def test_get_printer(self): self.assertIs(LogPrinter(None).printer, None) printer = Printer() self.assertIs(LogPrinter(printer).printer, printer) def test_logging(self): uut = LogPrinter(timestamp_format='') uut.logger = mock.MagicMock() uut.log_message(self.log_message) msg = Constants.COMPLEX_TEST_STRING uut.logger.log.assert_called_with(logging.ERROR, msg) uut = LogPrinter(log_level=LOG_LEVEL.DEBUG) uut.logger = mock.MagicMock() uut.log(LOG_LEVEL.ERROR, Constants.COMPLEX_TEST_STRING) uut.logger.log.assert_called_with(logging.ERROR, msg) uut.debug(Constants.COMPLEX_TEST_STRING, 'd') uut.logger.log.assert_called_with(logging.DEBUG, msg + ' d') uut.log_level = LOG_LEVEL.DEBUG uut.log_exception('Something failed.', NotImplementedError(msg)) uut.logger.log.assert_any_call(logging.ERROR, 'Something failed.') uut.logger.log.assert_called_with( logging.INFO, 'Exception was:\n{exception}: {msg}'.format( exception='NotImplementedError', msg=msg)) def test_raises(self): uut = LogPrinter(NullPrinter()) self.assertRaises(TypeError, uut.log, 5) self.assertRaises(TypeError, uut.log_exception, 'message', 5) self.assertRaises(TypeError, uut.log_message, 5) def test_log_level(self): uut = LogPrinter() self.assertEqual(uut.log_level, logging.DEBUG) uut.log_level = logging.INFO self.assertEqual(uut.log_level, logging.INFO) def test_get_state(self): uut = LogPrinter() self.assertNotIn('logger', uut.__getstate__()) def test_set_state(self): uut = LogPrinter() state = uut.__getstate__() uut.__setstate__(state) self.assertIs(uut.logger, logging.getLogger()) def test_no_printer(self): uut = LogPrinter() self.assertIs(uut.logger, logging.getLogger())
def test_construction(self): # take a look if defaults are good self.assertEqual(self.uut.log_level, LOG_LEVEL.DEBUG) self.assertEqual(self.uut.message, "test message") self.assertEqual(self.uut.timestamp, self.timestamp) # see that arguments are processed right self.uut = LogMessage(LOG_LEVEL.WARNING, " a msg ", 5, " ", timestamp=self.timestamp) self.assertEqual(self.uut.log_level, LOG_LEVEL.WARNING) self.assertEqual(self.uut.message, " a msg 5") self.assertEqual(self.uut.timestamp, self.timestamp) self.assertRaises(ValueError, LogMessage, LOG_LEVEL.DEBUG, "") self.assertRaises(ValueError, LogMessage, 5, "test")
def test_logging(self): uut = ListLogPrinter() ts = datetime.today() uut.log_level = LOG_LEVEL.INFO uut.warn('Test value', timestamp=ts) uut.print('Test 2', timestamp=ts) # Should go to INFO uut.debug('Test 2', timestamp=ts) # Should not be logged self.assertEqual(uut.logs, [LogMessage(LOG_LEVEL.WARNING, 'Test value', timestamp=ts), LogMessage(LOG_LEVEL.INFO, 'Test 2', timestamp=ts)]) self.assertRaises(TypeError, uut.log_message, 'message')
def test_equals(self): self.assertEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.WARNING, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), 5)
def __send_msg(self, log_level, delimiter, *args): if self.message_queue is None: return if len(args) == 0: return self.message_queue.put(LogMessage(log_level, str(delimiter).join(args)), timeout=self.TIMEOUT)
def __send_msg(self, log_level, delimiter, *args): if self.message_queue is None: return if len(args) == 0: return msg = "" for i in range(len(args) - 1): msg += str(args[i]) + str(delimiter) msg += str(args[-1]) self.message_queue.put(LogMessage(log_level, msg), timeout=self.TIMEOUT)
def log_exception(self, message, exception, log_level=LOG_LEVEL.ERROR, timestamp=None, **kwargs): if not isinstance(exception, BaseException): raise TypeError( "log_exception can only log derivatives of BaseException.") return self.log_message(LogMessage( log_level, message + "\n\n" + _("Exception was:") + "\n" + str(exception)), timestamp=timestamp, **kwargs)
def send_msg(message_queue, timeout, log_level, *args, delimiter=' ', end=''): """ Puts message into message queue for a LogPrinter to present to the user. :param message_queue: The queue to put the message into and which the LogPrinter reads. :param timeout: The queue blocks at most timeout seconds for a free slot to execute the put operation on. After the timeout it returns queue Full exception. :param log_level: The log_level i.e Error,Debug or Warning.It is sent to the LogPrinter depending on the message. :param args: This includes the elements of the message. :param delimiter: It is the value placed between each arg. By default it is a ' '. :param end: It is the value placed at the end of the message. """ output = str(delimiter).join(str(arg) for arg in args) + str(end) message_queue.put(LogMessage(log_level, output), timeout=timeout)
def log_exception(self, message, exception, log_level=LOG_LEVEL.ERROR, timestamp=None, **kwargs): if not isinstance(exception, BaseException): raise TypeError("log_exception can only log derivatives of " "BaseException.") traceback_str = "\n".join( traceback.format_exception(type(exception), exception, exception.__traceback__)) return self.log_message(LogMessage( log_level, message + "\n\n" + _("Exception was:") + "\n" + traceback_str), timestamp=timestamp, **kwargs)
class LogMessageTest(unittest.TestCase): timestamp = datetime.today() def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, "test", "message", timestamp=self.timestamp) def test_construction(self): # take a look if defaults are good self.assertEqual(self.uut.log_level, LOG_LEVEL.DEBUG) self.assertEqual(self.uut.message, "test message") self.assertEqual(self.uut.timestamp, self.timestamp) # see that arguments are processed right self.uut = LogMessage(LOG_LEVEL.WARNING, " a msg ", 5, " ", timestamp=self.timestamp) self.assertEqual(self.uut.log_level, LOG_LEVEL.WARNING) self.assertEqual(self.uut.message, " a msg 5") self.assertEqual(self.uut.timestamp, self.timestamp) self.assertRaises(ValueError, LogMessage, LOG_LEVEL.DEBUG, "") self.assertRaises(ValueError, LogMessage, 5, "test") def test_to_str(self): self.uut.message = Constants.COMPLEX_TEST_STRING self.uut.log_level = LOG_LEVEL.ERROR self.assertEqual(str(self.uut), "[{}] {}".format(_("ERROR"), Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.WARNING self.assertEqual(str(self.uut), "[{}] {}".format(_("WARNING"), Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.DEBUG self.assertEqual(str(self.uut), "[{}] {}".format(_("DEBUG"), Constants.COMPLEX_TEST_STRING)) self.uut.log_level = 5 self.assertEqual(str(self.uut), "[{}] {}".format(_("ERROR"), Constants.COMPLEX_TEST_STRING)) def test_equals(self): self.assertEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.WARNING, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), 5) def test_string_dict(self): self.uut.log_level = LOG_LEVEL.DEBUG self.uut.message = "test" self.assertEqual( self.uut.to_string_dict(), {"log_level": "DEBUG", "message": "test", "timestamp": self.timestamp.isoformat()}) self.uut.timestamp = None self.uut.log_level = -9999 # invalid level self.assertEqual( self.uut.to_string_dict(), {"log_level": "", "message": "test", "timestamp": ""})
class LogPrinterTestCase(unittest.TestCase): log_message = LogMessage(LOG_LEVEL.ERROR, StringConstants.COMPLEX_TEST_STRING) def test_interface(self): uut = LogPrinter() self.assertRaises(NotImplementedError, uut.log_message, self.log_message) def test_logging(self): uut = TestLogPrinter(timestamp_format="") self.assertEqual((str(self.log_message), "special"), uut.log_message(self.log_message, end="", special_arg="special")) uut = TestLogPrinter(log_level=LOG_LEVEL.DEBUG) ts = datetime.today() self.assertEqual(("[" + _("ERROR") + "][" + ts.strftime("%X") + "] " + StringConstants.COMPLEX_TEST_STRING, "test"), uut.log_message(self.log_message, timestamp=ts, end="")) self.assertEqual(("[" + _("ERROR") + "][" + ts.strftime("%X") + "] " + StringConstants.COMPLEX_TEST_STRING, "test"), uut.log(LOG_LEVEL.ERROR, StringConstants.COMPLEX_TEST_STRING, timestamp=ts, end="")) self.assertEqual(("[" + _("DEBUG") + "][" + ts.strftime("%X") + "] " + StringConstants.COMPLEX_TEST_STRING, "test"), uut.debug(StringConstants.COMPLEX_TEST_STRING, timestamp=ts, end="")) uut.log_level = LOG_LEVEL.WARNING self.assertEqual( None, uut.debug(StringConstants.COMPLEX_TEST_STRING, timestamp=ts, end="")) self.assertEqual(("[" + _("WARNING") + "][" + ts.strftime("%X") + "] " + StringConstants.COMPLEX_TEST_STRING, "test"), uut.warn(StringConstants.COMPLEX_TEST_STRING, timestamp=ts, end="")) self.assertEqual(("[" + _("ERROR") + "][" + ts.strftime("%X") + "] " + StringConstants.COMPLEX_TEST_STRING, "test"), uut.err(StringConstants.COMPLEX_TEST_STRING, timestamp=ts, end="")) logged = uut.log_exception("Something failed.", NotImplementedError( StringConstants.COMPLEX_TEST_STRING), timestamp=ts, end="") self.assertTrue( logged[0].startswith("[" + _("ERROR") + "][" + ts.strftime("%X") + "] Something failed.\n\n" + _("Exception was:") + "\n")) def test_raises(self): uut = LogPrinter() self.assertRaises(TypeError, uut.log, 5) self.assertRaises(TypeError, uut.log_exception, "message", 5) self.assertRaises(TypeError, uut.log_message, 5)
class LogMessageTest(unittest.TestCase): timestamp = datetime.today() def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, 'test', 'message', timestamp=self.timestamp) def test_construction(self): # take a look if defaults are good self.assertEqual(self.uut.log_level, LOG_LEVEL.DEBUG) self.assertEqual(self.uut.message, 'test message') self.assertEqual(self.uut.timestamp, self.timestamp) # see that arguments are processed right self.uut = LogMessage(LOG_LEVEL.WARNING, ' a msg ', 5, ' ', timestamp=self.timestamp) self.assertEqual(self.uut.log_level, LOG_LEVEL.WARNING) self.assertEqual(self.uut.message, ' a msg 5') self.assertEqual(self.uut.timestamp, self.timestamp) self.assertRaises(ValueError, LogMessage, LOG_LEVEL.DEBUG, '') self.assertRaises(ValueError, LogMessage, 5, 'test') def test_to_str(self): self.uut.message = Constants.COMPLEX_TEST_STRING self.uut.log_level = LOG_LEVEL.ERROR self.assertEqual( str(self.uut), '[{}] {}'.format('ERROR', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.WARNING self.assertEqual( str(self.uut), '[{}] {}'.format('WARNING', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.DEBUG self.assertEqual( str(self.uut), '[{}] {}'.format('DEBUG', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = 5 self.assertEqual( str(self.uut), '[{}] {}'.format('ERROR', Constants.COMPLEX_TEST_STRING)) def test_equals(self): self.assertEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.DEBUG, 'test message')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.WARNING, 'test message')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.DEBUG, 'test')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), 5) def test_string_dict(self): self.uut.log_level = LOG_LEVEL.DEBUG self.uut.message = 'test' self.assertEqual( self.uut.to_string_dict(), { 'log_level': 'DEBUG', 'message': 'test', 'timestamp': self.timestamp.isoformat() }) self.uut.timestamp = None self.uut.log_level = -9999 # invalid level self.assertEqual(self.uut.to_string_dict(), { 'log_level': '', 'message': 'test', 'timestamp': '' })
def log(self, log_level, message, timestamp=None, **kwargs): self.log_message(LogMessage(log_level, message, timestamp=timestamp), **kwargs)
def err(self, *messages, delimiter=" ", timestamp=None, **kwargs): self.log_message( LogMessage(LOG_LEVEL.ERROR, *messages, delimiter=delimiter, timestamp=timestamp), **kwargs)
def warn(self, *messages, delimiter=" ", timestamp=None, **kwargs): self.log_message( LogMessage(LOG_LEVEL.WARNING, *messages, delimiter=delimiter, timestamp=timestamp), **kwargs)
def log(self, log_level, message, timestamp=None, **kwargs): return self.log_message(LogMessage(log_level, message), timestamp=timestamp, **kwargs)
def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, "test message")
def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, 'test', 'message', timestamp=self.timestamp)
def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, "test", "message", timestamp=self.timestamp)
def debug(self, message, timestamp=None, **kwargs): return self.log_message(LogMessage(LOG_LEVEL.DEBUG, message), timestamp=timestamp, **kwargs)
class LogMessageTest(unittest.TestCase): timestamp = datetime.today() def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, "test", "message", timestamp=self.timestamp) def test_construction(self): # take a look if defaults are good self.assertEqual(self.uut.log_level, LOG_LEVEL.DEBUG) self.assertEqual(self.uut.message, "test message") self.assertEqual(self.uut.timestamp, self.timestamp) # see that arguments are processed right self.uut = LogMessage(LOG_LEVEL.WARNING, " a msg ", 5, " ", timestamp=self.timestamp) self.assertEqual(self.uut.log_level, LOG_LEVEL.WARNING) self.assertEqual(self.uut.message, " a msg 5") self.assertEqual(self.uut.timestamp, self.timestamp) self.assertRaises(ValueError, LogMessage, LOG_LEVEL.DEBUG, "") self.assertRaises(ValueError, LogMessage, 5, "test") def test_to_str(self): self.uut.message = Constants.COMPLEX_TEST_STRING self.uut.log_level = LOG_LEVEL.ERROR self.assertEqual( str(self.uut), "[{}] {}".format("ERROR", Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.WARNING self.assertEqual( str(self.uut), "[{}] {}".format("WARNING", Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.DEBUG self.assertEqual( str(self.uut), "[{}] {}".format("DEBUG", Constants.COMPLEX_TEST_STRING)) self.uut.log_level = 5 self.assertEqual( str(self.uut), "[{}] {}".format("ERROR", Constants.COMPLEX_TEST_STRING)) def test_equals(self): self.assertEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.WARNING, "test message")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), LogMessage(LOG_LEVEL.DEBUG, "test")) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, "test message"), 5) def test_string_dict(self): self.uut.log_level = LOG_LEVEL.DEBUG self.uut.message = "test" self.assertEqual( self.uut.to_string_dict(), { "log_level": "DEBUG", "message": "test", "timestamp": self.timestamp.isoformat() }) self.uut.timestamp = None self.uut.log_level = -9999 # invalid level self.assertEqual(self.uut.to_string_dict(), { "log_level": "", "message": "test", "timestamp": "" })
def warn(self, message, timestamp=None, **kwargs): return self.log_message(LogMessage(LOG_LEVEL.WARNING, message), timestamp=timestamp, **kwargs)
class LogMessageTest(unittest.TestCase): timestamp = datetime.today() def setUp(self): self.uut = LogMessage(LOG_LEVEL.DEBUG, 'test', 'message', timestamp=self.timestamp) def test_construction(self): # take a look if defaults are good self.assertEqual(self.uut.log_level, LOG_LEVEL.DEBUG) self.assertEqual(self.uut.message, 'test message') self.assertEqual(self.uut.timestamp, self.timestamp) # see that arguments are processed right self.uut = LogMessage(LOG_LEVEL.WARNING, ' a msg ', 5, ' ', timestamp=self.timestamp) self.assertEqual(self.uut.log_level, LOG_LEVEL.WARNING) self.assertEqual(self.uut.message, ' a msg 5') self.assertEqual(self.uut.timestamp, self.timestamp) self.assertRaises(ValueError, LogMessage, LOG_LEVEL.DEBUG, '') self.assertRaises(ValueError, LogMessage, 5, 'test') def test_to_str(self): self.uut.message = Constants.COMPLEX_TEST_STRING self.uut.log_level = LOG_LEVEL.ERROR self.assertEqual(str(self.uut), '[{}] {}'.format('ERROR', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.WARNING self.assertEqual(str(self.uut), '[{}] {}'.format('WARNING', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = LOG_LEVEL.DEBUG self.assertEqual(str(self.uut), '[{}] {}'.format('DEBUG', Constants.COMPLEX_TEST_STRING)) self.uut.log_level = 5 self.assertEqual(str(self.uut), '[{}] {}'.format('ERROR', Constants.COMPLEX_TEST_STRING)) def test_equals(self): self.assertEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.DEBUG, 'test message')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.WARNING, 'test message')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), LogMessage(LOG_LEVEL.DEBUG, 'test')) self.assertNotEqual(LogMessage(LOG_LEVEL.DEBUG, 'test message'), 5) def test_string_dict(self): self.uut.log_level = LOG_LEVEL.DEBUG self.uut.message = 'test' self.assertEqual( self.uut.to_string_dict(), {'log_level': 'DEBUG', 'message': 'test', 'timestamp': self.timestamp.isoformat()}) self.uut.timestamp = None self.uut.log_level = -9999 # invalid level self.assertEqual( self.uut.to_string_dict(), {'log_level': '', 'message': 'test', 'timestamp': ''})
def debug(self, *messages, delimiter=" ", timestamp=None, **kwargs): self.log_message( LogMessage(LOG_LEVEL.DEBUG, *messages, delimiter=delimiter, timestamp=timestamp), **kwargs)
def err(self, message, timestamp=None, **kwargs): return self.log_message(LogMessage(LOG_LEVEL.ERROR, message), timestamp=timestamp, **kwargs)
class LogPrinterTest(unittest.TestCase): timestamp = datetime.today() log_message = LogMessage(LOG_LEVEL.ERROR, Constants.COMPLEX_TEST_STRING, timestamp=timestamp) def test_interface(self): uut = LogPrinter(Printer()) self.assertRaises(NotImplementedError, uut.log_message, self.log_message) def test_get_printer(self): self.assertIs(LogPrinter(None).printer, None) printer = Printer() self.assertIs(LogPrinter(printer).printer, printer) def test_logging(self): uut = LogPrinter(StringPrinter(), timestamp_format="") uut.log_message(self.log_message, end="") self.assertEqual(uut.printer.string, str(self.log_message)) uut = LogPrinter(StringPrinter(), log_level=LOG_LEVEL.DEBUG) uut.log_message(self.log_message, end="") self.assertEqual( uut.printer.string, "[ERROR][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING) uut.printer.clear() uut.log(LOG_LEVEL.ERROR, Constants.COMPLEX_TEST_STRING, timestamp=self.timestamp, end="") self.assertEqual( uut.printer.string, "[ERROR][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING) uut.printer.clear() uut.debug(Constants.COMPLEX_TEST_STRING, "d", timestamp=self.timestamp, end="") self.assertEqual( uut.printer.string, "[DEBUG][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING + " d") uut.printer.clear() uut.log_level = LOG_LEVEL.INFO uut.debug(Constants.COMPLEX_TEST_STRING, timestamp=self.timestamp, end="") self.assertEqual(uut.printer.string, "") uut.printer.clear() uut.info(Constants.COMPLEX_TEST_STRING, "d", timestamp=self.timestamp, end="") self.assertEqual( uut.printer.string, "[INFO][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING + " d") uut.log_level = LOG_LEVEL.WARNING uut.printer.clear() uut.debug(Constants.COMPLEX_TEST_STRING, timestamp=self.timestamp, end="") self.assertEqual(uut.printer.string, "") uut.printer.clear() uut.warn(Constants.COMPLEX_TEST_STRING, "d", timestamp=self.timestamp, end="") self.assertEqual( uut.printer.string, "[WARNING][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING + " d") uut.printer.clear() uut.err(Constants.COMPLEX_TEST_STRING, "d", timestamp=self.timestamp, end="") self.assertEqual( uut.printer.string, "[ERROR][" + self.timestamp.strftime("%X") + "] " + Constants.COMPLEX_TEST_STRING + " d") uut.log_level = LOG_LEVEL.DEBUG uut.printer.clear() uut.log_exception( "Something failed.", NotImplementedError(Constants.COMPLEX_TEST_STRING), timestamp=self.timestamp) self.assertTrue(uut.printer.string.startswith( "[ERROR][" + self.timestamp.strftime("%X") + "] Something failed.\n" + "[DEBUG][" + self.timestamp.strftime("%X") + "] Exception was:")) uut.log_level = LOG_LEVEL.INFO uut.printer.clear() logged = uut.log_exception( "Something failed.", NotImplementedError(Constants.COMPLEX_TEST_STRING), timestamp=self.timestamp, end="") self.assertTrue(uut.printer.string.startswith( "[ERROR][" + self.timestamp.strftime("%X") + "] Something failed.")) def test_raises(self): uut = LogPrinter(NullPrinter()) self.assertRaises(TypeError, uut.log, 5) self.assertRaises(TypeError, uut.log_exception, "message", 5) self.assertRaises(TypeError, uut.log_message, 5)
def info(self, *messages, delimiter=" ", timestamp=None, **kwargs): self.log_message( LogMessage(LOG_LEVEL.INFO, *messages, delimiter=delimiter, timestamp=timestamp), **kwargs)
def __send_msg(self, log_level, *args, delimiter=' ', end=''): output = str(delimiter).join(str(arg) for arg in args) + str(end) self.message_queue.put(LogMessage(log_level, output), timeout=self.TIMEOUT)