public void ParametrizedScopeWrite()
{
var logProcessor = new TestLogProcessor();
ILogger logger = new ColoredLogger("Test logger", new LoggerExternalScopeProvider(), logProcessor);
using (logger.BeginParamScope(("testKey3", "testVal3"), ("testKey4", "testVal4")))
{
logger.LogInformation("Sample message");
}
var firstLogEntry = logProcessor.Log.FirstOrDefault();
Assert.IsNotNull(firstLogEntry, "Log not passed to ILogProcessor");
var logList = firstLogEntry.ToList();
Assert.IsTrue(logList[0].String.StartsWith("[ INFO | 2 | "), "Incorrect 'header' start");
Assert.IsNull(logList[0].BackgroundColor, "header BackgroundColor is not null");
Assert.AreEqual(logList[0].ForegroundColor, ConsoleColor.Green, "header ForegroundColor color is not Green");
Assert.IsTrue(logList[0].String.EndsWith("Test logger:\n"), "Incorrect 'header' end");
Assert.AreEqual(logList[1].String, "testKey3: testVal3, testKey4: testVal4", "Incorrect 'scope'");
Assert.AreEqual(logList[3].String, "testKey3: testVal3\ntestKey4: testVal4\n", "Incorrect 'params' from scope");
Assert.AreEqual(logList[4].String, "Sample message", "Incorrect 'message'");
Assert.AreEqual(logList[5].String, "\n", "Incorrect 'padding'");
}
public void ProcessLogEntryCallsSendToLogProviderForEachLogProvider()
{
var logProcessor = new TestLogProcessor();
var mockContextProvider = new Mock <IContextProvider>();
var mockLogProvider1 = new Mock <ILogProvider>();
var mockLogProvider2 = new Mock <ILogProvider>();
var logger = new Logger(logProcessor,
logProviders: new[] { mockLogProvider1.Object, mockLogProvider2.Object },
contextProviders: new[] { mockContextProvider.Object });
var logEntry = new LogEntry();
logProcessor.ProcessLogEntry(logger, logEntry);
logProcessor.SendToLogProviderInvocations.Count.Should().Be(2);
var invocation1 = logProcessor.SendToLogProviderInvocations[0];
var invocation2 = logProcessor.SendToLogProviderInvocations[1];
invocation1.LogProvider.Should().BeSameAs(mockLogProvider1.Object);
invocation1.LogEntry.Should().BeSameAs(logEntry);
invocation1.ErrorHandler.Should().BeSameAs(NullErrorHandler.Instance);
invocation1.FailureCount.Should().Be(0);
invocation2.LogProvider.Should().BeSameAs(mockLogProvider2.Object);
invocation2.LogEntry.Should().BeSameAs(logEntry);
invocation2.ErrorHandler.Should().BeSameAs(NullErrorHandler.Instance);
invocation2.FailureCount.Should().Be(0);
logProcessor.HandleErrorInvocations.Should().BeEmpty();
}
public void ProcessLogEntryDoesNotCallSendToLogProviderForLogProvidersWithALevelGreaterThanTheLogEntry()
{
var logProcessor = new TestLogProcessor();
var mockContextProvider = new Mock <IContextProvider>();
var mockLogProvider1 = new Mock <ILogProvider>();
var mockLogProvider2 = new Mock <ILogProvider>();
mockLogProvider1.Setup(m => m.Level).Returns(LogLevel.Error);
mockLogProvider2.Setup(m => m.Level).Returns(LogLevel.Info);
var logger = new Logger(logProcessor,
logProviders: new[] { mockLogProvider1.Object, mockLogProvider2.Object },
contextProviders: new[] { mockContextProvider.Object });
var logEntry = new LogEntry()
{
Level = LogLevel.Info
};
logProcessor.ProcessLogEntry(logger, logEntry);
logProcessor.SendToLogProviderInvocations.Count.Should().Be(1);
var invocation = logProcessor.SendToLogProviderInvocations[0];
invocation.LogProvider.Should().BeSameAs(mockLogProvider2.Object);
invocation.LogEntry.Should().BeSameAs(logEntry);
invocation.ErrorHandler.Should().BeSameAs(NullErrorHandler.Instance);
invocation.FailureCount.Should().Be(0);
logProcessor.HandleErrorInvocations.Should().BeEmpty();
}
public void IfErrorHandlerSetsShouldRetryToTrueSendToLogProviderIsCalled()
{
IErrorHandler errorHandler = DelegateErrorHandler.New(error =>
{
if (error.FailureCount < 2)
{
error.ShouldRetry = true;
}
});
var logProcessor = new TestLogProcessor();
var exception = new Exception();
var logProvider = new Mock <ILogProvider>().Object;
var logEntry = new LogEntry();
logProcessor.Unlock().HandleError(exception, logProvider, logEntry, errorHandler, 1, "Oops: {0}", new object[] { 123 });
logProcessor.SendToLogProviderInvocations.Count.Should().Be(1);
var sendToLogProviderInvocation = logProcessor.SendToLogProviderInvocations[0];
sendToLogProviderInvocation.LogProvider.Should().BeSameAs(logProvider);
sendToLogProviderInvocation.LogEntry.Should().BeSameAs(logEntry);
sendToLogProviderInvocation.ErrorHandler.Should().BeSameAs(errorHandler);
sendToLogProviderInvocation.FailureCount.Should().Be(1);
}
public void IfSendToLogProviderThrowsHandleErrorIsCalled()
{
var logProcessor = new TestLogProcessor(sendToLogProviderShouldThrow: true);
var mockContextProvider = new Mock <IContextProvider>();
var mockLogProvider = new Mock <ILogProvider>();
var logger = new Logger(logProcessor,
logProviders: new[] { mockLogProvider.Object },
contextProviders: new[] { mockContextProvider.Object });
var logEntry = new LogEntry();
logProcessor.ProcessLogEntry(logger, logEntry);
logProcessor.HandleErrorInvocations.Count.Should().Be(1);
var invocation = logProcessor.HandleErrorInvocations[0];
invocation.Exception.Message.Should().Be("error.");
invocation.LogProvider.Should().BeSameAs(mockLogProvider.Object);
invocation.LogEntry.Should().BeSameAs(logEntry);
invocation.ErrorHandler.Should().BeSameAs(NullErrorHandler.Instance);
invocation.FailureCount.Should().Be(1);
}
public void DisposeSetsIsDisposedToTrue()
{
var logProcessor = new TestLogProcessor();
logProcessor.Dispose();
logProcessor.IsDisposed.Should().Be(true);
}
public void SimpleWrite()
{
var logProcessor = new TestLogProcessor();
ILogger logger = new JsonLogger("Test logger", new LoggerExternalScopeProvider(), logProcessor);
logger.LogInformation("Sample message");
var firstLogEntry = logProcessor.Log.FirstOrDefault();
Assert.IsNotNull(firstLogEntry, "Log not passed to ILogProcessor");
JObject jsonObject = JsonConvert.DeserializeObject <JObject>(firstLogEntry.First().String);
Assert.AreEqual(jsonObject["message"].ToString(), "Sample message");
Assert.AreEqual(jsonObject["log_name"]?.ToString(), "Test logger");
Assert.AreEqual(jsonObject["level"].ToString(), 2.ToString());
Assert.AreEqual(jsonObject["level_string"]?.ToString(), "INFO");
}
public void ProcessLogEntryCallsContextProvidersAddContextMethod()
{
var logProcessor = new TestLogProcessor();
var mockContextProvider1 = new Mock <IContextProvider>();
var mockContextProvider2 = new Mock <IContextProvider>();
var mockLogProvider = new Mock <ILogProvider>();
var logger = new Logger(logProcessor,
logProviders: new[] { mockLogProvider.Object },
contextProviders: new[] { mockContextProvider1.Object, mockContextProvider2.Object });
var logEntry = new LogEntry();
logProcessor.ProcessLogEntry(logger, logEntry);
mockContextProvider1.Verify(m => m.AddContext(logEntry), Times.Once);
mockContextProvider2.Verify(m => m.AddContext(logEntry), Times.Once);
}
public void SimpleWrite()
{
var logProcessor = new TestLogProcessor();
ILogger logger = new ColoredLogger("Test logger", new LoggerExternalScopeProvider(), logProcessor);
logger.LogInformation("Sample message");
var firstLogEntry = logProcessor.Log.FirstOrDefault();
Assert.IsNotNull(firstLogEntry, "Log not passed to ILogProcessor");
var logList = firstLogEntry.ToList();
Assert.IsTrue(logList[0].String.StartsWith("[ INFO | 2 | "), "Incorrect 'header' start");
Assert.IsNull(logList[0].BackgroundColor, "header BackgroundColor is not null");
Assert.AreEqual(logList[0].ForegroundColor, ConsoleColor.Green, "header ForegroundColor color is not Green");
Assert.IsTrue(logList[0].String.EndsWith("Test logger:\n"), "Incorrect 'header' end");
Assert.AreEqual(logList[1].String, "Sample message", "Incorrect 'message'");
Assert.AreEqual(logList[2].String, "\n", "Incorrect 'padding'");
}
public void IfRetriedSendToLogProviderThrowsHandleErrorIsCalled()
{
IErrorHandler errorHandler = DelegateErrorHandler.New(error =>
{
if (error.FailureCount < 2)
{
error.ShouldRetry = true;
}
});
var logProcessor = new TestLogProcessor(sendToLogProviderShouldThrow: true);
var exception = new Exception();
var logProvider = new Mock <ILogProvider>().Object;
var logEntry = new LogEntry();
logProcessor.Unlock().HandleError(exception, logProvider, logEntry, errorHandler, 1, "Oops: {0}", new object[] { 123 });
logProcessor.HandleErrorInvocations.Count.Should().Be(2);
var invocation1 = logProcessor.HandleErrorInvocations[0];
var invocation2 = logProcessor.HandleErrorInvocations[1];
// Original HandleError call
invocation1.Exception.Should().BeSameAs(exception);
invocation1.LogProvider.Should().BeSameAs(logProvider);
invocation1.LogEntry.Should().BeSameAs(logEntry);
invocation1.FailureCount.Should().Be(1);
invocation1.ErrorMessageFormat.Should().Be("Oops: {0}");
// Resend HandleError call
invocation2.Exception.Should().NotBeSameAs(exception);
invocation2.Exception.Message.Should().Be("error.");
invocation2.LogProvider.Should().BeSameAs(logProvider);
invocation2.LogEntry.Should().BeSameAs(logEntry);
invocation2.FailureCount.Should().Be(2);
invocation2.ErrorMessageFormat.Should().Be("Error while re-sending log entry {0} to log provider {1}.");
}
public void HandleErrorInvokesErrorHandlerCallbackWhenProvided()
{
Error capturedError = null;
IErrorHandler errorHandler = DelegateErrorHandler.New(error =>
{
capturedError = error;
});
var logProcessor = new TestLogProcessor();
var exception = new Exception();
var logProvider = new Mock <ILogProvider>().Object;
var logEntry = new LogEntry();
logProcessor.Unlock().HandleError(exception, logProvider, logEntry, errorHandler, 321, "Oops: {0}", new object[] { 123 });
capturedError.Should().NotBeNull();
capturedError.Exception.Should().BeSameAs(exception);
capturedError.LogProvider.Should().BeSameAs(logProvider);
capturedError.LogEntry.Should().BeSameAs(logEntry);
capturedError.FailureCount.Should().Be(321);
capturedError.Message.Should().Be("Oops: 123");
}
public void IsDisposedIsFalseInitially()
{
var logProcessor = new TestLogProcessor();
logProcessor.IsDisposed.Should().Be(false);
}
