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));
}
