private static ILog GetLoggerForUseWithScope()
{
var adapter = new CuttingEdgeLoggerFactoryAdapter();
var scopeProvider = LoggingProviderScope.GetProviderFromConfiguration();
return(adapter.GetLogger(scopeProvider.Name));
}
public void Initialize_WithIncorrectLoggingProviderName_LogsToExpectedProvider()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var provider = new LoggingWebEventProvider();
var invalidConfiguration = CreateValidConfiguration();
invalidConfiguration.Add("loggingProvider", "NON EXISTING PROVIDER");
// Act
provider.Initialize("Valid name", invalidConfiguration);
}
}
public void Info_WithValidMessage_LogsEventWithSeverityInformation()
{
// Arrange
ILog cuttingEdgeLogger = GetLoggerForUseWithScope();
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
cuttingEdgeLogger.Info("message to log");
// Assert
Assert.AreEqual(LoggingEventType.Information, scope.LoggedEntries.First().Severity);
}
}
public void ProcessEvent_WithNullEvent_SucceedsButDoesNotLog()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var provider = CreateInitializedProvider();
// Act
provider.ProcessEvent(null);
// Assert
Assert.AreEqual(0, scope.LoggedEntries.Count);
}
}
public void Shutdown_Always_SucceedsButDoesNotLog()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var provider = CreateInitializedProvider();
// Act
provider.Shutdown();
// Assert
Assert.AreEqual(0, scope.LoggedEntries.Count);
}
}
public void ProcessEvent_WithCorrectlyConfiguredProviderWithNoProviderSet_LogsToDefaultProvider()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var provider = CreateInitializedProvider();
WebBaseEvent webEvent = new DerivedWebErrorEvent("Valid message", null, 1, new Exception());
// Act
provider.ProcessEvent(webEvent);
// Assert
Assert.AreEqual(1, scope.LoggedEntries.Count);
}
}
public void Debug_WithMessage_LogsThatMessage()
{
// Arrange
object expectedMessage = "some message";
ILog cuttingEdgeLogger = GetLoggerForUseWithScope();
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
cuttingEdgeLogger.Debug(expectedMessage);
// Assert
Assert.AreEqual(expectedMessage, scope.LoggedEntries.First().Message);
}
}
public void LogUnhandledException_EventArgsWithHttpUnhandledException_DoesLog()
{
// Arrange
var moduleUnderTest = new TestAspNetExceptionLoggingModule();
object exceptionToLog = new HttpUnhandledException();
var eventArgs = new UnhandledExceptionEventArgs(exceptionToLog, false);
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
moduleUnderTest.LogUnhandledException(null, eventArgs);
// Assert
Assert.AreEqual(1, scope.LoggedEntries.Count());
}
}
public void Debug_WithEmptyMessage_LogsTemplateMessage()
{
// Arrange
const string TemplateMessage = "No message supplied";
object message = string.Empty;
ILog cuttingEdgeLogger = GetLoggerForUseWithScope();
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
cuttingEdgeLogger.Debug(message);
// Assert
Assert.AreEqual(TemplateMessage, scope.LoggedEntries.First().Message);
}
}
public void ProcessEvent_WithWebFailureAuditEvent_LogsAsWarning()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedSeverity = LoggingEventType.Warning;
var provider = CreateInitializedProvider();
WebBaseEvent webEvent = new DerivedWebFailureAuditEvent("Valid message", null, 1);
// Act
provider.ProcessEvent(webEvent);
// Assert
var actualSeverity = scope.LoggedEntries.First().Severity;
Assert.AreEqual(expectedSeverity, actualSeverity);
}
}
public void Log_WithExceptionWithMessage_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "Expected message in entry";
var expectedEntry =
new LogEntry(LoggingEventType.Information, expectedMessage, null, null);
// Act
Logger.Log(expectedMessage);
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void ProcessEvent_WithCorrectlyConfiguredProviderWithProviderSet_LogsToExpectedProvider()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var provider = new LoggingWebEventProvider();
var configuration = new NameValueCollection();
configuration.Add("loggingProvider", "UnitTestingLoggingProvider");
provider.Initialize("Valid name", configuration);
WebBaseEvent webEvent = new DerivedWebErrorEvent("Valid message", null, 1, new Exception());
// Act
provider.ProcessEvent(webEvent);
// Assert
Assert.AreEqual(1, scope.LoggedEntries.Count);
}
}
public void Error_WithoutException_DoesNotLog()
{
// Arrange
var expectedNumberOfLogEntries = 0;
var moduleUnderTest = new FakeAspNetExceptionLoggingModule();
var context = new HttpApplication();
moduleUnderTest.Init(context);
using (var scope = new LoggingProviderScope())
{
// Act
RaisErrorOnContext(context, null);
// Assert
Assert.AreEqual(expectedNumberOfLogEntries, scope.LoggedEntries.Count);
}
}
public void LogUnhandledException_EventArgsWithException_LogsCriticalEvent()
{
// Arrange
var expectedSeverity = LoggingEventType.Critical;
var moduleUnderTest = new TestAspNetExceptionLoggingModule();
object exceptionToLog = new Exception();
var eventArgs = new UnhandledExceptionEventArgs(exceptionToLog, false);
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
moduleUnderTest.LogUnhandledException(null, eventArgs);
// Assert
Assert.AreEqual(expectedSeverity, scope.LoggedEntries.First().Severity);
}
}
public void Error_WithException_LogsEventWithSeverityOfError()
{
// Arrange
var expectedSeverity = LoggingEventType.Error;
var moduleUnderTest = new TestAspNetExceptionLoggingModule();
var context = new HttpApplication();
moduleUnderTest.Init(context);
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
RaisErrorOnContext(context, new Exception());
// Assert
Assert.AreEqual(expectedSeverity, scope.LoggedEntries.First().Severity);
}
}
public void ProcessEvent_WithDerivedWebErrorEvent_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedSeverity = LoggingEventType.Error;
var provider = CreateInitializedProvider();
WebBaseEvent webEvent = new DerivedWebErrorEvent("Valid message", null, 1, new Exception());
// Act
provider.ProcessEvent(webEvent);
// Assert
var loggedEntry = scope.LoggedEntries.First();
Assert.AreEqual(expectedSeverity, loggedEntry.Severity);
Assert.IsNotNull(loggedEntry.Exception);
}
}
public void Log_WithValidArguments_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedSeverity = LoggingEventType.Error;
var expectedMessage = "Expected message in entry";
var expectedEntry =
new LogEntry(expectedSeverity, expectedMessage, null, null);
// Act
Logger.Log(expectedSeverity, expectedMessage);
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void Log_WithExceptionWithoutMessage_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "InvalidOperationException";
var exceptionToLog = new InvalidOperationException(string.Empty);
var expectedEntry =
new LogEntry(LoggingEventType.Error, expectedMessage, null, exceptionToLog);
// Act
Logger.Log(exceptionToLog);
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void Error_WithException_LogsException()
{
// Arrange
var moduleUnderTest = new TestAspNetExceptionLoggingModule();
var context = new HttpApplication();
var expectedException = new Exception();
moduleUnderTest.Init(context);
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
RaisErrorOnContext(context, expectedException);
var actualException = scope.LoggedEntries.First().Exception;
// Assert
Assert.AreEqual(expectedException, actualException);
}
}
public void Error_WithHttpUnhandledExceptionWithInnerException_LogsInnerException()
{
// Arrange
var moduleUnderTest = new TestAspNetExceptionLoggingModule();
var context = new HttpApplication();
var expectedException = new InvalidOperationException();
var exceptionForError = new HttpUnhandledException("some message", expectedException);
moduleUnderTest.Init(context);
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Act
RaisErrorOnContext(context, exceptionForError);
var actualException = scope.LoggedEntries.First().Exception;
// Assert
Assert.AreEqual(expectedException, actualException);
}
}
public void Log_WithValidArguments_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "Expected message in entry";
var expectedSource =
this.GetType().FullName + ".Log_WithValidArguments_LogsExpectedEntry()";
var expectedEntry =
new LogEntry(LoggingEventType.Information, expectedMessage, expectedSource, null);
// Act
Logger.Log(expectedMessage, MethodBase.GetCurrentMethod());
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void Log_WithValidArguments_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "Expected message in entry";
var expectedException = new Exception();
var expectedSource = "Expected source text";
var expectedEntry =
new LogEntry(LoggingEventType.Error, expectedMessage, expectedSource, expectedException);
// Act
Logger.Log(expectedMessage, expectedException, expectedSource);
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void Log_WithExceptionWithoutMessage_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "NotSupportedException";
var exceptionToLog = new NotSupportedException(string.Empty);
var expectedSource = "CuttingEdge.Logging.Tests.Unit.LoggerTests.LogExceptionMethodBaseTests." +
"Log_WithExceptionWithoutMessage_LogsExpectedEntry()";
var expectedEntry =
new LogEntry(LoggingEventType.Error, expectedMessage, expectedSource, exceptionToLog);
// Act
Logger.Log(exceptionToLog, MethodBase.GetCurrentMethod());
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
public void Log_WithMethodBaseWithParameters_LogsExpectedEntry()
{
using (var scope = new LoggingProviderScope(ScopeOption.AllowOnlyASingleEntryToBeLogged))
{
// Arrange
var expectedMessage = "Expected message in entry";
int notImportant;
MethodBase sourceToLog = CreateMethodBaseFromThisMethod("not important", out notImportant);
var expectedSource =
this.GetType().FullName + ".CreateMethodBaseFromThisMethod(String, out Int32&)";
var expectedEntry =
new LogEntry(LoggingEventType.Information, expectedMessage, expectedSource, null);
// Act
Logger.Log(expectedMessage, sourceToLog);
// Assert
var loggedEntry = scope.LoggedEntries.First();
AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
}
}
