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_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_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_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_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 getContentFromFilename(backendOptions): """Get content from the file attached to a given backend and erase the content from the file.""" filename = backendOptions.get("FileName") if not filename: return None # get the content of the file with open(filename, "r") as fileContent: content = fileContent.read() # clean the content lines = content.split("\n") cleanContent = "" for line in lines: cleanContent += cleaningLog(line) # reset the file with open(filename, "w") as fileContent: pass return cleanContent
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