public void AppendTest()
{
var myPath = $"{typeof(DebouncingFileLoggingTests).Namespace}.{Path.GetRandomFileName()}.log";
var testedQueuedFileLogger = new QueuedLoggerWrapper(new FileLoggerBase(myPath), new PassiveDebouncer());
try
{
var expectedError1 = new Exception("testError1");
var expectedError2 = "testError2";
var expectedWarning = "testWarning1";
var expectedinfo = "testInfo1";
testedQueuedFileLogger.LogError(expectedError1);
testedQueuedFileLogger.LogError(expectedError2);
testedQueuedFileLogger.LogWarning(expectedWarning);
testedQueuedFileLogger.LogInfo(expectedinfo);
testedQueuedFileLogger.Flush();
var received = File.ReadAllText(myPath);
Assert.True(File.Exists(myPath));
Assert.Contains(expectedError1.Message, received);
Assert.Contains(expectedError2, received);
Assert.Contains(expectedWarning, received);
Assert.Contains(expectedinfo, received);
Assert.Contains(MessageSeverity.Error.ToString(), received);
Assert.Contains(MessageSeverity.Warning.ToString(), received);
Assert.Contains(MessageSeverity.Information.ToString(), received);
}
finally
{
testedQueuedFileLogger.Dispose();
File.Delete(myPath);
}
}
private static void Main(string[] args)
{
Console.WriteLine("Hello in Passive Debouncer test harness! " +
"This is the load test. The file logger will be spammed with the number of messages (random GUIDs) you choose from multiple threads." +
" The debouncer role is to keep the messages queued in memory and not flush immidiatly. How many messages would you like to send from the thread pool?");
Console.Write("Number of messages: ");
var line = Console.ReadLine();
int validInteger;
while (!int.TryParse(line, out validInteger) && !(validInteger > 0))
{
Console.WriteLine($"There was a problem with your input: {line} is not a valid integer in this context. Enter any natural number greater than 0.");
Console.Write("Number of messages: ");
line = Console.ReadLine();
}
Console.Write($"You chose {validInteger}.");
if (validInteger > 100000)
{
Console.Write(" This can take a while:)");
}
Console.WriteLine();
var file = new FileInfo(Path.ChangeExtension(Path.GetRandomFileName(), "txt"));
Console.WriteLine($"The contents will be written to {file.FullName}. Note, that passive debouncer is 'lazy' and will write the rest on next request.");
var fileLogger = new FileLoggerBase(file.FullName);
var watch = Stopwatch.StartNew();
using (var passiveDebouncer = new PassiveDebouncer())
using (var wrapper = new QueuedLoggerWrapper(fileLogger, passiveDebouncer))
{
Parallel.For(0, validInteger, x =>
{
wrapper.LogInfo(Guid.NewGuid().ToString());
});
watch.Stop();
Console.WriteLine($"Finished in {watch.Elapsed} with {wrapper.Failures} failures, after {wrapper.Requests} log requests");
}
Console.WriteLine("Open file? y/n");
var key = Console.ReadKey();
if (key.KeyChar == 'y')
{
using (var process = Process.Start(new ProcessStartInfo {
FileName = fileLogger.OutputFile.FullName, UseShellExecute = true
}))
{ }
}
Console.WriteLine();
Console.WriteLine("Delete file? y/n");
key = Console.ReadKey();
if (key.KeyChar == 'y')
{
fileLogger.OutputFile.Delete();
}
}
public void IsThreadSafeAlwaysReturnsTrue(bool isThreadSafe)
{
var myPath = $"{typeof(QueuedLoggerWrapperTests).Namespace}.{Path.GetRandomFileName()}.log";
var mockLogger1 = new Mock <FileLoggerBase>(myPath);
var mockDebouncer1 = new Mock <IDebouncer>();
mockLogger1.SetupGet(m => m.IsThreadSafe).Returns(isThreadSafe);
var testedQueuedFileLogger = new QueuedLoggerWrapper(mockLogger1.Object, mockDebouncer1.Object);
Assert.True(testedQueuedFileLogger.IsThreadSafe);
}
public void FlushAutoReturnsValueDependingOnWrappedLogger(bool flushesAuto)
{
var myPath = $"{typeof(QueuedLoggerWrapperTests).Namespace}.{Path.GetRandomFileName()}.log";
var mockLogger1 = new Mock <FileLoggerBase>(myPath);
var mockDebouncer1 = new Mock <IDebouncer>();
mockLogger1.SetupGet(m => m.FlushAuto).Returns(flushesAuto);
var testedQueuedFileLogger = new QueuedLoggerWrapper(mockLogger1.Object, mockDebouncer1.Object);
Assert.Equal(flushesAuto, testedQueuedFileLogger.FlushAuto);
}
public void CreateQueuedFileLogger()
{
var myPath = $"{typeof(QueuedLoggerWrapperTests).Namespace}.{Path.GetRandomFileName()}.log";
var testedQueuedFileLogger = new QueuedLoggerWrapper(new FileLoggerBase(myPath), new PassiveDebouncer {
DebounceMilliseconds = 1
});
try
{
testedQueuedFileLogger.LogInfo("test7013");
Assert.True(File.Exists(myPath));
}
finally
{
testedQueuedFileLogger.Dispose();
File.Delete(myPath);
}
}
public void DisposeDisposesUnderlyingLogger()
{
var myPath = $"{typeof(QueuedLoggerWrapperTests).Namespace}.{Path.GetRandomFileName()}.log";
var mockLogger1 = new Mock <FileLoggerBase>(myPath);
var mockDebouncer1 = new Mock <IDebouncer>();
mockDebouncer1.Setup(e => e.Dispose());
QueuedLoggerWrapper testedQueuedFileLogger = null;
try
{
testedQueuedFileLogger = new QueuedLoggerWrapper(mockLogger1.Object, mockDebouncer1.Object);
}
finally
{
testedQueuedFileLogger.Dispose();
}
mockDebouncer1.Verify(e => e.Dispose());
}
public void LogError2()
{
var myPath = $"{typeof(DebouncingFileLoggingTests).Namespace}.{Path.GetRandomFileName()}.log";
var testedQueuedFileLogger = new QueuedLoggerWrapper(new FileLoggerBase(myPath), new PassiveDebouncer {
DebounceMilliseconds = 1
});
try
{
var expected = new Exception("test");
testedQueuedFileLogger.LogError(expected);
var received = File.ReadAllText(myPath);
Assert.True(File.Exists(myPath));
Assert.Contains(expected.Message, received);
Assert.Contains(MessageSeverity.Error.ToString(), received);
}
finally
{
testedQueuedFileLogger.Dispose();
File.Delete(myPath);
}
}
