def test_setLevelShowngLogger(loggerLevel, isSuperiorTo, logRecordLevel): """ Set gLogger level: check whether a log record should be displayed """ capturedBackend, log, sublog = gLoggerReset() levels = gLogger.getAllPossibleLevels() gLogger.setLevel(loggerLevel) # convert level name into its integer value logRecordLevelValue = LogLevels.getLevelValue(logRecordLevel) res = gLogger._createLogRecord(logRecordLevelValue, 'message', '') # clean the log to remove unecessary information logstring = cleaningLog(capturedBackend.getvalue()) # if loggerLevel is superior to logRecordLevel then: # - log record should not appear # - shown should return False as the log doesn't appear # - value returned by createLogRecord should be False too isLoggerLvlSupToLogRecordLvl = LogLevels.getLevelValue( loggerLevel) > logRecordLevelValue assert isLoggerLvlSupToLogRecordLvl == isSuperiorTo if isLoggerLvlSupToLogRecordLvl: assert not gLogger.shown(logRecordLevel) assert not res assert logstring == "" else: assert gLogger.shown(logRecordLevel) assert res assert logstring == "Framework %s: message\n" % logRecordLevel.upper() capturedBackend.truncate(0) capturedBackend.seek(0)
def test_createLogRecord(sMsg, sVarMsg, exc_info, expected): """ Create logs of different levels with multiple logs """ capturedBackend, log, sublog = gLoggerReset() # Set the level to debug gLogger.setLevel("debug") # dictionary of key = logger to use, value = output associated to the logger logDict = {gLogger: "", log: "/log", sublog: "/log/sublog"} # get list of existing levels, for each of them, a log record is created levels = gLogger.getAllPossibleLevels() for level in levels: for logger, logInfo in logDict.items(): # createLogRecord is the method in charge of creating the log record # debug, ..., always methods wrap the following method # we use logLevels to get the int value corresponding to the level name logger._createLogRecord(LogLevels.getLevelValue(level), sMsg, sVarMsg, exc_info) # clean the log to remove unecessary information logstring = cleaningLog(capturedBackend.getvalue()) logExpected = "Framework%s %s: %s\n" % (logInfo, level, expected) assert logExpected == logstring capturedBackend.truncate(0) capturedBackend.seek(0)
def test_showStack(): """ Get the showStack """ capturedBackend, log, sublog = gLoggerReset() # dictionary of key = logger to use, value = output associated to the logger logDict = {gLogger: "", log: "/log", sublog: "/log/sublog"} for logger, logInfo in logDict.items(): # By default, should not appear as the level is NOTICE logger.showStack() # clean the log to remove unecessary information logstring = cleaningLog(capturedBackend.getvalue()) assert logstring == "" capturedBackend.truncate(0) capturedBackend.seek(0) # Set level to debug gLogger.setLevel("debug") for logger, logInfo in logDict.items(): # The debug message should appear logger.showStack() # clean the log to remove unecessary information logstring = cleaningLog(capturedBackend.getvalue()) assert logstring == "Framework%s DEBUG: \n" % logInfo capturedBackend.truncate(0) capturedBackend.seek(0)
def test_localSubLoggerObject(logLevel): """ Create a local subLogger and compare its output with the standard subLogger for all the log levels """ capturedBackend, log, _ = gLoggerReset() # Set the level to debug to always make sure that something is printed log.setLevel("debug") # Create a real subLogger and a localSubLogger # with the same "name" subLog = log.getSubLogger("child") localSubLog = log.getSubLogger("child") # Print and capture a message with the real sublogger capturedBackend.truncate(0) capturedBackend.seek(0) getattr(subLog, logLevel)(logLevel) subMsg = capturedBackend.getvalue() # Print and capture a message with the local sublogger capturedBackend.truncate(0) capturedBackend.seek(0) getattr(localSubLog, logLevel)(logLevel) locMsg = capturedBackend.getvalue() # Compare the output assert subMsg == locMsg
def test_registerBackendgLogger(backends): """ Attach backends to gLogger, generate some logs from different loggers and check the content of the backends """ _, log, sublog = gLoggerReset() # dictionary of available loggers loggers = {"gLogger": gLogger, "log": log, "sublog": sublog} # attach backends to the corresponding logger for backend, params in backends.items(): logger = loggers[params["logger"]] numberOfBackends = len(logger._backendsList) logger.registerBackend(params["backendType"], params["backendOptions"]) # backend should be added to logger.backendList assert len(logger._backendsList) == (numberOfBackends + 1) # Generate logs from gLogger, log, sublog gLogger.setLevel("notice") gLogger.notice("msg") log.notice("msg") sublog.notice("msg") # Check the content of the backends for backend, params in backends.items(): content = params["extractBackendContent"](params["backendOptions"]) assert content == params["backendContent"]
def test_registerBackendgLogger(backends): """ Attach backends to gLogger, generate some logs from different loggers and check the content of the backends """ _, log, sublog = gLoggerReset() # dictionary of available loggers loggers = {'gLogger': gLogger, 'log': log, 'sublog': sublog} # attach backends to the corresponding logger for backend, params in backends.items(): logger = loggers[params['logger']] numberOfBackends = len(logger._backendsList) logger.registerBackend(params['backendType'], params['backendOptions']) # backend should be added to logger.backendList assert len(logger._backendsList) == (numberOfBackends + 1) # Generate logs from gLogger, log, sublog gLogger.setLevel('notice') gLogger.notice('msg') log.notice('msg') sublog.notice('msg') # Check the content of the backends for backend, params in backends.items(): content = params['extractBackendContent'](params['backendOptions']) assert content == params['backendContent']
def test_getAllPossibleLevels(): """ Make sure getAllPossibleLevels returns every existing level """ _, log, sublog = gLoggerReset() levels = ["DEBUG", "VERBOSE", "INFO", "WARN", "NOTICE", "ERROR", "ALWAYS", "FATAL"] assert sorted(gLogger.getAllPossibleLevels()) == sorted(levels) assert sorted(log.getAllPossibleLevels()) == sorted(levels) assert sorted(sublog.getAllPossibleLevels()) == sorted(levels)
def test_showFormatOptionsgLogger( header, threadID, timeStamp, context, msg, expectedLog, isThreadIDAvailable, isTimeStampAvailable ): """ Set gLogger options, check that options are inherited in log and sublog """ capturedBackend, log, sublog = gLoggerReset() # setting these values should modify the way the log record is displayed gLogger.showHeaders(header) gLogger.showThreadIDs(threadID) gLogger.showTimeStamps(timeStamp) gLogger.showContexts(context) # log and sublog should inherit from the changes assert gLogger._options["headerIsShown"] == header assert gLogger._options["threadIDIsShown"] == threadID assert log._options["headerIsShown"] == gLogger._options["headerIsShown"] assert log._options["timeStampIsShown"] == gLogger._options["timeStampIsShown"] assert log._options["contextIsShown"] == gLogger._options["contextIsShown"] assert log._options["threadIDIsShown"] == gLogger._options["threadIDIsShown"] assert sublog._options["headerIsShown"] == log._options["headerIsShown"] assert sublog._options["timeStampIsShown"] == log._options["timeStampIsShown"] assert sublog._options["contextIsShown"] == log._options["contextIsShown"] assert sublog._options["threadIDIsShown"] == log._options["threadIDIsShown"] # create log records and check the format is correct gLogger.notice(msg) logValue = capturedBackend.getvalue() # check that timestamp is available if it has to be available assert ("UTC" in logValue) == isTimeStampAvailable logstring = cleaningLog(logValue) capturedBackend.truncate(0) capturedBackend.seek(0) log.notice(msg) logValue = capturedBackend.getvalue() assert ("UTC" in logValue) == isTimeStampAvailable logstring += cleaningLog(logValue) capturedBackend.truncate(0) capturedBackend.seek(0) sublog.notice(msg) logValue = capturedBackend.getvalue() assert ("UTC" in logValue) == isTimeStampAvailable logstring += cleaningLog(logValue) capturedBackend.truncate(0) capturedBackend.seek(0) # check that threadID is present in the log when it should be present threadIDValue = str(thread.get_ident()) assert (threadIDValue in logstring) == isThreadIDAvailable # as thread ID depends on the execution, we have to add it to the expected results if isThreadIDAvailable: expectedLog = expectedLog % (threadIDValue, threadIDValue, threadIDValue) assert expectedLog == logstring
def test_setLevelInit(): """ Test setLevel and getLevel: initialization of gLogger """ _, log, sublog = gLoggerReset() # make sure gLogger and its subloggers have a common level when initialized # we don't set the level of gLogger assert gLogger.getLevel() == 'NOTICE' assert log.getLevel() == 'NOTICE' assert sublog.getLevel() == 'NOTICE'
def test_logsFromExtLibsHandlers(isEnabled, loggingLevel, numberHandlers, handlerType): """ Check that handlers attached are different according to the value of enableLogsFromExternalLibs() """ gLoggerReset() # when enable, Logging should also report logs from external library # a StreamHandler should be attached to the root logger by default if isEnabled: gLogger.enableLogsFromExternalLibs() # in the other case, Logging should not report logs from external library # a NullHandler disables the emission of the log records going to the root logger else: gLogger.disableLogsFromExternalLibs() handlers = logging.getLogger().handlers assert logging.getLogger().getEffectiveLevel() == loggingLevel assert numberHandlers == len(handlers) assert isinstance(handlers[0], handlerType)
def test_getSubLoggerObject(): """ Create a sublogger, set its level, get a sublogger with the same name and check that is it the same object """ _, _, _ = gLoggerReset() log = gLogger.getSubLogger("log") log.setLevel("notice") anotherLog = gLogger.getSubLogger("log") assert log.getLevel() == anotherLog.getLevel() assert log == anotherLog
def test_logsFromExtLibsLogs(isEnabled, loggerName, message, expected): """ Check whether logs are displayed according to the value of enableLogsFromExternalLibs() """ gLoggerReset() # when enable, Logging should also report logs from external library # logs from external libs should appear if isEnabled: gLogger.enableLogsFromExternalLibs() # in the other case, Logging should not report logs from external library # logs from external libs shouldn't appear else: gLogger.disableLogsFromExternalLibs() # modify the output to capture logs of the root logger bufferRoot = StringIO() logging.getLogger().handlers[0].stream = bufferRoot logging.getLogger(loggerName).info(message) logstring = cleaningLog(bufferRoot.getvalue()) assert expected == logstring
def test_setLevelgLogger(): """ Test setLevel and getLevel: set gLogger level """ _, log, sublog = gLoggerReset() levels = gLogger.getAllPossibleLevels() # as log and sublog levels has not been changed, they should inherit from the same level for level in levels: gLogger.setLevel(level) assert gLogger.getLevel() == level.upper() assert log.getLevel() == level.upper() assert sublog.getLevel() == level.upper()
def test_showFormatOptionsSubLog(header, threadID, msg, expectedLog, isThreadIDAvailable): """ Set sublog (child of log) options """ capturedBackend, log, sublog = gLoggerReset() # set gLogger and log options, sublog options should not be modified gLogger.showHeaders(True) gLogger.showThreadIDs(False) log.showHeaders(False) log.showThreadIDs(False) # set sublog options sublog.showHeaders(header) sublog.showThreadIDs(threadID) # log should inherit from the options of gLogger, subLog shoud not inherit from log assert gLogger._options["headerIsShown"] assert not gLogger._options["threadIDIsShown"] assert not log._options["headerIsShown"] assert not log._options["threadIDIsShown"] assert sublog._options["headerIsShown"] == header assert sublog._options["threadIDIsShown"] == threadID # create log records and check the format is correct gLogger.notice(msg) logstring = cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) log.notice(msg) logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) sublog.notice(msg) logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) expectedLog = "Framework NOTICE: message\nmessage\n" + expectedLog threadIDValue = str(_thread.get_ident()) assert (threadIDValue in logstring) == isThreadIDAvailable # as thread ID depends on the execution, we have to add it to the expected results if isThreadIDAvailable: expectedLog = expectedLog % threadIDValue assert expectedLog == logstring
def test_logsFromExtLibsMultCalls(): """ Calls the method several times to see whether we have duplication of the logs """ gLoggerReset() for i in range(5): gLogger.enableLogsFromExternalLibs() handlers = logging.getLogger().handlers assert len(handlers) == 1 assert isinstance(handlers[0], logging.StreamHandler) for i in range(5): gLogger.disableLogsFromExternalLibs() handlers = logging.getLogger().handlers assert len(handlers) == 1 assert isinstance(handlers[0], logging.NullHandler) gLogger.enableLogsFromExternalLibs() gLogger.disableLogsFromExternalLibs() gLogger.enableLogsFromExternalLibs() gLogger.disableLogsFromExternalLibs() handlers = logging.getLogger().handlers assert len(handlers) == 1 assert isinstance(handlers[0], logging.NullHandler) gLogger.disableLogsFromExternalLibs() gLogger.enableLogsFromExternalLibs() gLogger.disableLogsFromExternalLibs() gLogger.enableLogsFromExternalLibs() handlers = logging.getLogger().handlers assert len(handlers) == 1 assert isinstance(handlers[0], logging.StreamHandler)
def test_logsFromExtLibsPropag(): """ Test the no propagation of the logs from the Logging objects to the root logger of 'logging' """ capturedBackend, _, _ = gLoggerReset() gLogger.enableLogsFromExternalLibs() # modify the output to capture logs of the root logger bufferRoot = StringIO() logging.getLogger().handlers[0].stream = bufferRoot gLogger.error('message') assert capturedBackend.getvalue() != "" assert bufferRoot.getvalue() == ""
def test_setLevelStopPropagation(): """ Test setLevel and getLevel: set gLogger level while log and sublog have already be set """ _, log, sublog = gLoggerReset() levels = gLogger.getAllPossibleLevels() # by changing gLogger level, log and sublog should not be affected anymore as they have been changed manually log.setLevel('warn') sublog.setLevel('verbose') for level in levels: gLogger.setLevel(level) assert gLogger.getLevel() == level.upper() assert log.getLevel() == 'WARN' assert sublog.getLevel() == 'VERBOSE'
def test_setLevelLog(): """ Test setLevel and getLevel: set log level """ _, log, sublog = gLoggerReset() levels = gLogger.getAllPossibleLevels() # set gLogger level gLogger.setLevel('notice') # by changing log level, gLogger should not be affected, subLogger should be for level in levels: log.setLevel(level) assert gLogger.getLevel() == 'NOTICE' assert log.getLevel() == level.upper() assert sublog.getLevel() == level.upper()
def test_setLevelSublog(): """ Test setLevel and getLevel: set sublog level """ _, log, sublog = gLoggerReset() levels = gLogger.getAllPossibleLevels() # set gLogger and log level gLogger.setLevel('notice') log.setLevel('warn') # by changing sublog level, gLogger and log should not be affected for level in levels: sublog.setLevel(level) assert gLogger.getLevel() == 'NOTICE' assert log.getLevel() == 'WARN' assert sublog.getLevel() == level.upper()
def test_showFormatOptionsLog(header, threadID, msg, expectedLog, isThreadIDAvailable): """ Set log (child of gLogger) options, check that options are inherited in sublog """ capturedBackend, log, sublog = gLoggerReset() # set gLogger options, they should not be modified gLogger.showHeaders(True) gLogger.showThreadIDs(False) # set log options log.showHeaders(header) log.showThreadIDs(threadID) # sublog should inherit from the changes, gLogger should not be affected assert gLogger._options['headerIsShown'] assert not gLogger._options['threadIDIsShown'] assert log._options['headerIsShown'] == header assert log._options['threadIDIsShown'] == threadID assert sublog._options['headerIsShown'] == log._options['headerIsShown'] assert sublog._options['threadIDIsShown'] == log._options['threadIDIsShown'] # create log records and check the format is correct gLogger.notice(msg) logstring = cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) log.notice(msg) logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) sublog.notice(msg) logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) expectedLog = "Framework NOTICE: message\n" + expectedLog threadIDValue = str(thread.get_ident()) assert (threadIDValue in logstring) == isThreadIDAvailable # as thread ID depends on the execution, we have to add it to the expected results if isThreadIDAvailable: expectedLog = expectedLog % (threadIDValue, threadIDValue) assert expectedLog == logstring
def test_showFormatOptionsPropag(): """ Make sure log and sublog don't inherit from gLogger options if already set """ capturedBackend, log, sublog = gLoggerReset() # set logger options log.showHeaders(False) log.showThreadIDs(False) # then, set gLogger options again gLogger.showHeaders(True) gLogger.showThreadIDs(True) # log should not inherit from the options of gLogger as it has been modified by a developer # subLog shoud inherit from log, it has not been modified assert gLogger._options["headerIsShown"] assert gLogger._options["threadIDIsShown"] assert log._options["headerIsShown"] != gLogger._options["headerIsShown"] assert log._options["threadIDIsShown"] != gLogger._options[ "threadIDIsShown"] assert sublog._options["headerIsShown"] == log._options["headerIsShown"] assert sublog._options["threadIDIsShown"] == log._options[ "threadIDIsShown"] # a log record is sent, we then get the result to see if options have been taken into account gLogger.notice("me") logstring = cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) log.notice("ss") logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) sublog.notice("age") logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) threadID = str(_thread.get_ident()) expectedLog = "Framework [%s] NOTICE: me\nss\nage\n" % threadID assert expectedLog == logstring
def test_showFormatOptionsInit(): """ Check showHeaders and showThreadIDs methods at initialization """ capturedBackend, log, sublog = gLoggerReset() # first, make sure options are inherited from gLogger assert gLogger._options["headerIsShown"] assert gLogger._options["timeStampIsShown"] assert gLogger._options["contextIsShown"] assert not gLogger._options["threadIDIsShown"] assert log._options["headerIsShown"] == gLogger._options["headerIsShown"] assert log._options["timeStampIsShown"] == gLogger._options[ "timeStampIsShown"] assert log._options["contextIsShown"] == gLogger._options["contextIsShown"] assert log._options["threadIDIsShown"] == gLogger._options[ "threadIDIsShown"] assert sublog._options["headerIsShown"] == log._options["headerIsShown"] assert sublog._options["timeStampIsShown"] == log._options[ "timeStampIsShown"] assert sublog._options["contextIsShown"] == log._options["contextIsShown"] assert sublog._options["threadIDIsShown"] == log._options[ "threadIDIsShown"] # create log records and check that the format is correct gLogger.notice("me") logstring = cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) log.notice("ss") logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) sublog.notice("age") logstring += cleaningLog(capturedBackend.getvalue()) capturedBackend.truncate(0) capturedBackend.seek(0) assert logstring == "Framework NOTICE: me\nFramework/log NOTICE: ss\nFramework/log/sublog NOTICE: age\n"
def test_getSubLoggerLogRecord(): """ Create some subloggers and create a log record """ capturedBackend, log, sublog = gLoggerReset() # Send a first log with a simple sublogger log.always("message") assert " Framework/log " in capturedBackend.getvalue() # Reinitialize the buffer and send a log with a child of the sublogger capturedBackend.truncate(0) capturedBackend.seek(0) sublog.always("message") assert " Framework/log/sublog " in capturedBackend.getvalue() # Generate a new sublogger from sublog capturedBackend.truncate(0) capturedBackend.seek(0) subsublog = sublog.getSubLogger("subsublog") subsublog.always("message") assert " Framework/log/sublog/subsublog " in capturedBackend.getvalue()