public void Results_Matches_Specified_Range_Exactly_No_Official_Holidays()
{
tracker = new EventLogTracker(MakeEventLogFactory(2019, 4, 18));
var actual = tracker.FindBy(new EventLogQuery("^ESENT$", "Application", new Date(2019, 4, 18), new Date(2019, 4, 30)));
Assert.True(actual.ContainsKey("2019-04-18"));
Assert.False(actual.ContainsKey("2019-04-19"));
Assert.False(actual.ContainsKey("2019-04-20"));
Assert.False(actual.ContainsKey("2019-04-22")); // Saturday
Assert.True(actual.ContainsKey("2019-04-30")); // Sunday
}
public void ServiceResumedWritesToEventLog()
{
DistributorEventLogger logger = new DistributorEventLogger(TestEventSource);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
logger.LogServiceResumed();
Assert.AreEqual(1, eventLog.NewEntries().Count(ev => EventIsFromLogger(ev, logger)));
}
}
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 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 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 CacheCallbackFailureWithInstrumentationEnabledDoesWriteToEventLog()
{
ICachingInstrumentationProvider provider
= new CachingInstrumentationProvider(instanceName, false, true, formatter);
Exception exception = new Exception(exceptionMessage);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
provider.FireCacheCallbackFailed(key, exception);
var newEntries = from entry in eventLog.NewEntries()
where entry.Message.IndexOf(exceptionMessage) > -1
select entry;
Assert.AreEqual(1, newEntries.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 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());
}
}
}
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 ConfigurationErrorsAreLoggedInEventLog()
{
using (var configurationSourceWithInvalidConfiguration = new FileConfigurationSource("errornous.config", false))
using (EventLogTracker eventLog = new EventLogTracker(GetEventLog()))
{
try
{
ValidationFactory.CreateValidator <EventLogFixture>(configurationSourceWithInvalidConfiguration);
Assert.Fail();
}
catch (ConfigurationErrorsException e)
{
var newValidationEntries = (
from entry in eventLog.NewEntries()
where entry.Source == "Enterprise Library Validation" &&
entry.Message.IndexOf(e.Message) > -1
select entry
).ToList();
Assert.AreEqual(1, newValidationEntries.Count);
}
}
}
//private static IDateTimeValueFactory MakeDateTimeValueFactoryMock(int year = startYear, int month = startMonth, int day = startDay)
//{
// Mock<IDateTimeValueFactory> mock = new Mock<IDateTimeValueFactory>();
// DateTime start_ = new DateTime(year, month, day);
// mock.Setup(m => m.LocalToday(It.IsAny<int>())).Returns(new Date(start_.AddDays(-22)));
// return mock.Object;
//}
public void Dispose()
{
tracker = null;
}
public EventLogTrackerTests()
{
tracker = new EventLogTracker(MakeEventLogFactory());
}
