public void ExceptionHandledThroughLoggingBlock() { MockTraceListener.Reset(); container.AddExtension(new ExceptionHandlingBlockExtension()); container.AddExtension(new LoggingBlockExtension()); ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy"); Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION"))); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains("TestCat")); Assert.AreEqual(5, MockTraceListener.LastEntry.EventId); Assert.AreEqual(TraceEventType.Error, MockTraceListener.LastEntry.Severity); Assert.AreEqual("TestTitle", MockTraceListener.LastEntry.Title); }
public void TestTraceToDiagnosticTrace() { // Arrange var t = new Trace(); var myListener = new MockTraceListener(); System.Diagnostics.Trace.Listeners.Clear(); System.Diagnostics.Trace.Listeners.Add(myListener); var expected = 1; // Act t.log("test"); // Assert Assert.AreEqual(expected, myListener.logEntries.Count); }
public void UsingTracerDoesNotWriteWhenDisabled() { SetTracingFlag(false); MockTraceListener.Reset(); Guid currentActivityId = Guid.Empty; using (new Tracer(operation)) { currentActivityId = Trace.CorrelationManager.ActivityId; Assert.AreEqual(0, MockTraceListener.Entries.Count); } Assert.AreEqual(0, MockTraceListener.Entries.Count); }
public void TraceListenerWritesFullTypeNameAndMethodName() { string MyTypeAndMethodName = "Microsoft.Practices.EnterpriseLibrary.Logging.Tests.TracerFixture.TraceListenerWritesFullTypeNameAndMethodName"; MockTraceListener.Reset(); using (new Tracer(operation)) { Assert.AreEqual(1, MockTraceListener.Entries.Count); MockTraceListener.Reset(); } Assert.AreEqual(1, MockTraceListener.Entries.Count); Assert.IsTrue(MockTraceListener.Entries[0].Message.Contains(MyTypeAndMethodName)); }
public void UseTracingWithDisabledLoggerDoesntWrite() { MockTraceListener.Reset(); LogSource source = new LogSource("tracesource", new[] { new MockTraceListener() }, SourceLevels.All); List <LogSource> traceSources = new List <LogSource>(new LogSource[] { source }); LogWriter logWriter = new LogWriter(new List <ILogFilter>(), new List <LogSource>(), source, null, new LogSource("errors"), "default", false, false); using (Tracer tracer = new Tracer("testoperation", logWriter)) { Assert.AreEqual(0, MockTraceListener.Entries.Count); } Assert.AreEqual(0, MockTraceListener.Entries.Count); }
public void TraceListenerFilterOnSingleElementCollectionReturnsHasSingleElement() { TraceListenerFilter filter = new TraceListenerFilter(); TraceListener listener1 = new MockTraceListener(); IList traceListenersCollection = new TraceListener[] { listener1 }; int i = 0; Dictionary <TraceListener, int> listeners = new Dictionary <TraceListener, int>(); foreach (TraceListener listener in filter.GetAvailableTraceListeners(traceListenersCollection)) { i++; listeners[listener] = (listeners.ContainsKey(listener) ? listeners[listener] : 0) + 1; } Assert.AreEqual(1, i); Assert.AreEqual(1, listeners[listener1]); }
protected override void Arrange() { this.traceListener = new MockTraceListener(); var logWriter = new LogWriter( new ILogFilter[0], new LogSource[0], new LogSource("all", new TraceListener[] { this.traceListener }, SourceLevels.All), new LogSource(""), new LogSource(""), "default", false, false); Logger.SetLogWriter(logWriter, false); }
public void UsingTracerWritesEntryAndExitMessages() { MockTraceListener.Reset(); Guid currentActivityId = Guid.Empty; using (new Tracer(operation)) { currentActivityId = Trace.CorrelationManager.ActivityId; Assert.AreEqual(1, MockTraceListener.Entries.Count); AssertLogEntryIsValid(MockTraceListener.LastEntry, Tracer.startTitle, operation, currentActivityId, true); MockTraceListener.Reset(); } Assert.AreEqual(1, MockTraceListener.Entries.Count); AssertLogEntryIsValid(MockTraceListener.LastEntry, Tracer.endTitle, operation, currentActivityId, false); }
public void Setup() { this.traceListener = new MockTraceListener("original"); this.logWriter = new LogWriter( new LogWriterStructureHolder( new ILogFilter[0], new Dictionary <string, LogSource>(), new LogSource("all", new[] { traceListener }, SourceLevels.All), new LogSource("not processed"), new LogSource("error"), "default", false, false, false)); }
public void CanAddAsynchronousTraceListenerToSpecialSource() { var listener = new MockTraceListener { Name = "listener", Filter = new EventTypeFilter(SourceLevels.Critical) }; var config = new LoggingConfiguration(); config.SpecialSources.LoggingErrorsAndWarnings.AddAsynchronousTraceListener(listener); var addedListener = (AsynchronousTraceListenerWrapper)config.SpecialSources.LoggingErrorsAndWarnings.Listeners.First(); Assert.AreSame(listener, addedListener.TraceListener); Assert.AreEqual("listener", addedListener.Name); Assert.AreEqual(SourceLevels.Critical, ((EventTypeFilter)addedListener.Filter).EventType); }
public void SetUp() { AppDomain.CurrentDomain.SetData("APPBASE", Environment.CurrentDirectory); logWriter = #if NETCOREAPP new LogWriterFactory(NetCoreHelper.LookupConfigSection).Create(); #else new LogWriterFactory().Create(); #endif MockTraceListener.Reset(); ErrorsMockTraceListener.Reset(); emptyTraceSource = new LogSource("none", Enumerable.Empty <TraceListener>(), SourceLevels.All); Assert.IsFalse(emptyTraceSource.Listeners.Any()); }
public void ConfigurationChangeNotificationRefreshesLogger() { SystemConfigurationSource.ResetImplementation(false); Logger.Reset(); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(1, MockTraceListener.Entries.Count); System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; ((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne")); rwConfiguration.Save(); SystemConfigurationSource.Implementation.ConfigSourceChanged(string.Empty); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(0, MockTraceListener.Entries.Count, "should have been filtered out by the new category filter"); }
public void UsingTracerDoesNotWriteWhenDisabled() { using (new ContainerSwitcher(GetContainerWithTracingFlag(false), true)) { MockTraceListener.Reset(); Guid currentActivityId = Guid.Empty; using (new Tracer(operation)) { currentActivityId = Trace.CorrelationManager.ActivityId; Assert.AreEqual(0, MockTraceListener.Entries.Count); } Assert.AreEqual(0, MockTraceListener.Entries.Count); } Logger.Reset(); }
public void GetTracerFromTraceManagerWithNoInstrumentation() { MockTraceListener.Reset(); LogSource source = new LogSource("tracesource", SourceLevels.All); source.Listeners.Add(new MockTraceListener()); List <LogSource> traceSources = new List <LogSource>(new LogSource[] { source }); LogWriter lg = new LogWriter(new List <ILogFilter>(), new List <LogSource>(), source, null, new LogSource("errors"), "default", true, false); TraceManager tm = new TraceManager(lg); Assert.IsNotNull(tm); using (tm.StartTrace("testoperation")) { Assert.AreEqual(1, MockTraceListener.Entries.Count); } Assert.AreEqual(2, MockTraceListener.Entries.Count); }
public void TestHandleMessageNoClient() { config.SetPropertyFieldForTests("MaskCredentials", true); listener = new MockTraceListener(config); XmlDocument xOutgoing = XmlUtilities.CreateDocument(Resources.XmlRequest); listener.HandleMessage(xOutgoing, null, SoapMessageDirection.OUT); Assert.AreEqual(xOutgoing.OuterXml, ContextStore.GetValue("SoapRequest")); XmlDocument xIncoming = XmlUtilities.CreateDocument(Resources.XmlResponse); listener.HandleMessage(xIncoming, null, SoapMessageDirection.IN); Assert.AreEqual(xIncoming.OuterXml, ContextStore.GetValue("SoapResponse")); Assert.IsNull(ContextStore.GetValue("FormattedSoapLog")); Assert.IsNull(ContextStore.GetValue("FormattedRequestLog")); }
public void ConfigurationChangeNotificationRefreshesLoggerAutomatically() { ConfigurationChangeWatcher.SetDefaultPollDelayInMilliseconds(100); SystemConfigurationSource.ResetImplementation(true); Logger.Reset(); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(1, MockTraceListener.Entries.Count); System.Configuration.Configuration rwConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); LoggingSettings rwSettings = rwConfiguration.GetSection(LoggingSettings.SectionName) as LoggingSettings; ((CategoryFilterData)rwSettings.LogFilters.Get("Category")).CategoryFilters.Add(new CategoryFilterEntry("MockCategoryOne")); rwConfiguration.Save(); Thread.Sleep(400); MockTraceListener.Reset(); Logger.Write("test", "MockCategoryOne"); Assert.AreEqual(0, MockTraceListener.Entries.Count); }
public void UseTracingWithOwnLogWriter() { MockTraceListener.Reset(); LogSource source = new LogSource("tracesource", SourceLevels.All); source.Listeners.Add(new MockTraceListener()); List <LogSource> traceSources = new List <LogSource>(new LogSource[] { source }); LogWriter logWriter = new LogWriter(new List <ILogFilter>(), new List <LogSource>(), source, null, new LogSource("errors"), "default", true, false); using (Tracer tracer = new Tracer("testoperation", logWriter, null)) { Assert.AreEqual(1, MockTraceListener.Entries.Count); } Assert.AreEqual(2, MockTraceListener.Entries.Count); }
public void LoggedExceptionCopiesExceptionDataForStringKeys() { MockTraceListener.Reset(); Exception exception = new Exception("TEST EXCEPTION"); object value = new object(); object key4 = new object(); exception.Data.Add("key1", value); exception.Data.Add("key2", "value"); exception.Data.Add("key3", 3); exception.Data.Add(key4, "value"); Assert.IsFalse(ExceptionPolicy.HandleException(exception, "Logging Policy")); Assert.AreEqual(1, MockTraceListener.Entries.Count); Assert.AreEqual(3, MockTraceListener.Entries[0].ExtendedProperties.Count); Assert.AreEqual(value, MockTraceListener.Entries[0].ExtendedProperties["key1"]); Assert.AreEqual("value", MockTraceListener.Entries[0].ExtendedProperties["key2"]); Assert.AreEqual(3, MockTraceListener.Entries[0].ExtendedProperties["key3"]); }
public void Setup() { MockTraceListener.Reset(); this.traceListener = new MockTraceListener(); var logWriter = new LogWriter( new ILogFilter[0], new LogSource[0], new LogSource("all", new TraceListener[] { traceListener }, SourceLevels.All), new LogSource("not processed"), new LogSource("errors"), "default", true, false); Logger.SetLogWriter(logWriter, false); }
public void EmptyCategoriesRevertToDefaultCategory() { MockTraceListener.Reset(); LoggingSettings settings = LoggingSettings.GetLoggingSettings(new SystemConfigurationSource()); LogEntry log = new LogEntry(); log.EventId = 1; log.Message = "test"; log.Categories = new string[0]; log.Severity = TraceEventType.Error; Logger.Write(log); Assert.IsNotNull(MockTraceListener.LastEntry); Assert.AreEqual("test", MockTraceListener.LastEntry.Message); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(settings.DefaultCategory)); }
public void TestCorrectResponseInfo() { MockAdsUser user = new MockAdsUser(new MockAppConfig()); MockTraceListener listener = (MockTraceListener)user.Listeners[0]; SoapListenerInspector inspector = new SoapListenerInspector(user, TestServiceName); HttpResponseMessageProperty responseProperties = new HttpResponseMessageProperty(); responseProperties.Headers.Add("X-TestHeader", "Hello World"); responseProperties.StatusCode = System.Net.HttpStatusCode.OK; response.Properties.Add(HttpResponseMessageProperty.Name, responseProperties); inspector.BeforeSendRequest(ref request, channel); inspector.AfterReceiveReply(ref response, channel); Assert.AreEqual(responseProperties.Headers, listener.LastResponseInfo.Headers); Assert.AreEqual(responseProperties.StatusCode, listener.LastResponseInfo.StatusCode); Assert.AreEqual(ExpectedResponseXml, listener.LastResponseInfo.Body); }
public void WhenTheLoggingUpdateEventIsTriggered_ThenTheWrapperStartsUsingANewTraceListenerResolvedFromTheLocatorInTheEventArguments() { var newTraceListener = new MockTraceListener("mock"); var container = new UnityContainer().RegisterInstance <TraceListener>("mock", newTraceListener); this.coordinator.RaiseLoggingUpdate(new UnityServiceLocator(container)); var cache = new TraceEventCache(); var data = new object(); this.wrapperTraceListener.TraceData(cache, "source", TraceEventType.Critical, 100, data); Assert.IsNull(this.traceListener.tracedData); Assert.IsNull(this.traceListener.tracedSource); Assert.IsNull(this.traceListener.tracedEventType); Assert.AreSame(data, newTraceListener.tracedData); Assert.AreEqual("source", newTraceListener.tracedSource); Assert.AreEqual(TraceEventType.Critical, newTraceListener.tracedEventType); }
public void Setup() { this.coordinator = new MockLoggingUpdateCoordinator(); this.traceListener = new MockTraceListener("original"); this.instrumentationProvider = new MockLoggingInstrumentationProvider(); this.logWriter = new LogWriterImpl( new LogWriterStructureHolder( new ILogFilter[0], new Dictionary <string, LogSource>(), new LogSource("all", new[] { traceListener }, SourceLevels.All), new LogSource("not processed"), new LogSource("error"), "default", false, false, false), this.instrumentationProvider, coordinator); }
public void TraceListenerFilterOnMultipleElementsCollectionReturnsHasSameElements() { TraceListenerFilter filter = new TraceListenerFilter(); TraceListener listener1 = new MockTraceListener(); TraceListener listener2 = new MockTraceListener(); IEnumerable <TraceListener> traceListenersCollection = new TraceListener[] { listener1, listener2 }; int i = 0; Dictionary <TraceListener, int> listeners = new Dictionary <TraceListener, int>(); foreach (TraceListener listener in filter.GetAvailableTraceListeners(traceListenersCollection)) { i++; listeners[listener] = (listeners.ContainsKey(listener) ? listeners[listener] : 0) + 1; } Assert.AreEqual(2, i); Assert.AreEqual(1, listeners[listener1]); Assert.AreEqual(1, listeners[listener2]); }
public void TestHandleMessage() { config.SetPropertyFieldForTests("MaskCredentials", true); listener = new MockTraceListener(config); XmlDocument xOutgoing = new XmlDocument(); xOutgoing.LoadXml(Resources.XmlRequest); listener.HandleMessage(xOutgoing, adsClient, SoapMessageDirection.OUT); Assert.AreEqual(xOutgoing.OuterXml, ContextStore.GetValue("SoapRequest")); XmlDocument xIncoming = new XmlDocument(); xIncoming.LoadXml(Resources.XmlResponse); listener.HandleMessage(xIncoming, adsClient, SoapMessageDirection.IN); Assert.AreEqual(xIncoming.OuterXml, ContextStore.GetValue("SoapResponse")); Assert.AreEqual(Resources.SoapLog.Replace("\r\n", "\n"), ((string)ContextStore.GetValue("FormattedSoapLog")).Replace("\r\n", "\n")); Assert.AreEqual(Resources.ResponseLog.Replace("\r\n", "\n"), ((string)ContextStore.GetValue("FormattedRequestLog")).Replace("\r\n", "\n")); }
public void LoggingHandlerCreatesFormatterWithTheDocumentedConstructor() { MockTraceListener.Reset(); ConstructorSensingExceptionFormatter.Instances.Clear(); Exception exception = new Exception("test exception"); Guid testGuid = Guid.NewGuid(); LoggingExceptionHandler handler = new LoggingExceptionHandler( "TestCat", 0, TraceEventType.Warning, "test", 0, typeof(ConstructorSensingExceptionFormatter), Logger.Writer); handler.HandleException(exception, testGuid); Assert.AreEqual(1, ConstructorSensingExceptionFormatter.Instances.Count); Assert.AreSame(exception, ConstructorSensingExceptionFormatter.Instances[0].Exception); Assert.AreEqual(testGuid, ConstructorSensingExceptionFormatter.Instances[0].HandlingInstanceId); }
public void UsingTracerDoesNotWriteWhenDisabled() { SystemConfigurationSource.ResetImplementation(false); //turn tracing off SetTracingFlag(false); MockTraceListener.Reset(); Guid currentActivityId = Guid.Empty; using (new Tracer(operation)) { currentActivityId = Trace.CorrelationManager.ActivityId; Assert.AreEqual(0, MockTraceListener.Entries.Count); } Assert.AreEqual(0, MockTraceListener.Entries.Count); //turn tracing back on SetTracingFlag(true); }
public void MultipleRequestsUseSameLogWriterInstance() { MockTraceListener.Reset(); { ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy"); Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION"))); } { ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy"); Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION"))); } { ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy"); Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION"))); } Assert.AreEqual(3, MockTraceListener.Entries.Count); Assert.AreEqual(3, MockTraceListener.Instances.Count); Assert.AreSame(MockTraceListener.Instances[0], MockTraceListener.Instances[1]); Assert.AreSame(MockTraceListener.Instances[0], MockTraceListener.Instances[2]); }
public void CanGetAllTraceListeners() { var listener1 = new MockTraceListener(); var listener2 = new MockTraceListener(); var listener3 = new MockTraceListener(); var listener4 = new MockTraceListener(); var config = new LoggingConfiguration(); config.AddLogSource("source1", listener1, listener2); config.AddLogSource("source2", listener2); config.AddLogSource("source3", listener1, listener3); config.AddLogSource("source4"); config.SpecialSources.Unprocessed.AddTraceListener(listener2); config.SpecialSources.Unprocessed.AddTraceListener(listener4); var allListeners = config.AllTraceListeners.ToArray(); Assert.AreEqual(4, allListeners.Length); CollectionAssert.AreEquivalent(new TraceListener[] { listener1, listener2, listener3, listener4 }, allListeners); }
public void TestCorrectRequestInfo() { MockAdsUser user = new MockAdsUser(new MockAppConfig()); MockTraceListener listener = new MockTraceListener(user.Config); user.Listeners.Add(listener); SoapListenerInspector inspector = new SoapListenerInspector(user, TestServiceName); HttpRequestMessageProperty requestProperties = new HttpRequestMessageProperty(); requestProperties.Headers.Add("Authorization", "Bearer 1234"); requestProperties.Method = "POST"; request.Properties.Add(HttpRequestMessageProperty.Name, requestProperties); inspector.BeforeSendRequest(ref request, channel); inspector.AfterReceiveReply(ref response, channel); Assert.AreEqual(requestProperties.Headers, listener.LastRequestInfo.Headers); Assert.AreEqual(requestProperties.Method, listener.LastRequestInfo.HttpMethod); Assert.AreEqual(ExpectedRequestXml, listener.LastRequestInfo.Body); Assert.AreEqual(TestServiceName, listener.LastRequestInfo.Service); }
public void LoggedMessagesDuringTracerAddsCategoryIds() { MockTraceListener.Reset(); using (new Tracer(operation)) { Assert.AreEqual(1, MockTraceListener.Entries.Count); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(operation)); MockTraceListener.Reset(); Logger.Write("message", category); Assert.AreEqual(1, MockTraceListener.Entries.Count); Assert.AreEqual(2, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(operation)); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(category)); MockTraceListener.Reset(); } Assert.AreEqual(1, MockTraceListener.Entries.Count); Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count); Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(operation)); }