public void EntryIsWrittenWhenWritingAnEntryPassingExtPropsCategoryPriorityEventIdSeverityAndTitle()
{
string originalFile = "ExtPropsCatPriorityEventIdSevTitle.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Test message";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add("one", 1);
properties.Add("two", 2);
properties.Add("three", 3);
logWriter.Write(message, "General", 3, 5, TraceEventType.Critical, "Sample Title", properties);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(TraceEventType.Critical, deserializedEntry.Severity);
Assert.AreEqual("Sample Title", deserializedEntry.Title);
Assert.AreEqual(5, deserializedEntry.EventId);
Assert.AreEqual(3, deserializedEntry.ExtendedProperties.Count);
}
public void EntryIsWrittenWhenLoggingUsingBinaryLogFormatter()
{
const string BinaryFileName = "trace.log";
File.Delete(BinaryFileName);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration102"));
this.writer = factory.Create();
LogEntry entry = LogEntryFactory.GetLogEntry();
entry.Categories.Clear();
entry.Categories.Add("General");
if (writer.ShouldLog(entry))
{
this.writer.Write(entry);
}
Assert.IsTrue(File.Exists(BinaryFileName));
FileInfo fileInfo = new FileInfo(BinaryFileName);
Assert.IsTrue(fileInfo.Length > 0);
LogEntry deserializedEntry = LogFileReader.GetEntry(BinaryFileName);
Assert.AreEqual(entry.Message, deserializedEntry.Message);
Assert.AreEqual(entry.Priority, deserializedEntry.Priority);
Assert.AreEqual(entry.Severity, deserializedEntry.Severity);
}
public void EntryIsWrittenWhenWritingAnEntryPassingExtendedProperties()
{
string originalFile = "LoggerExtendedProperties.log";
File.Delete(originalFile);
this.ConfigureContainer(originalFile);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration101"));
this.writer = factory.Create();
string message = "Test message";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add("one", 1);
properties.Add("two", 2);
properties.Add("three", 3);
this.writer.Write(message, properties);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.ExtendedProperties.Count);
}
public void EntryIsWrittenWhenWritingAnEntryPassingExtPropsCategoryPriorityEventIdSeverityAndTitle()
{
string originalFile = "LoggerExtPropsCatPriorityEventIdSevTitle.log";
this.ConfigureContainer(originalFile);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration101"));
this.writer = factory.Create();
string message = "Test message";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add("one", 1);
properties.Add("two", 2);
properties.Add("three", 3);
this.writer.Write(message, "General", 3, 5, TraceEventType.Information, "Sample Title", properties);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(TraceEventType.Information, deserializedEntry.Severity);
Assert.AreEqual("Sample Title", deserializedEntry.Title);
Assert.AreEqual(5, deserializedEntry.EventId);
Assert.AreEqual(3, deserializedEntry.ExtendedProperties.Count);
}
public void EntryIsWrittenWhenLoggingWithBinaryFormatterUsingRollingFile()
{
const string FilePath = "rolling-sampleBinary.log";
const string ListenerName = "Rolling File Listener";
const string FormatterName = "Binary Formatter";
const string Footer = "----------------";
const string Header = "----------------";
File.Delete(FilePath);
configurationStart.WithOptions
.LogToCategoryNamed(CategoryName)
.WithOptions
.SetAsDefaultCategory()
.ToSourceLevels(SourceLevels.All)
.SendTo
.RollingFile(ListenerName)
.ToFile(FilePath)
.RollAfterSize(100)
.RollEvery(Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.RollInterval.Day)
.UseTimeStampPattern("ddmmyyyy")
.CleanUpArchivedFilesWhenMoreThan(5)
.WithFooter(Footer)
.WithHeader(Header)
.WithTraceOptions(TraceOptions.None)
.FormatWith(new FormatterBuilder()
.BinaryFormatterNamed(FormatterName));
this.SetConfigurationSource();
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection(e));
this.writer = factory.Create();
Logger.SetLogWriter(this.writer);
this.writer.Write(LogEntryFactory.GetLogEntry());
var deserializedEntry = LogFileReader.GetEntry(FilePath);
Assert.AreEqual(LogEntryFactory.DefaultMessage, deserializedEntry.Message);
Assert.AreEqual(2, deserializedEntry.Categories.Count);
Assert.AreEqual(LogEntryFactory.DefaultEventId, deserializedEntry.EventId);
Assert.AreEqual(LogEntryFactory.DefaultPriority, deserializedEntry.Priority);
}
public void EntryIsWrittenWhenWritingAnEntryPassingMessage()
{
string originalFile = "message.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Testing new overload";
logWriter.Write(message);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(DefaultPriority, deserializedEntry.Priority);
Assert.AreEqual(DefaultSeverity, deserializedEntry.Severity);
Assert.AreEqual(DefaultTitle, deserializedEntry.Title);
Assert.AreEqual(DefaultEventId, deserializedEntry.EventId);
}
public void EntryIsWrittenWhenWritingAnEntryPassingMessageCategoryPriorityEventIdSeverityAndTitle()
{
string originalFile = "catPriorityEventIdSeverityTitle.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Test message";
logWriter.Write(message, "General", 3, 2, TraceEventType.Critical, "My personal title");
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(2, deserializedEntry.EventId);
Assert.AreEqual(TraceEventType.Critical, deserializedEntry.Severity);
Assert.AreEqual("My personal title", deserializedEntry.Title);
}
public void EntryIsWrittenWhenWritingAnEntryPassingMessageCategoryPriorityAndEventId()
{
string originalFile = "messageCategoryPriorityEventId.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Test message";
logWriter.Write(message, "General", 3, 2);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(2, deserializedEntry.EventId);
Assert.AreEqual(DefaultSeverity, deserializedEntry.Severity);
Assert.AreEqual(DefaultTitle, deserializedEntry.Title);
}
public void EntryIsWrittenWhenLoggingWithBinaryFormatterUsingFlatFile()
{
const string FilePath = "binaryTemplateSample.log";
const string ListenerName = "Flat File Listener";
const string FormatterName = "Binary Formatter";
const string Footer = "-----------------";
const string Header = "-----------------";
File.Delete(FilePath);
configurationStart.WithOptions
.LogToCategoryNamed(CategoryName)
.WithOptions
.SetAsDefaultCategory()
.ToSourceLevels(SourceLevels.All)
.SendTo
.FlatFile(ListenerName)
.ToFile(FilePath)
.WithFooter(Footer)
.WithHeader(Header)
.WithTraceOptions(TraceOptions.None)
.FormatWith(new FormatterBuilder()
.BinaryFormatterNamed(FormatterName));
this.SetConfigurationSource();
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection(e));
this.writer = factory.Create();
Logger.SetLogWriter(this.writer);
this.writer.Write(LogEntryFactory.GetLogEntry());
var deserializedEntry = LogFileReader.GetEntry(FilePath);
Assert.AreEqual(LogEntryFactory.DefaultMessage, deserializedEntry.Message);
Assert.AreEqual(2, deserializedEntry.Categories.Count);
Assert.AreEqual(LogEntryFactory.DefaultEventId, deserializedEntry.EventId);
Assert.AreEqual(LogEntryFactory.DefaultPriority, deserializedEntry.Priority);
}
public void EntryIsWrittenWhenWritingAnEntryPassingExtendedProperties()
{
string originalFile = "ExtendedProperties.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Test message";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add("one", 1);
properties.Add("two", 2);
properties.Add("three", 3);
logWriter.Write(message, properties);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.ExtendedProperties.Count);
}
public void EntryIsWrittenWhenWritingAnEntryPassingMessageCategoryPriorityEventIdSeverityAndTitle()
{
string originalFile = "catLoggerPriorityEventIdSeverityTitle.log";
File.Delete(originalFile);
this.ConfigureContainer(originalFile);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration101"));
this.writer = factory.Create();
string message = "Test message";
this.writer.Write(message, "General", 3, 2, TraceEventType.Critical, "My personal title");
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(2, deserializedEntry.EventId);
Assert.AreEqual(TraceEventType.Critical, deserializedEntry.Severity);
Assert.AreEqual("My personal title", deserializedEntry.Title);
}
public void EntryIsWrittenWhenWritingAnEntryPassingMessageCategoryPriorityAndEventId()
{
string originalFile = "messageLoggerCategoryPriorityEventId.log";
File.Delete(originalFile);
this.ConfigureContainer(originalFile);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration101"));
this.writer = factory.Create();
string message = "Test message";
this.writer.Write(message, "General", 3, 2);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(2, deserializedEntry.EventId);
Assert.AreEqual(DefaultSeverity, deserializedEntry.Severity);
Assert.AreEqual(DefaultTitle, deserializedEntry.Title);
}
public void EntryIsWrittenWhenLoggingAnEntryPassingMessage()
{
const string OriginalFile = "messageLogger.log";
File.Delete(OriginalFile);
this.ConfigureContainer(OriginalFile);
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration101"));
this.writer = factory.Create();
string message = "Testing new overload";
this.writer.Write(message);
LogEntry deserializedEntry = LogFileReader.GetEntry(OriginalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(DefaultPriority, deserializedEntry.Priority);
Assert.AreEqual(DefaultSeverity, deserializedEntry.Severity);
Assert.AreEqual(DefaultTitle, deserializedEntry.Title);
Assert.AreEqual(DefaultEventId, deserializedEntry.EventId);
}
