public void CanDeserializeSerializedConfiguration()
{
string name = "name";
string source = "source";
string log = "log";
string machine = "machine";
string formatter = "formatter";
TraceListenerData data = new FormattedEventLogTraceListenerData(name, source, log, machine,
formatter, TraceOptions.Callstack);
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, roSettigs.TraceListeners.Get(name).TraceOutputOptions);
Assert.AreSame(typeof(FormattedEventLogTraceListenerData), roSettigs.TraceListeners.Get(name).GetType());
Assert.AreSame(typeof(FormattedEventLogTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType);
Assert.AreSame(typeof(FormattedEventLogTraceListener), roSettigs.TraceListeners.Get(name).Type);
Assert.AreEqual(formatter, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter);
Assert.AreEqual(log, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Log);
Assert.AreEqual(machine, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).MachineName);
Assert.AreEqual(source, ((FormattedEventLogTraceListenerData)roSettigs.TraceListeners.Get(name)).Source);
}
public SendToFormattedEventLogTraceListenerBuilder(ILoggingConfigurationSendTo context, string listenerName)
:base(context)
{
eventLogListener = new FormattedEventLogTraceListenerData
{
Name = listenerName
};
base.AddTraceListenerToSettingsAndCategory(eventLogListener);
}
public void ListenerDataIsCreatedCorrectly()
{
FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData("listener", "unknown source", "custom", "machine", "formatter");
Assert.AreSame(typeof(FormattedEventLogTraceListener), listenerData.Type);
Assert.AreSame(typeof(FormattedEventLogTraceListenerData), listenerData.ListenerDataType);
Assert.AreEqual("listener", listenerData.Name);
Assert.AreEqual("unknown source", listenerData.Source);
Assert.AreEqual("formatter", listenerData.Formatter);
Assert.AreEqual("custom", listenerData.Log);
Assert.AreEqual("machine", listenerData.MachineName);
}
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
FormattedEventLogTraceListenerData castedObjectConfiguration
= (FormattedEventLogTraceListenerData)objectConfiguration;
ILogFormatter formatter
= GetFormatter(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new FormattedEventLogTraceListener(
castedObjectConfiguration.Source,
castedObjectConfiguration.Log,
castedObjectConfiguration.MachineName,
formatter);
return(createdObject);
}
public void CanCreateInstanceFromConfigurationFileWithMinimalConfiguration()
{
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.Formatters.Add(new TextFormatterData("formatter", "foobar template"));
FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData();
listenerData.Name = "listener";
listenerData.Type = typeof(FormattedEventLogTraceListener);
listenerData.ListenerDataType = typeof(FormattedEventLogTraceListenerData);
listenerData.Source = "unknown source";
listenerData.Formatter = "formatter";
loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(FormattedEventLogTraceListener));
FormattedEventLogTraceListener castedListener = (FormattedEventLogTraceListener)listener;
Assert.IsNotNull(castedListener.Formatter);
Assert.AreEqual("unknown source", ((EventLogTraceListener)castedListener.SlaveListener).EventLog.Source);
Assert.AreEqual(FormattedEventLogTraceListener.DefaultLogName, ((EventLogTraceListener)castedListener.SlaveListener).EventLog.Log);
Assert.AreEqual(FormattedEventLogTraceListener.DefaultMachineName, ((EventLogTraceListener)castedListener.SlaveListener).EventLog.MachineName);
Assert.AreEqual(castedListener.Formatter.GetType(), typeof(TextFormatter));
Assert.AreEqual("foobar template", ((TextFormatter)castedListener.Formatter).Template);
}
public void CanCreateInstanceFromGivenName()
{
FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData("listener", "unknown source", "formatter");
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.Formatters.Add(new TextFormatterData("formatter", "foobar template"));
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", helper.configurationSource, reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(listener.GetType(), typeof(FormattedEventLogTraceListener));
FormattedEventLogTraceListener castedListener = (FormattedEventLogTraceListener)listener;
Assert.IsNotNull(castedListener.Formatter);
Assert.AreEqual("unknown source", ((EventLogTraceListener)castedListener.SlaveListener).EventLog.Source);
Assert.AreEqual(FormattedEventLogTraceListener.DefaultLogName, ((EventLogTraceListener)castedListener.SlaveListener).EventLog.Log);
Assert.AreEqual(FormattedEventLogTraceListener.DefaultMachineName, ((EventLogTraceListener)castedListener.SlaveListener).EventLog.MachineName);
Assert.AreEqual(castedListener.Formatter.GetType(), typeof(TextFormatter));
Assert.AreEqual("foobar template", ((TextFormatter)castedListener.Formatter).Template);
}
public void CanCreateInstanceFromGivenName()
{
FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData("listener", "unknown source", "formatter");
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.Formatters.Add(new TextFormatterData("formatter", "some template"));
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = GetListener("listener", helper.configurationSource);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(listener.GetType(), typeof(FormattedEventLogTraceListener));
FormattedEventLogTraceListener castedListener = (FormattedEventLogTraceListener)listener;
Assert.IsNotNull(castedListener.Formatter);
Assert.AreEqual("unknown source", ((EventLogTraceListener)castedListener.InnerListener).EventLog.Source);
Assert.AreEqual(FormattedEventLogTraceListener.DefaultMachineName, ((EventLogTraceListener)castedListener.InnerListener).EventLog.MachineName);
Assert.AreEqual(castedListener.Formatter.GetType(), typeof(TextFormatter));
Assert.AreEqual("some template", ((TextFormatter)castedListener.Formatter).Template);
try
{
Assert.AreEqual(FormattedEventLogTraceListener.DefaultLogName, ((EventLogTraceListener)castedListener.InnerListener).EventLog.Log);
}
catch (SecurityException ex)
{
Assert.Inconclusive("In order to run the tests, please run Visual Studio as Administrator.\r\n{0}", ex.ToString());
}
}
public void CanCreatePoliciesForFormattedEventLogTraceListenerWithFormatter()
{
FormattedEventLogTraceListenerData listenerData
= new FormattedEventLogTraceListenerData("listener", CommonUtil.EventLogSourceName, CommonUtil.EventLogName, "machine", "formatter");
listenerData.TraceOutputOptions = TraceOptions.Callstack | TraceOptions.ProcessId;
listenerData.Filter = SourceLevels.Error;
loggingSettings.TraceListeners.Add(listenerData);
FormatterData formatterData = new TextFormatterData("formatter", "template");
loggingSettings.Formatters.Add(formatterData);
using (var container = CreateContainer())
{
FormattedEventLogTraceListener createdObject =
(FormattedEventLogTraceListener)container.Resolve<TraceListener>("listener\u200cimplementation");
Assert.IsNotNull(createdObject);
Assert.AreEqual(listenerData.TraceOutputOptions, createdObject.TraceOutputOptions);
Assert.IsNotNull(createdObject.Filter);
Assert.IsInstanceOfType(createdObject.Filter, typeof(EventTypeFilter));
Assert.AreEqual(listenerData.Filter, ((EventTypeFilter)createdObject.Filter).EventType);
Assert.IsNotNull(createdObject.Formatter);
Assert.AreSame(typeof(TextFormatter), createdObject.Formatter.GetType());
Assert.AreEqual("template", ((TextFormatter)createdObject.Formatter).Template);
Assert.AreEqual(CommonUtil.EventLogSourceName, ((EventLogTraceListener)createdObject.InnerListener).EventLog.Source);
Assert.AreEqual(CommonUtil.EventLogName, ((EventLogTraceListener)createdObject.InnerListener).EventLog.Log);
Assert.AreEqual("machine", ((EventLogTraceListener)createdObject.InnerListener).EventLog.MachineName);
}
}
private EntLib.TraceListenerData GetEventLogTraceListener()
{
var eventLogListener = new EntLib.FormattedEventLogTraceListenerData();
eventLogListener.Name = EventLogTraceListenerName;
eventLogListener.TraceOutputOptions = TraceOptions.Callstack;
eventLogListener.Type = typeof(FormattedEventLogTraceListener);
eventLogListener.ListenerDataType = typeof(EntLib.FormattedEventLogTraceListenerData);
eventLogListener.Filter = SourceLevels.All;
eventLogListener.Formatter = TextFormatterName;
if (string.IsNullOrEmpty(PlatformApplication.Current.Name))
{
eventLogListener.Source = DefaultEventSource;
}
else
{
eventLogListener.Source = PlatformApplication.Current.Name;
}
return eventLogListener;
}
