public static void TestJsonFormatting()
{
var layout = new JSONFragmentPatternLayout();
layout.ActivateOptions();
var memoryAppender = new MemoryAppender
{
Layout = layout,
};
BasicConfigurator.Configure(memoryAppender);
var log = LogManager.GetLogger(typeof(LogJsonFormattingTests));
{
log.Info("Test1");
var localEvents = memoryAppender.GetEvents();
Assert.AreEqual("Test1", localEvents.Last().RenderedMessage);
}
{
log.Info(new { Test = "Test1" });
var localEvents = memoryAppender.GetEvents();
Assert.AreEqual("{ Test = Test1 }", localEvents.Last().RenderedMessage);
}
{
log.Info(new { Test1 = "Test1", Test2 = new { Test = "Test2" } });
var localEvents = memoryAppender.GetEvents();
Assert.AreEqual("{ Test1 = Test1, Test2 = { Test = Test2 } }", localEvents.Last().RenderedMessage);
}
}
/// <summary>
/// Tests the logging without exception.
/// </summary>
/// <param name="level">The log level to be tested.</param>
/// <param name="methodInfo">The method info to be called to invoke the method to be tested.</param>
private void TestLog(Level level, MethodInfo methodInfo)
{
using (var kernel = this.CreateKernel())
{
var loggerClass = kernel.Get <CtorPropertyLoggerClass>();
methodInfo.Invoke(loggerClass, new object[] { "message {0}", new object[] { 1 } });
var lastLogEvent = testAppender.GetEvents()[testAppender.GetEvents().Length - 1];
lastLogEvent.Should().NotBeNull();
lastLogEvent.RenderedMessage.Should().Be("message 1");
lastLogEvent.Level.Should().Be(level);
lastLogEvent.LoggerName.Should().Be(loggerClass.GetType().FullName);
lastLogEvent.ExceptionObject.Should().BeNull();
}
}
public void Database()
{
MemoryAppender memoryAppender = new MemoryAppender();
BasicConfigurator.Configure(LogManager.GetLogger(typeof (SchemaExport)).Logger.Repository, memoryAppender);
ActiveRecordStarter.CreateSchema();
PropertyBag["events"] = memoryAppender.GetEvents();
}
public void TestLogging()
{
// Set up a simple Log4Net configuration that logs in memory.
var memAppend = new log4net.Appender.MemoryAppender();
#if NETCOREAPP1_0
var repository = LogManager.GetRepository(Assembly.GetEntryAssembly());
BasicConfigurator.Configure(repository, memAppend);
#else
BasicConfigurator.Configure(memAppend);
#endif
BrowseRequest br = new BrowseRequest();
br.Count = 20;
br.Offset = 0;
BrowseSelection colorSel = new BrowseSelection("mycolor");
colorSel.AddValue("yellow");
br.AddSelection(colorSel);
BrowseSelection makeSel = new BrowseSelection("make");
makeSel.AddValue("rav4");
br.AddSelection(makeSel);
FacetSpec spec = new FacetSpec();
spec.ExpandSelection = true;
spec.OrderBy = FacetSpec.FacetSortSpec.OrderHitsDesc;
spec.MaxCount = 15;
br.SetFacetSpec("mycolor", spec);
br.SetFacetSpec("id", spec);
br.SetFacetSpec("make", spec);
Directory ramIndexDir = CreateIndex();
using (DirectoryReader srcReader = DirectoryReader.Open(ramIndexDir))
{
using (BoboMultiReader boboReader = BoboMultiReader.GetInstance(srcReader, _facetHandlers))
{
using (BoboBrowser boboBrowser = new BoboBrowser(boboReader))
{
using (BrowseResult result = boboBrowser.Browse(br))
{
}
}
}
}
var events = memAppend.GetEvents();
Assert.AreEqual(3, events.Length);
StringAssert.StartsWith("facetHandler loaded: id, took:", events[0].RenderedMessage);
StringAssert.StartsWith("facetHandler loaded: make, took:", events[1].RenderedMessage);
StringAssert.StartsWith("facetHandler loaded: mycolor, took:", events[2].RenderedMessage);
}
public void UsingCodeWithSpecific()
{
var appender = new MemoryAppender();
// This will configure log4net to log to the specified appender.
// Will also call BasicConfigurator.Configure(memoryAppender); internally
Configure.With()
.Log4Net(appender)
.DefaultBuilder();
var loggingEvents = appender.GetEvents()
.ToList();
Assert.IsNotEmpty(loggingEvents);
}
public void UsingCodeWithImplied()
{
var appender = new MemoryAppender();
BasicConfigurator.Configure(appender);
//This will log to all appenders currently configured in Log4net
SetLoggingLibrary.Log4Net();
Configure.With()
.DefaultBuilder();
var loggingEvents = appender.GetEvents()
.ToList();
Assert.IsNotEmpty(loggingEvents);
}
public void Log4NetCatchesUnhandledExceptionsTest()
{
// Arrange
const string exceptionMessage = "myMessage";
var testUri = new Uri("net.pipe://localhost/ExceptionThrower");
var memoryAppender = new MemoryAppender();
var hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.AddAppender(memoryAppender);
hierarchy.Root.Level = Level.Error;
hierarchy.Configured = true;
memoryAppender.Clear();
var clientEndpoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(IExceptionThrowerService)),
new NetNamedPipeBinding(),
new EndpointAddress(testUri));
var serviceEndpoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(IExceptionThrowerService)),
new NetNamedPipeBinding(),
new EndpointAddress(testUri));
var factory =
new ChannelFactory<IExceptionThrowerService>(clientEndpoint);
// Act
using (var host = new ServiceHost(typeof(ExceptionThrowerService)))
{
host.AddServiceEndpoint(serviceEndpoint);
host.Description.Behaviors.Add(new LogUnhandledExceptionBehavior());
host.Open();
try
{
var service = factory.CreateChannel();
service.ThrowException(exceptionMessage);
}
catch(FaultException)
{
//swallow the returned exception (we know it's coming back)
}
}
// Assert
var events = memoryAppender.GetEvents();
Assert.That(events.Count(), Is.GreaterThan(0));
Assert.That(events.Last().ExceptionObject.Message, Is.EqualTo(exceptionMessage));
//Display received exceptions
events.Select(x => x.ExceptionObject.ToString()).ToList().ForEach(Console.WriteLine);
}
public void Test() {
// Get the default hierarchy
var h = LogManager.GetLoggerRepository() as Hierarchy;
var m = new MemoryAppender();
h.Root.AddAppender(m);
log.Debug("test");
var l1a = new L1("a");
var l1b = new L1("b");
l1a.L1CallL2();
l1b.L1CallL2();
var events = m.GetEvents();
CheckEvent(0, events, typeof(ContextLoggerTests), "Test", "test");
CheckEvent(1, events, typeof(L1), ".ctor", "[a] L1 logger created");
CheckEvent(2, events, typeof(L1), ".ctor", "[b] L1 logger created");
CheckEvent(3, events, typeof(L1), "L1CallL2", "[a] L1 calling L2");
CheckEvent(4, events, typeof(L2), ".ctor", "[a] L2 logger created");
CheckEvent(5, events, typeof(L2), "L2Call", "[a] L2 call");
CheckEvent(6, events, typeof(L1), "L1CallL2", "[b] L1 calling L2");
CheckEvent(7, events, typeof(L2), ".ctor", "[b] L2 logger created");
CheckEvent(8, events, typeof(L2), "L2Call", "[b] L2 call");
h.Root.RemoveAppender(m);
}
public void FilterDefWithoutReference()
{
const string filterDef = @"<hibernate-mapping xmlns='urn:nhibernate-mapping-2.2' >
<filter-def name='LiveFilter'>
<filter-param name='LiveParam' type='boolean'/>
</filter-def>
</hibernate-mapping>";
var cfg = GetConfiguration();
cfg.AddXmlString(filterDef);
var memoryAppender = new MemoryAppender();
BasicConfigurator.Configure(memoryAppender);
try
{
cfg.BuildSessionFactory();
var wholeLog = String.Join("\r\n", memoryAppender.GetEvents().Select(x => x.RenderedMessage).ToArray());
Assert.That(wholeLog, Is.StringContaining("filter-def for filter named"));
Assert.That(wholeLog, Is.StringContaining("was never used to filter classes nor collections."));
}
finally
{
LogManager.Shutdown();
}
}
public void UnknownOptions()
{
var memoryAppender = new MemoryAppender();
BasicConfigurator.Configure(memoryAppender);
Dictionary<string, string> testDictionary = new Dictionary<string, string>();
Guid g = Guid.NewGuid();
testDictionary.Add(g.ToString(), g.ToString());
testDictionary.Add("MyString", "&");
SimpleOptions so = new SimpleOptions(testDictionary);
Assert.True(memoryAppender.GetEvents()[5].RenderedMessage.Equals(g.ToString()));
}
private static IEnumerable<string> GetAllRenderedMessages(Action action)
{
var memoryAppender = new MemoryAppender();
BasicConfigurator.Configure(memoryAppender);
LogHelper.SetLoggingLevel(Level.All);
action();
var renderedMessages = memoryAppender.GetEvents().Select(le => le.RenderedMessage).ToList();
memoryAppender.Close();
LogHelper.ResetLogging();
return renderedMessages;
}
