public void CanChangeTraceLevel()
{
var loggerResult = new LoggerEventArgs();
var testClass = new MockLoggingClass();
var logger = testClass.GetLogger();
testClass.LoggerEvent += (sender, args) =>
{
loggerResult = args;
};
const string expectedMessage = "- Hello World";
// Default priority for LogVerbose is low - we'll change to high
testClass.LogMessage(logger.LogVerbose,
"Hello {0}", "World", Priority.High);
Assert.AreEqual(Category.Debug, loggerResult.Category);
Assert.AreEqual(Priority.High, loggerResult.Priority);
Assert.AreEqual(expectedMessage, loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
// Set trace level to verbose
var appSettings = testClass.GetAppSettings();
appSettings.TraceLevel = (int)GwnTraceLevel.Verbose;
testClass.LogMessage(logger.LogVerbose, expectedMessage);
Assert.IsTrue(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogInfo, expectedMessage);
Assert.IsTrue(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogWarning, expectedMessage);
Assert.IsTrue(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogError, expectedMessage);
Assert.IsTrue(loggerResult.IsLoggingPermitted);
// Set trace level to Info (level 3)
appSettings.TraceLevel = (int)GwnTraceLevel.Info;
// Verbose should be false (level 4)
testClass.LogMessage(logger.LogVerbose, expectedMessage);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
// Info should be true (level 3)
testClass.LogMessage(logger.LogInfo, expectedMessage);
Assert.IsTrue(loggerResult.IsLoggingPermitted);
}
public void CanChangeDefaultPriority()
{
var loggerResult = new LoggerEventArgs();
var testClass = new MockLoggingClass();
var logger = testClass.GetLogger();
testClass.LoggerEvent += (sender, args) =>
{
loggerResult = args;
};
// Default priority for LogVerbose is low - we'll change to high
testClass.LogMessage(logger.LogVerbose,
"Hello {0}", "World", Priority.High);
Assert.AreEqual(Category.Debug, loggerResult.Category);
Assert.AreEqual(Priority.High, loggerResult.Priority);
Assert.AreEqual("- Hello World", loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
}
/// <summary>
/// Logs the specified message using standard Prism logger
/// (ILoggerFacade). All of the other logging methods, which
/// implement IGwnLogger, call this method - it ia a single
/// entry point.
/// <br></br><br></br>
/// The <see cref="GwnSwitch"/> is used to determine if logging
/// is enabled for the specified category (debug, info, warn, error)
/// based on the AppSettings.TraceLevel value. If enabled the
/// virtual method LogTheMessage(sender, LoggerEventArgs) is called
/// so the message can be logged. When logged the LoggerEvent
/// will be published via the event aggregator.
/// <br></br> <br></br>
/// The LoggerEvent of this class, unlike the IOC Logger event (which
/// uses the event aggregator), *always* publishes the logging contents
/// (mainly for TDD and display in diagnostic status controls). The
/// IsLoggingPermitted property of the logger event args will indicate
/// whether the logged entry was loggable by the <see cref="GwnSwitch"/>
/// </summary>
/// <param name="message">The message.</param>
/// <param name="category">The category.</param>
/// <param name="priority">The priority.</param>
public void Log(string message, Category category, Priority priority)
{
// Determine if the trace level will allow logging
var isLoggingPermitted = Switch
.TraceLevelAllowsLogging(category, priority);
// Create event argument for logging and event
var args = new LoggerEventArgs
{
Message = message,
Category = category,
Priority = priority,
IsLoggingPermitted = isLoggingPermitted
};
// If permitted log the message
if (isLoggingPermitted)
LogTheMessage(this, args);
// Raise event that message was requested (even if not logged)
OnLoggerEvent(args);
}
/// <summary>
/// Handles the <see cref="E:LoggerEvent" /> event.
/// </summary>
/// <param name="e">The
/// <see cref="Gwn.Library.Common.Events.LoggerEventArgs" />
/// instance containing the event data.</param>
protected virtual void OnLoggerEvent(LoggerEventArgs e)
{
LoggerEvent?.Invoke(this, e);
}
/// <summary>
/// Logs the message using default logging behavior for category,
/// priority, and trace level. Intended to be overridden so that
/// derived classes can use the standard business logic, i.e., for
/// tracelevel, while being able to alter the output destination of
/// the logged message. By default this method logs to Debug.Writeline()
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="LoggerEventArgs"/> instance
/// containing the event data.</param>
protected virtual void LogTheMessage(object sender, LoggerEventArgs e)
{
Debug.WriteLine(e.Message);
}
public void CanUpdateLoggingWithClassNamePrefix()
{
var loggerResult = new LoggerEventArgs();
var testClass = new MockLoggingClass();
var logger = testClass.GetLogger();
testClass.LoggerEvent += (sender, args) =>
{
loggerResult = args;
};
const string expectedMessage =
"- GwnLoggerFixture.MethodName: Hello World 100";
// ^^^^^^^^^^^^^^^^
// Default priority for LogVerbose is low - we'll change to high
// by placing Priority.High in the parameter list. We'll also send
// "this" which will cause the class name to prefix the logging result
testClass.LogMessage(logger.LogVerbose,
"MethodName: Hello {0} {1}", "World",
100, Priority.High, this);
Assert.AreEqual(Category.Debug, loggerResult.Category);
Assert.AreEqual(Priority.High, loggerResult.Priority);
Assert.AreEqual(expectedMessage, loggerResult.Message);
}
public void CanOverridePriority()
{
var loggerResult = new LoggerEventArgs();
var testClass = new MockLoggingClass();
var logger = testClass.GetLogger();
testClass.LoggerEvent += (sender, args) =>
{
loggerResult = args;
};
testClass.LogMessage(logger.LogError, "Hello {0}","World");
Assert.AreEqual(Category.Exception, loggerResult.Category);
Assert.AreEqual(Priority.High, loggerResult.Priority);
Assert.AreEqual("X Hello World", loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogWarning, "TraceLevel = {0}", 2);
Assert.AreEqual(Category.Warn, loggerResult.Category);
Assert.AreEqual(Priority.Medium, loggerResult.Priority);
Assert.AreEqual("! TraceLevel = 2", loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogInfo, "{0} Information", "Good");
Assert.AreEqual(Category.Info, loggerResult.Category);
Assert.AreEqual(Priority.Low, loggerResult.Priority);
Assert.AreEqual("+ Good Information", loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
testClass.LogMessage(logger.LogVerbose, "To much {0}", "Information");
Assert.AreEqual(Category.Debug, loggerResult.Category);
Assert.AreEqual(Priority.Low, loggerResult.Priority);
Assert.AreEqual("- To much Information", loggerResult.Message);
Assert.IsFalse(loggerResult.IsLoggingPermitted);
}