public void Writes_InnerException_To_File()
{
Exception outer = null;
Exception inner = null;
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
try
{
throw new Exception("This is the inner exception message");
}
catch (Exception caught)
{
inner = caught;
}
try
{
throw new Exception("This is the outer exception message", inner);
}
catch (Exception caught)
{
outer = caught;
}
logger.Write("Exception occured!", outer);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(inner.Message).And.StringContaining(inner.StackTrace)
);
}
public void Setup()
{
_fileHandlerMock = new Mock <IFileHandler>();
_target = new SimpleFileLogger(_fileHandlerMock.Object);
_pathProviderMock = new Mock <ITestingPathProvider>();
_filePath = _pathProviderMock.Object.GetPathToTestLog();
}
public void LogMessagesFromAllLevels_SingleThread()
{
const string filePath = "log.txt";
using (var log = new SimpleFileLogger(filePath))
{
string message = "Nachricht";
log.Trace(message);
log.Debug(message);
log.Info(message);
log.Warning(message);
log.Error(message);
log.Critical(message);
}
string[] actualLines =
(from line in File.ReadAllLines(filePath) select line.ToLower()).ToArray();
var expectedLabels = new[] { "trace", "debug", "info", "warning", "error", "critical" };
Assert.Equal(expectedLabels.Count(), actualLines.Count());
AssertThatEverySubstringIsContainedInDistinctLine(expectedLabels, actualLines,
(message, line) => line.Contains(message));
File.Delete(filePath);
}
public void InstantiateAndDispose_FileDoesNotExist()
{
const string filePath = "log.txt";
var log = new SimpleFileLogger(filePath);
log.Dispose();
File.Delete(filePath);
}
public void New_Creates_NonExistent_File()
{
Assert.False(File.Exists(FileMocks.FileThatDoesNotExist()));
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
Assert.True(File.Exists(FileMocks.FileThatDoesNotExist()));
}
}
public void New_Creates_NonExistent_File()
{
Assert.False(File.Exists(FileMocks.FileThatDoesNotExist()));
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
Assert.True(File.Exists(FileMocks.FileThatDoesNotExist()));
}
}
public void InstantiateAndDispose_FileExists()
{
const string filePath = "log.txt";
File.WriteAllText(filePath, "Etwas.");
var log = new SimpleFileLogger(filePath);
log.Dispose();
File.Delete(filePath);
}
public void Default_New_Uses_DefaultLogFile_And_DefaultMaxLogSize()
{
Assert.False(File.Exists(SimpleFileLogger.DefaultLogFile));
using (var fileLogger = new SimpleFileLogger())
{
Assert.True(File.Exists(SimpleFileLogger.DefaultLogFile));
}
File.Delete(SimpleFileLogger.DefaultLogFile);
}
public void Default_New_Uses_DefaultLogFile_And_DefaultMaxLogSize()
{
Assert.False(File.Exists(SimpleFileLogger.DefaultLogFile));
using (var fileLogger = new SimpleFileLogger())
{
Assert.True(File.Exists(SimpleFileLogger.DefaultLogFile));
}
File.Delete(SimpleFileLogger.DefaultLogFile);
}
public void New_Writes_Log_Header()
{
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining("Log Start").IgnoreCase
);
}
public void Writes_Blank_Line_To_File()
{
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine();
}
Assert.That(
File.ReadAllLines(FileMocks.FileThatDoesNotExist()).Length,
Is.EqualTo(2)
);
}
public void Writes_Simple_Message_To_File()
{
string message = "This is a log message";
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine(message);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(message)
);
}
public void LogOneMessage_SingleThread()
{
const string message = "Nachricht";
const string filePath = "log.txt";
using (var log = new SimpleFileLogger(filePath))
{
log.Trace(message);
}
string actualContent = File.ReadAllText(filePath);
Assert.Contains(message, actualContent);
File.Delete(filePath);
}
public static bool GetFromLine(string line, int sequence, out Tweet tweet)
{
tweet = null;
if (line == null)
{
return(false);
}
StringBuilder user = new StringBuilder();
StringBuilder comment = new StringBuilder();
bool foundSeperator = false;
for (int i = 0; i < line.Length; i++)
{
if (!foundSeperator)
{
if (line[i] == '>')
{
foundSeperator = true;
continue;
}
user.Append(line[i]);
}
else
{
comment.Append(line[i]);
}
}
if (!foundSeperator)
{
SimpleFileLogger.LogEvent("Tweet format error", DateTime.Now, string.Concat("Did not find feed seperator on line ", sequence));
return(false);
}
var commentResult = comment.ToString().Trim();
if (string.IsNullOrEmpty(commentResult))
{
SimpleFileLogger.LogEvent("Tweet format error", DateTime.Now, string.Concat("Feed did not contain a message on line ", sequence));
return(false);
}
tweet = new Tweet()
{
Username = user.ToString().Trim(), Comment = commentResult, Sequence = sequence
};
return(true);
}
public void Writes_Format_Message_To_File()
{
string format = "This is a log format with 2 params {0} {1}";
string param1 = "param1";
string param2 = "param2";
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine(format, param1, param2);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(param1).And.StringContaining(param2)
);
}
public static void BDLog(string message, Exception e = null)
{
lock (LogLock) {
if (BDLogger == null)
{
BDLogger = new SimpleFileLogger("Brinedump.log");
}
if (e != null)
{
BDLogger.Error(message + "\n" + e.ToString());
}
else
{
BDLogger.Info(message);
}
};
}
public void New_ReThrows_Target_File_Exceptions()
{
//make sure the target file exists
File.WriteAllText(FileMocks.FileThatDoesNotExist(), String.Empty);
//open the target file in exclusive mode
using (var exclusive = File.Open(FileMocks.FileThatDoesNotExist(), FileMode.Open, FileAccess.Read, FileShare.None))
{
Assert.That(
() => {
using (var shouldFail = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
},
Throws.InstanceOf<IOException>()
);
}
}
public void New_ReThrows_Target_File_Exceptions()
{
//make sure the target file exists
File.WriteAllText(FileMocks.FileThatDoesNotExist(), String.Empty);
//open the target file in exclusive mode
using (var exclusive = File.Open(FileMocks.FileThatDoesNotExist(), FileMode.Open, FileAccess.Read, FileShare.None))
{
Assert.That(
() => {
using (var shouldFail = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
},
Throws.InstanceOf <IOException>()
);
}
}
public void LogManyMessages_SingleThread()
{
string[] messages = With <string> .CreateArrayOf(100, (int index) => $"Nachricht #{index}");
const string filePath = "log.txt";
using (var log = new SimpleFileLogger(filePath))
{
foreach (string message in messages)
{
log.Trace(message);
}
}
string[] actualLines = File.ReadAllLines(filePath);
Assert.Equal(messages.Count(), actualLines.Count());
AssertThatEverySubstringIsContainedInDistinctLine(messages, actualLines,
(message, line) => line.EndsWith(message));
File.Delete(filePath);
}
private static async Task Main(string[] args)
{
List <Account> accounts = new List <Account>();
ISimpleLogger logger;
#if DEBUG
logger = new SimpleConsoleLogger();
#else
logger = new SimpleFileLogger(AppContext.BaseDirectory);
#endif
try
{
var builder = new ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile("appsettings.json");
IConfigurationRoot configuration = builder.Build();
configuration.GetSection("accounts").Bind(accounts);
using (var service = new VkCelebrationSchedulerService(accounts, logger))
{
#if DEBUG
await service.RunAsConsole(args);
#else
ServiceBase.Run(service);
#endif
}
}
catch (Exception ex)
{
logger.WriteException(ex);
logger.WriteLine("=====================================================");
}
finally
{
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
}
public void Writes_Exception_To_File()
{
Exception ex = null;
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
try
{
throw new Exception("This is the exception message");
}
catch (Exception caught)
{
ex = caught;
}
logger.Write("Exception occured!", ex);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Does.Contain(ex.Message).And.Contains(ex.StackTrace)
);
}
public static void ReadFeeds(string userFileName, string tweetFileName)
{
try
{
var users = new UserRepository(userFileName).GetAll().OrderBy(p => p.Name);
var tweets = new TweetRepository(tweetFileName).GetAll().ToLookup(p => p.Username.ToUpper());
foreach (var user in users)
{
Console.WriteLine(user.Name);
foreach (var tweet in GetTweetsForUser(user, tweets))
{
Console.Write("\t@");
Console.Write(tweet.Username);
Console.Write(": ");
Console.WriteLine(tweet.Comment);
}
}
}
catch (Exception ex)
{
SimpleFileLogger.LogEvent("Read tweets exception", DateTime.Now, ex.Message, true);
}
}
public void New_Rolls_Log_After_MaximumLogSize()
{
//create some test data that is just larger than the MaximumLogSize
byte[] data = Enumerable.Range(1, SimpleFileLogger.DefaultMaximumLogBytes + 1)
.Select(i => Convert.ToByte(i % 255))
.ToArray();
File.WriteAllBytes(FileMocks.FileThatDoesNotExist(), data);
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining("Log Rollover").IgnoreCase
);
Assert.That(
File.ReadAllBytes(FileMocks.FileThatDoesNotExist()).LongLength,
Is.LessThan(SimpleFileLogger.DefaultMaximumLogBytes + 1)
);
}
public void New_Rolls_Log_After_MaximumLogSize()
{
//create some test data that is just larger than the MaximumLogSize
byte[] data = Enumerable.Range(1, SimpleFileLogger.DefaultMaximumLogBytes + 1)
.Select(i => Convert.ToByte(i % 255))
.ToArray();
File.WriteAllBytes(FileMocks.FileThatDoesNotExist(), data);
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining("Log Rollover").IgnoreCase
);
Assert.That(
File.ReadAllBytes(FileMocks.FileThatDoesNotExist()).LongLength,
Is.LessThan(SimpleFileLogger.DefaultMaximumLogBytes + 1)
);
}
public void Writes_Blank_Line_To_File()
{
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine();
}
Assert.That(
File.ReadAllLines(FileMocks.FileThatDoesNotExist()).Length,
Is.EqualTo(2)
);
}
public void Writes_Simple_Message_To_File()
{
string message = "This is a log message";
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine(message);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(message)
);
}
public void Writes_Format_Message_To_File()
{
string format = "This is a log format with 2 params {0} {1}";
string param1 = "param1";
string param2 = "param2";
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
logger.WriteLine(format, param1, param2);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(param1).And.StringContaining(param2)
);
}
public void Writes_InnerException_To_File()
{
Exception outer = null;
Exception inner = null;
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
try
{
throw new Exception("This is the inner exception message");
}
catch (Exception caught)
{
inner = caught;
}
try
{
throw new Exception("This is the outer exception message", inner);
}
catch (Exception caught)
{
outer = caught;
}
logger.Write("Exception occured!", outer);
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining(inner.Message).And.StringContaining(inner.StackTrace)
);
}
public void New_Writes_Log_Header()
{
using (var logger = new SimpleFileLogger(FileMocks.FileThatDoesNotExist()))
{
//no-op
}
Assert.That(
File.ReadAllText(FileMocks.FileThatDoesNotExist()),
Is.StringContaining("Log Start").IgnoreCase
);
}
