public void ServiceStoppedWritesToEventLog()
{
DistributorEventLogger logger = new DistributorEventLogger();
using (var eventLog = new EventLogTracker(GetEventLog()))
{
logger.LogServiceStopped();
Assert.AreEqual(1, eventLog.NewEntries().Count(ev => EventIsFromLogger(ev, logger)));
}
}
public void CacheFailureWithInstrumentationDisabledDoesNotWriteToEventLog()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, false, false, formatter);
Exception exception = new Exception(exceptionMessage);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
provider.FireCacheFailed(errorMessage, exception);
Assert.AreEqual(0, eventLog.NewEntries().Count());
}
}
public void ShouldLogOnlyToCategoriesGivenInConfig()
{
using (var configSource = new FileConfigurationSource("LogCallHandler.config", false))
{
using (var eventLog = new EventLogTracker("Application"))
{
using (var injector = new PolicyInjector(configSource))
{
LoggingTarget target = injector.Create<LoggingTarget>();
target.DoSomething(1, "two", 3.0);
}
Assert.AreEqual(1, eventLog.NewEntries().Select(le => le.Category == "Default Category").Count());
}
}
}
public void DefaultLoggerWritesToEventLog()
{
DefaultCachingEventLogger logger
= new DefaultCachingEventLogger(true);
ConfigurationErrorsException exception = new ConfigurationErrorsException(exceptionMessage);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
logger.LogConfigurationError(instanceName, exception);
var newEntries = from entry in eventLog.NewEntries()
where entry.Message.IndexOf(exceptionMessage) > -1
select entry;
Assert.AreEqual(1, newEntries.ToList().Count);
}
}
public void CacheCallbackFailureWithInstrumentationDisabledDoesNotWriteToEventLog()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, false, false, formatter);
Exception exception = new Exception(exceptionMessage);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
provider.FireCacheCallbackFailed(errorMessage, exception);
var newEntries = from entry in eventLog.NewEntries()
where entry.Message.IndexOf(exceptionMessage) > -1
select entry;
Assert.AreEqual(0, newEntries.Count());
}
}
public void ShouldCombineWithPoliciesDefinedInConfiguration()
{
using (var configSource = new FileConfigurationSource("CombinesWithConfig.config", false))
{
using (var eventLog = new EventLogTracker("Application"))
{
using (var injector = new PolicyInjector(configSource))
{
var typeWhichUndergoesLoggingOnMethodCall =
injector.Create<TypeWhichUndergoesAttributeBasedLogging>();
typeWhichUndergoesLoggingOnMethodCall.TestMethod();
typeWhichUndergoesLoggingOnMethodCall.MyProperty = "hello";
}
Assert.AreEqual(2,
eventLog.NewEntries().Select(le => le.Message.Contains("This is before the call")).
Count());
}
}
}
public void InvalidMessageIsLoggedAndRemovedFromTheQueue()
{
clientListener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, "not a log entry");
using (var eventLog = new EventLogTracker(GetEventLog()))
{
msmqDistributor.CheckForMessages();
Assert.AreEqual(1, eventLog.NewEntries().Count(ev => EventIsFromLogger(ev, eventLogger)));
}
Assert.IsTrue(IsQueueEmpty());
}
public void ServiceFailureWithoutExceptionWritesToEventLog()
{
DistributorEventLogger logger = new DistributorEventLogger(TestEventSource);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
logger.LogServiceFailure(message, null, TraceEventType.Error);
Assert.AreEqual(1,
eventLog.NewEntries().Count(ev => EventIsFromLogger(ev, logger)));
}
}
public void EventLogWrittenWhenCreatingUndefinedPolicy()
{
using (var tracker = new EventLogTracker("Application"))
{
try
{
ExceptionPolicy.HandleException(new Exception(), "ThisIsAnUnknownKey");
}
catch (ActivationException)
{
var entries = from entry in tracker.NewEntries()
where entry.Source == "Enterprise Library ExceptionHandling" &&
entry.Message.Contains("ThisIsAnUnknownKey")
select entry;
Assert.AreEqual(1, entries.Count());
}
}
}