public void SetUp()
{
configurationSource = new DictionaryConfigurationSourceWithHandlersQuery();
InstrumentationConfigurationSection instrumentationConfig = new InstrumentationConfigurationSection(true, true, false);
configurationSource.Add(InstrumentationConfigurationSection.SectionName, instrumentationConfig);
settings = new LoggingSettings();
configurationSource.Add(LoggingSettings.SectionName, settings);
settings.SpecialTraceSources.ErrorsTraceSource
= new TraceSourceData("error", SourceLevels.Off);
TraceSourceData traceSourceData = new TraceSourceData("blocking", SourceLevels.All);
traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener1"));
settings.TraceSources.Add(traceSourceData);
traceSourceData = new TraceSourceData("nonblocking", SourceLevels.All);
traceSourceData.TraceListeners.Add(new TraceListenerReferenceData("listener2"));
settings.TraceSources.Add(traceSourceData);
TraceListenerData traceListenerData = new CustomTraceListenerData("listener1", typeof(MockBlockingCustomTraceListener), "init 1");
settings.TraceListeners.Add(traceListenerData);
traceListenerData = new MockTraceListenerData("listener2");
settings.TraceListeners.Add(traceListenerData);
reflectionCache = new ConfigurationReflectionCache();
MockTraceListener.Reset();
MockBlockingCustomTraceListener.Reset();
}
public void CanCreatePoliciesForCustomTraceListenerWithFormatter()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), "", TraceOptions.Callstack);
listenerData.Formatter = "formatter";
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
loggingSettings.TraceListeners.Add(listenerData);
FormatterData formatterData = new TextFormatterData("formatter", "template");
loggingSettings.Formatters.Add(formatterData);
using (var container = CreateContainer())
{
var createdObject =
container.Resolve <TraceListener>("listener\u200cimplementation") as AttributeSettingTraceListenerWrapper;
Assert.IsNotNull(createdObject);
Assert.AreEqual("listener\u200cimplementation", createdObject.Name);
Assert.AreEqual(TraceOptions.Callstack, createdObject.TraceOutputOptions);
Assert.AreEqual(typeof(MockCustomTraceListener), createdObject.InnerTraceListener.GetType());
Assert.AreEqual(null, ((MockCustomTraceListener)createdObject.InnerTraceListener).initData); // configured with "", but set to null
Assert.AreEqual(attributeValue, ((MockCustomTraceListener)createdObject.InnerTraceListener).Attribute);
Assert.IsNotNull(((MockCustomTraceListener)createdObject.InnerTraceListener).Formatter);
Assert.AreSame(typeof(TextFormatter), ((MockCustomTraceListener)createdObject.InnerTraceListener).Formatter.GetType());
Assert.AreEqual("template", ((TextFormatter)((MockCustomTraceListener)createdObject.InnerTraceListener).Formatter).Template);
}
}
public void SavesChangesToConfigurationObject()
{
CustomTraceListenerData sourceElement = new CustomTraceListenerData("name", typeof(bool), "init");
sourceElement.Attributes.Add("att3", "val3");
sourceElement.Attributes.Add("att4", "val4");
sourceElement.Attributes.Add("att5", "val5");
sourceElement.Formatter = "formatter";
sourceElement.Filter = SourceLevels.Information;
sourceElement.TraceOutputOptions = TraceOptions.Callstack;
List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1);
CustomTraceListenerDataWmiMapper.GenerateWmiObjects(sourceElement, settings);
Assert.AreEqual(1, settings.Count);
CustomTraceListenerSetting setting = settings[0] as CustomTraceListenerSetting;
Assert.IsNotNull(setting);
setting.Attributes = new string[] { "att1=val1", "att2=val2" };
setting.Formatter = "formatter override";
setting.InitData = "init override";
setting.ListenerType = typeof(int).AssemblyQualifiedName;
setting.Filter = SourceLevels.All.ToString();
setting.TraceOutputOptions = TraceOptions.DateTime.ToString();
setting.Commit();
Assert.AreEqual(2, sourceElement.Attributes.Count);
Assert.AreEqual("val1", sourceElement.Attributes["att1"]);
Assert.AreEqual("val2", sourceElement.Attributes["att2"]);
Assert.AreEqual("formatter override", sourceElement.Formatter);
Assert.AreEqual("init override", sourceElement.InitData);
Assert.AreEqual(typeof(int), sourceElement.Type);
Assert.AreEqual(SourceLevels.All, sourceElement.Filter);
Assert.AreEqual(TraceOptions.DateTime, sourceElement.TraceOutputOptions);
}
public void ThenConfiguredTraceListenerHasAttributes()
{
CustomTraceListenerData customTl = GetLoggingConfiguration().TraceListeners.OfType <CustomTraceListenerData>().First();
Assert.AreEqual("key", customTl.Attributes.Keys[0]);
Assert.AreEqual("value", customTl.Attributes["key"]);
}
public void CanCreateInstanceWithoutInitializationDataFromConfigurationFile()
{
CustomTraceListenerData listenerData = new CustomTraceListenerData();
listenerData.Name = "listener";
listenerData.Type = typeof(MockCustomTraceListener);
listenerData.ListenerDataType = typeof(CustomTraceListenerData);
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener =
GetListener("listener\u200cimplementation", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings));
Assert.IsNotNull(listener);
Assert.AreEqual("listener\u200cimplementation", listener.Name);
var innerListener = (MockCustomTraceListener)(
(AttributeSettingTraceListenerWrapper)listener).InnerTraceListener;
Assert.IsNull(innerListener.initData);
Assert.IsNull(innerListener.Formatter);
Assert.AreEqual(attributeValue, innerListener.Attribute);
}
public void CanDeserializeSerializedConfiguration()
{
string name = "name";
string initData = "init data";
string attributeName = "attribute";
string attributeValue = "value";
CustomTraceListenerData data = new CustomTraceListenerData(name, typeof(MockCustomTraceListener), initData, TraceOptions.Callstack);
data.SetAttributeValue(attributeName, attributeValue);
LoggingSettings settings = new LoggingSettings();
settings.TraceListeners.Add(data);
IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>();
sections[LoggingSettings.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
LoggingSettings roSettigs = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName);
Assert.AreEqual(1, roSettigs.TraceListeners.Count);
Assert.IsNotNull(roSettigs.TraceListeners.Get(name));
Assert.AreEqual(TraceOptions.Callstack, ((CustomTraceListenerData)roSettigs.TraceListeners.Get(name)).TraceOutputOptions);
Assert.AreSame(typeof(CustomTraceListenerData), roSettigs.TraceListeners.Get(name).GetType());
Assert.AreSame(typeof(CustomTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType);
Assert.AreSame(typeof(MockCustomTraceListener), roSettigs.TraceListeners.Get(name).Type);
Assert.AreEqual(attributeValue, ((CustomTraceListenerData)roSettigs.TraceListeners.Get(name)).Attributes[attributeName]);
}
public void CanCreateInstanceWithFormatterFromConfigurationFile()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), initializationData);
listenerData.Formatter = "formatter";
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.TraceListeners.Add(listenerData);
loggingSettings.Formatters.Add(new TextFormatterData("formatter", "template"));
TraceListener listener =
GetListener("listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings));
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
var innerListener = (MockCustomTraceListener)listener;
Assert.AreEqual(initializationData, innerListener.initData);
Assert.IsNotNull(innerListener.Formatter);
Assert.AreSame(typeof(TextFormatter), innerListener.Formatter.GetType());
Assert.AreEqual("template", ((TextFormatter)(innerListener.Formatter)).Template);
Assert.AreEqual(attributeValue, innerListener.Attribute);
}
public void SetUp()
{
provider = new CustomTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
wmiSettings = new List <ConfigurationSetting>();
configurationObject = new CustomTraceListenerData();
}
public void CreationOfCustomTraceListenerWithoutRequiredSignatureConstructorThrows()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListenerWithInvalidConstructor), initializationData);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, listenerData, helper.configurationSource, reflectionCache);
}
public void SetUp()
{
provider = new CustomTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
machineOptionsKey = new MockRegistryKey(false);
userKey = new MockRegistryKey(true);
userOptionsKey = new MockRegistryKey(false);
configurationObject = new CustomTraceListenerData();
}
public void SetUp()
{
provider = new CustomTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
machineOptionsKey = new MockRegistryKey(false);
userKey = new MockRegistryKey(true);
userOptionsKey = new MockRegistryKey(false);
configurationObject = new CustomTraceListenerData();
}
public void CreationOfCustomTraceListenerWithoutRequiredSignatureConstructorThrows()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListenerWithInvalidConstructor), initializationData);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = GetListener("listener", helper.configurationSource);
}
public void Given()
{
listenerData =
new CustomTraceListenerData(
"custom trace listener",
typeof(System.Diagnostics.TextWriterTraceListener),
"someInitData")
{
Formatter = "formatter"
};
}
public void Given()
{
listenerData =
new CustomTraceListenerData(
"custom trace listener",
typeof(MockCustomTraceListener),
"someInitData")
{
Formatter = "formatter"
};
}
private static CustomTraceListenerData GetConsoleListener()
{
var consoleListener = new CustomTraceListenerData();
consoleListener.Name = CONSOLE;
consoleListener.Type = typeof(ConsoleTraceListener);
consoleListener.ListenerDataType = typeof(CustomTraceListenerData);
consoleListener.Filter = SourceLevels.All;
consoleListener.TraceOutputOptions = TraceOptions.None;
consoleListener.Formatter = "MsgFormatter";
return(consoleListener);
}
public void CanCreateInstanceFromGivenConfiguration()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), initializationData);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, listenerData, helper.configurationSource, reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(typeof(MockCustomTraceListener), listener.GetType());
Assert.AreEqual(initializationData, ((MockCustomTraceListener)listener).initData);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:CustomTraceListenerNode"/> class.
/// </summary>
/// <param name="customTraceListenerData">The custom trace listener data.</param>
public CustomTraceListenerNode(CustomTraceListenerData customTraceListenerData)
{
if (null == customTraceListenerData) throw new ArgumentNullException("customTraceListenerData");
Rename(customTraceListenerData.Name);
TraceOutputOptions = customTraceListenerData.TraceOutputOptions;
this.formatterName = customTraceListenerData.Formatter;
this.type = customTraceListenerData.Type;
foreach (string key in customTraceListenerData.Attributes)
{
editableAttributes.Add(new EditableKeyValue(key, customTraceListenerData.Attributes[key]));
}
}
public static void GenerateWmiObjects(CustomTraceListenerData data,
ICollection <ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(
new CustomTraceListenerSetting(data,
data.Name,
data.Type.AssemblyQualifiedName,
data.InitData,
CustomDataWmiMapperHelper.GenerateAttributesArray(data.Attributes),
data.TraceOutputOptions.ToString(),
data.Filter.ToString(),
data.Formatter));
}
public SendToCustomTraceListenerBuilder(ILoggingConfigurationSendTo context, string listenerName, Type customTraceListenerType, NameValueCollection attributes)
: base(context)
{
customListener = new CustomTraceListenerData()
{
Name = listenerName,
Type = customTraceListenerType
};
customListener.Attributes.Add(attributes);
base.AddTraceListenerToSettingsAndCategory(customListener);
}
public void CanCreateInstanceFromGivenName()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), initializationData);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = GetListener("listener", helper.configurationSource);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(typeof(MockCustomTraceListener), listener.GetType());
Assert.AreEqual(initializationData, ((MockCustomTraceListener)listener).initData);
}
public CustomTraceListenerNode(CustomTraceListenerData customTraceListenerData)
{
if (null == customTraceListenerData)
{
throw new ArgumentNullException("customTraceListenerData");
}
Rename(customTraceListenerData.Name);
TraceOutputOptions = customTraceListenerData.TraceOutputOptions;
this.formatterName = customTraceListenerData.Formatter;
this.typeName = customTraceListenerData.TypeName;
foreach (string key in customTraceListenerData.Attributes)
{
editableAttributes.Add(new EditableKeyValue(key, customTraceListenerData.Attributes[key]));
}
}
public void CustomTraceListenerDataTest()
{
string attributeKey = "attKey";
string attributeValue = "attValue";
string name = "some name";
Type type = typeof(FormattedEventLogTraceListener);
CustomTraceListenerData data = new CustomTraceListenerData();
data.Name = name;
data.Type = type;
data.Attributes.Add(attributeKey, attributeValue);
CustomTraceListenerNode node = new CustomTraceListenerNode(data);
Assert.AreEqual(name, node.Name);
Assert.AreEqual(type.AssemblyQualifiedName, node.Type);
Assert.AreEqual(attributeKey, node.Attributes[0].Key);
Assert.AreEqual(attributeValue, node.Attributes[0].Value);
}
public void CanCreateInstanceFromConfigurationFile()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), initializationData);
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(typeof(MockCustomTraceListener), listener.GetType());
Assert.AreEqual(initializationData, ((MockCustomTraceListener)listener).initData);
Assert.IsNull(((MockCustomTraceListener)listener).Formatter);
Assert.AreEqual(attributeValue, ((MockCustomTraceListener)listener).Attribute);
}
public void CustomTraceListenerNodeTest()
{
string attributeKey = "attKey";
string attributeValue = "attValue";
string name = "some name";
Type type = typeof(FormattedEventLogTraceListener);
CustomTraceListenerNode customTraceListenerNode = new CustomTraceListenerNode();
customTraceListenerNode.Attributes.Add(new EditableKeyValue(attributeKey, attributeValue));
customTraceListenerNode.Name = name;
customTraceListenerNode.Type = type.AssemblyQualifiedName;
ApplicationNode.AddNode(customTraceListenerNode);
CustomTraceListenerData nodeData = (CustomTraceListenerData)customTraceListenerNode.TraceListenerData;
Assert.AreEqual(name, nodeData.Name);
Assert.AreEqual(type, nodeData.Type);
Assert.AreEqual(attributeKey, nodeData.Attributes.AllKeys[0]);
Assert.AreEqual(attributeValue, nodeData.Attributes[attributeKey]);
}
public void CustomTraceListenerDataTest()
{
string attributeKey = "attKey";
string attributeValue = "attValue";
string name = "some name";
Type type = typeof(FormattedEventLogTraceListener);
CustomTraceListenerData data = new CustomTraceListenerData();
data.Name = name;
data.Type = type;
data.Attributes.Add(attributeKey, attributeValue);
CustomTraceListenerNode node = new CustomTraceListenerNode(data);
Assert.AreEqual(name, node.Name);
Assert.AreEqual(type, node.Type);
Assert.AreEqual(attributeKey, node.Attributes[0].Key);
Assert.AreEqual(attributeValue, node.Attributes[0].Value);
}
public void CanCreatePoliciesForCustomTraceListener()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), "", TraceOptions.Callstack);
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
loggingSettings.TraceListeners.Add(listenerData);
container.AddExtension(new LoggingBlockExtension());
TraceListener createdObject = container.Resolve <TraceListener>("listener");
Assert.IsNotNull(createdObject);
Assert.AreEqual("listener", createdObject.Name);
Assert.AreEqual(TraceOptions.Callstack, createdObject.TraceOutputOptions);
Assert.AreEqual(typeof(MockCustomTraceListener), createdObject.GetType());
Assert.AreEqual(null, ((MockCustomTraceListener)createdObject).initData); // configured with "", but set to null
Assert.AreEqual(attributeValue, ((MockCustomTraceListener)createdObject).Attribute);
Assert.IsNull(((MockCustomTraceListener)createdObject).Formatter);
}
public void CustomTraceListenerNodeDataTest()
{
string attributeKey = "attKey";
string attributeValue = "attValue";
string name = "some name";
Type type = typeof(FormattedEventLogTraceListener);
CustomTraceListenerData customTraceListenerData = new CustomTraceListenerData();
customTraceListenerData.Attributes.Add(attributeKey, attributeValue);
customTraceListenerData.Name = name;
customTraceListenerData.Type = type;
CustomTraceListenerNode customTraceListenerNode = new CustomTraceListenerNode(customTraceListenerData);
ApplicationNode.AddNode(customTraceListenerNode);
CustomTraceListenerData nodeData = (CustomTraceListenerData)customTraceListenerNode.TraceListenerData;
Assert.AreEqual(name, nodeData.Name);
Assert.AreEqual(type, nodeData.Type);
Assert.AreEqual(attributeKey, nodeData.Attributes.AllKeys[0]);
Assert.AreEqual(attributeValue, nodeData.Attributes[attributeKey]);
}
public void CanCreateInstanceFromGivenConfigurationWithAttributes()
{
CustomTraceListenerData listenerData
= new CustomTraceListenerData("listener", typeof(MockCustomTraceListener), initializationData);
listenerData.SetAttributeValue(MockCustomTraceListener.AttributeKey, attributeValue);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = GetListener("listener", helper.configurationSource);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
var innerListener = (MockCustomTraceListener)listener;
Assert.AreEqual(initializationData, innerListener.initData);
Assert.AreEqual(attributeValue, innerListener.Attribute);
}
public void ThenCustomTraceListenerHasAppropriateType()
{
CustomTraceListenerData customTl = GetLoggingConfiguration().TraceListeners.OfType <CustomTraceListenerData>().First();
Assert.AreEqual(typeof(TestCustomTraceListener), customTl.Type);
}
public void ThenFilterIsAll()
{
CustomTraceListenerData customTl = GetLoggingConfiguration().TraceListeners.OfType <CustomTraceListenerData>().First();
Assert.AreEqual(SourceLevels.All, customTl.Filter);
}
public void ThenTraceOptionsIsNone()
{
CustomTraceListenerData customTl = GetLoggingConfiguration().TraceListeners.OfType <CustomTraceListenerData>().First();
Assert.AreEqual(TraceOptions.None, customTl.TraceOutputOptions);
}
public void ThenCustomTraceListenerAppearsInConfiguration()
{
CustomTraceListenerData customTl = GetLoggingConfiguration().TraceListeners.OfType <CustomTraceListenerData>().First();
Assert.AreEqual("custom", customTl.Name);
}
public void Given()
{
listenerData = new CustomTraceListenerData("someName",
typeof(MockCustomTraceListenerWithoutExpectedConstructor),
"initData");
}
public void WhenCreatingInstanceUsingDefaultContructor_ThenListenerDataTypeIsSet()
{
var listener = new CustomTraceListenerData();
Assert.AreEqual(typeof(CustomTraceListenerData), listener.ListenerDataType);
}
