public void StoppingQueueLogWriterHaltsWriting()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
using (backgroundMultiLogWriter)
{
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
queueEntryWriter.Stop();
queueEntryWriter.Stop(); // Stopping twice shouldn't change things
// These messages aren't logged
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
queueEntryWriter.Start();
queueEntryWriter.Start(); // Starting twice shouldn't change things
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
}
Assert.False(backgroundMultiLogWriter.IsBackgroundThreadRunning);
Assert.Equal(2 * 8 * 8, innerLogWriter.Count);
}
public void QueueLogWriterCanBeDisposedEarly()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
using (backgroundMultiLogWriter)
{
using (queueEntryWriter as IDisposable)
{
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
}
Assert.False(queueEntryWriter.IsEnabled);
Assert.False(queueEntryWriter.IsStarted);
Assert.True(backgroundMultiLogWriter.IsStarted);
// Can't restart after Dispose()
Assert.Throws <ObjectDisposedException>(() => queueEntryWriter.Start());
// Logging still doesn't throw after Dispose
var msg = new MessageEntry("Logged while Dispose()ed - never logged.");
queueEntryWriter.Write(ref msg);
}
Assert.False(backgroundMultiLogWriter.IsStarted);
Assert.False(backgroundMultiLogWriter.IsBackgroundThreadRunning);
Assert.Equal(8 * 8, innerLogWriter.Count);
}
public void EnsureTraceMessageIsTruncated()
{
var testLogWriter = new TestLogWriter
{
ErrorEnabled = true,
InformationEnabled = true,
TraceEnabled = true,
WarningEnabled = true
};
var logWriters = new List <IEventLogWriter> {
testLogWriter
};
var eventLog = new EventLog(logWriters);
var msg = "T" + Guid.NewGuid();
eventLog.WriteTrace(msg);
Assert.AreEqual(msg, testLogWriter.LastEntry.Message);
msg = string.Join("", Enumerable.Repeat("T", 15000));
var truncatedMsg = msg.Substring(0, 10000);
eventLog.WriteTrace(msg);
Assert.AreEqual(truncatedMsg, testLogWriter.LastEntry.Message);
}
public void DisposePreventsRestart()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
backgroundMultiLogWriter.Dispose(); // Blocks until the background thread exits
// After a Dispose(), BackgroundMultiLogWriter can't be re-used
Assert.Throws <ObjectDisposedException>(() => backgroundMultiLogWriter.Start());
// Logging doesn't throw, though
var msg = new MessageEntry("Logged while Dispose()ed - never logged.");
queueEntryWriter.Write(ref msg);
}
public void CanRestartBackgroundMultiLogWriter()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
// Re-starting shouldn't hurt anything
Assert.True(backgroundMultiLogWriter.IsStarted);
backgroundMultiLogWriter.Start();
queueEntryWriter.Start();
// Log some, then Stop
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
backgroundMultiLogWriter.Stop(); // Blocks until the background thread exits
Assert.False(innerLogWriter.IsStarted);
Assert.False(backgroundMultiLogWriter.IsStarted);
Assert.Equal(8 * 8, innerLogWriter.Count);
// After a Stop(), logging does nothing
var msg = new MessageEntry("Logged while stopped - never logged.");
queueEntryWriter.Write(ref msg);
// After a Stop(), BackgroundMultiLogWriter and it's contained logwriters can be restarted
backgroundMultiLogWriter.Start();
// Log some, then Dispose
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
backgroundMultiLogWriter.Dispose(); // Blocks until the background thread exits
Assert.False(innerLogWriter.IsStarted);
Assert.False(backgroundMultiLogWriter.IsStarted);
Assert.Equal(2 * 8 * 8, innerLogWriter.Count);
// After a Dispose(), BackgroundMultiLogWriter can't be re-used
Assert.Throws <ObjectDisposedException>(() => backgroundMultiLogWriter.Start());
// Entries can still be written, though
queueEntryWriter.Write(ref msg);
}
public LoggerShould(ITestOutputHelper output) : base(output)
{
_logEnricher = new Mock <ILogEnricher>();
_logWriter = new Mock <ILogWriter>();
_testLogWriter = new TestLogWriter();
var provider = new DependencyCollection()
.AddLogging()
.AddJsonConverter() // for register IConvertersCollection
.AddDefaultLogEnrichers()
.AddLogWriter(_testLogWriter)
.AddLogWriter(_logWriter.Object)
.AddLogWriter <ConsoleLogWriter>()
.AddLogEnricher(_logEnricher.Object)
.AddLogEnricher <TestLogEnricher>()
.BuildProvider();
_convertersCollection = provider.GetRequiredService <IConvertersCollection>();
_logger = provider.GetRequiredService <ILogger <LoggerShould> >();
}
public void TestLogWriters()
{
TestLogWriter tlw = new TestLogWriter();
Log.AddLogWriter(tlw, null);
Log.Debug("Test1");
Assert.AreEqual("Test1", tlw.LastMessage);
Assert.AreEqual(LogLevel.Debug, tlw.LastLogLevel);
Assert.IsNull(tlw.LastLogFormatter);
Log.Information("Test2");
Assert.AreEqual("Test2", tlw.LastMessage);
Assert.AreEqual(LogLevel.Information, tlw.LastLogLevel);
Log.Error("Test3");
Assert.AreEqual("Test3", tlw.LastMessage);
Assert.AreEqual(LogLevel.Error, tlw.LastLogLevel);
}
