public void EmailTraceListenerNodeDataTest()
{
string name = "some name";
string subjectSuffix = "subject suffix";
string subjectPrefix = "subject prefix";
string toAddress = "some to address";
string fromAddress = "some from address";
string smtpServer = "some server";
int smtpPort = 123;
EmailTraceListenerData emailTraceListenerData = new EmailTraceListenerData();
emailTraceListenerData.Name = name;
emailTraceListenerData.ToAddress = toAddress;
emailTraceListenerData.FromAddress = fromAddress;
emailTraceListenerData.SmtpServer = smtpServer;
emailTraceListenerData.SmtpPort = smtpPort;
emailTraceListenerData.SubjectLineEnder = subjectSuffix;
emailTraceListenerData.SubjectLineStarter = subjectPrefix;
EmailTraceListenerNode emailTraceListenerNode = new EmailTraceListenerNode(emailTraceListenerData);
ApplicationNode.AddNode(emailTraceListenerNode);
Assert.AreEqual(name, emailTraceListenerNode.Name);
Assert.AreEqual(subjectSuffix, emailTraceListenerNode.SubjectLineEnder);
Assert.AreEqual(subjectPrefix, emailTraceListenerNode.SubjectLineStarter);
Assert.AreEqual(toAddress, emailTraceListenerNode.ToAddress);
Assert.AreEqual(fromAddress, emailTraceListenerNode.FromAddress);
Assert.AreEqual(smtpPort, emailTraceListenerNode.SmtpPort);
Assert.AreEqual(smtpServer, emailTraceListenerNode.SmtpServer);
}
public void EmailTraceListenerNodeTest()
{
string name = "some name";
string subjectSuffix = "subject suffix";
string subjectPrefix = "subject prefix";
string toAddress = "some to address";
string fromAddress = "some from address";
string smtpServer = "some server";
int smtpPort = 123;
EmailTraceListenerNode emailTraceListenerNode = new EmailTraceListenerNode();
emailTraceListenerNode.Name = name;
emailTraceListenerNode.SubjectLineStarter = subjectPrefix;
emailTraceListenerNode.SubjectLineEnder = subjectSuffix;
emailTraceListenerNode.ToAddress = toAddress;
emailTraceListenerNode.FromAddress = fromAddress;
emailTraceListenerNode.SmtpServer = smtpServer;
emailTraceListenerNode.SmtpPort = smtpPort;
ApplicationNode.AddNode(emailTraceListenerNode);
EmailTraceListenerData nodeData = (EmailTraceListenerData)emailTraceListenerNode.TraceListenerData;
Assert.AreEqual(name, nodeData.Name);
Assert.AreEqual(subjectSuffix, nodeData.SubjectLineEnder);
Assert.AreEqual(subjectPrefix, nodeData.SubjectLineStarter);
Assert.AreEqual(toAddress, nodeData.ToAddress);
Assert.AreEqual(fromAddress, nodeData.FromAddress);
Assert.AreEqual(smtpPort, nodeData.SmtpPort);
Assert.AreEqual(smtpServer, nodeData.SmtpServer);
}
public void EmailTraceListenerNodeDataTest()
{
string name = "some name";
string subjectSuffix = "subject suffix";
string subjectPrefix = "subject prefix";
string toAddress = "some to address";
string fromAddress = "some from address";
string smtpServer = "some server";
int smtpPort = 123;
SourceLevels filter = SourceLevels.Critical;
EmailTraceListenerData emailTraceListenerData = new EmailTraceListenerData();
emailTraceListenerData.Name = name;
emailTraceListenerData.ToAddress = toAddress;
emailTraceListenerData.FromAddress = fromAddress;
emailTraceListenerData.SmtpServer = smtpServer;
emailTraceListenerData.SmtpPort = smtpPort;
emailTraceListenerData.SubjectLineEnder = subjectSuffix;
emailTraceListenerData.SubjectLineStarter = subjectPrefix;
emailTraceListenerData.Filter = filter;
EmailTraceListenerNode emailTraceListenerNode = new EmailTraceListenerNode(emailTraceListenerData);
ApplicationNode.AddNode(emailTraceListenerNode);
Assert.AreEqual(name, emailTraceListenerNode.Name);
Assert.AreEqual(subjectSuffix, emailTraceListenerNode.SubjectLineEnder);
Assert.AreEqual(subjectPrefix, emailTraceListenerNode.SubjectLineStarter);
Assert.AreEqual(toAddress, emailTraceListenerNode.ToAddress);
Assert.AreEqual(fromAddress, emailTraceListenerNode.FromAddress);
Assert.AreEqual(smtpPort, emailTraceListenerNode.SmtpPort);
Assert.AreEqual(smtpServer, emailTraceListenerNode.SmtpServer);
Assert.AreEqual(filter, emailTraceListenerNode.Filter);
}
public void CanCreatePoliciesForEmailTraceListenerWithFormatter()
{
EmailTraceListenerData listenerData
= new EmailTraceListenerData("listener", "to address", "from address", "starter", "ender", "smtp", 25, "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())
{
EmailTraceListener createdObject =
(EmailTraceListener)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);
}
}
public void CanCreatePoliciesForEmailTraceListenerWithFormatter()
{
EmailTraceListenerData listenerData
= new EmailTraceListenerData("listener", "to address", "from address", "starter", "ender", "smtp", 25, "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);
container.AddExtension(new LoggingBlockExtension());
EmailTraceListener createdObject = (EmailTraceListener)container.Resolve <TraceListener>("listener");
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);
// TODO test the actual values used to create the listener
}
public void SetUp()
{
provider = new ConfigurationElementManageabilityProviderWrapper(new EmailTraceListenerDataManageabilityProvider());
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
wmiSettings = new List <ConfigurationSetting>();
configurationObject = new EmailTraceListenerData();
}
public void SetUp()
{
provider = new EmailTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
machineOptionsKey = new MockRegistryKey(false);
userKey = new MockRegistryKey(true);
userOptionsKey = new MockRegistryKey(false);
configurationObject = new EmailTraceListenerData();
}
public void SetUp()
{
provider = new EmailTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
machineOptionsKey = new MockRegistryKey(false);
userKey = new MockRegistryKey(true);
userOptionsKey = new MockRegistryKey(false);
configurationObject = new EmailTraceListenerData();
}
public void ListenerDataIsCreatedCorrectly()
{
EmailTraceListenerData listenerData = CreateDefaultData();
Assert.AreSame(typeof(EmailTraceListener), listenerData.Type);
Assert.AreSame(typeof(EmailTraceListenerData), listenerData.ListenerDataType);
Assert.AreEqual("listener", listenerData.Name);
Assert.AreEqual("smtphost", listenerData.SmtpServer);
Assert.AreEqual("formatter", listenerData.Formatter);
}
public MockEmailTraceListener(string toAddress,
string fromAddress,
string subjectLineStarter,
string subjectLineEnder,
string smtpServer,
int smtpPort,
ILogFormatter formatter)
: base(toAddress, fromAddress, subjectLineStarter, subjectLineEnder, smtpServer, smtpPort, formatter)
{
this.emailData = new EmailTraceListenerData(toAddress, fromAddress, subjectLineStarter, subjectLineEnder, smtpServer, smtpPort, string.Empty);
}
public void CanUseSSLWhenUnauthenticated()
{
var listenerData = new EmailTraceListenerData("listener",
"[email protected]", "*****@*****.**",
"EntLib-Logging:", "has occurred",
"smtphost", 25,
"formatter", TraceOptions.None, SourceLevels.All,
EmailAuthenticationMode.None, null, null, true);
Assert.IsTrue(listenerData.UseSSL);
}
public void CanSetUserNameAndPassword()
{
var listenerData = new EmailTraceListenerData("listener",
"[email protected]", "*****@*****.**",
"EntLib-Logging:", "has occurred",
"smtphost", 25,
"formatter", TraceOptions.None, SourceLevels.All,
EmailAuthenticationMode.UserNameAndPassword, "user", "secret", true);
Assert.AreEqual(EmailAuthenticationMode.UserNameAndPassword, listenerData.AuthenticationMode);
Assert.AreEqual("user", listenerData.UserName);
Assert.AreEqual("secret", listenerData.Password);
}
/// <summary>
/// Configures the email-based trace listener with custom address information.
/// </summary>
/// <param name="fromAddress">Email address that messages will be sent from.</param>
/// <param name="toAddress">One or more email semicolon separated addresses.</param>
public void ConfigureEmailTraceListener(string fromAddress, string toAddress)
{
if (this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName))
{
EmailTraceListenerData listenerData = this.loggingSettings.TraceListeners.Get(Resources.EmailTraceListenerName) as EmailTraceListenerData;
if (listenerData != null)
{
listenerData.FromAddress = fromAddress;
listenerData.ToAddress = toAddress;
}
}
}
/// <summary>
/// Initialize a new instance of the <see cref="EmailTraceListenerNode"/> class with a <see cref="EmailTraceListenerData"/> class.
/// </summary>
/// <param name="emailTraceListenerData">A <see cref="EmailTraceListenerData"/> class.</param>
public EmailTraceListenerNode(EmailTraceListenerData emailTraceListenerData)
{
if (null == emailTraceListenerData) throw new ArgumentNullException("emailTraceListenerData");
Rename(emailTraceListenerData.Name);
TraceOutputOptions = emailTraceListenerData.TraceOutputOptions;
this.formatterName = emailTraceListenerData.Formatter;
this.toAddress = emailTraceListenerData.ToAddress;
this.fromAddress = emailTraceListenerData.FromAddress;
this.subjectLineStarter = emailTraceListenerData.SubjectLineStarter;
this.subjectLineEnder = emailTraceListenerData.SubjectLineEnder;
this.smtpServer = emailTraceListenerData.SmtpServer;
this.smtpPort = emailTraceListenerData.SmtpPort;
}
public static void GenerateWmiObjects(EmailTraceListenerData configurationObject,
ICollection <ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(
new EmailTraceListenerSetting(configurationObject,
configurationObject.Name,
configurationObject.Formatter,
configurationObject.FromAddress,
configurationObject.SmtpPort,
configurationObject.SmtpServer,
configurationObject.SubjectLineEnder,
configurationObject.SubjectLineStarter,
configurationObject.ToAddress,
configurationObject.TraceOutputOptions.ToString(),
configurationObject.Filter.ToString()));
}
/// <summary>
/// Configures the email-based trace listener with custom SMTP server configuration.
/// </summary>
/// <param name="serverName">The SMTP server to use to send messages.</param>
/// <param name="serverPort">The SMTP port.</param>
/// <param name="userName">User name when authenticating with user name and password.</param>
/// <param name="password">Password when authenticating with user name and password.</param>
/// <param name="useSsl">A flag indicating whether or not it is required to use SSL when connecting to the SMTP server.</param>
public void ConfigureEmailTraceListenerSmtpServer(string serverName, int serverPort, string userName, string password, bool useSsl)
{
if (this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName))
{
EmailTraceListenerData listenerData = this.loggingSettings.TraceListeners.Get(Resources.EmailTraceListenerName) as EmailTraceListenerData;
if (listenerData != null)
{
listenerData.SmtpServer = serverName;
listenerData.SmtpPort = 25;
listenerData.UserName = userName;
listenerData.Password = password;
listenerData.UseSSL = useSsl;
}
}
}
/// <summary>
/// Initialize a new instance of the <see cref="EmailTraceListenerNode"/> class with a <see cref="EmailTraceListenerData"/> class.
/// </summary>
/// <param name="emailTraceListenerData">A <see cref="EmailTraceListenerData"/> class.</param>
public EmailTraceListenerNode(EmailTraceListenerData emailTraceListenerData)
{
if (null == emailTraceListenerData)
{
throw new ArgumentNullException("emailTraceListenerData");
}
Rename(emailTraceListenerData.Name);
TraceOutputOptions = emailTraceListenerData.TraceOutputOptions;
this.formatterName = emailTraceListenerData.Formatter;
this.toAddress = emailTraceListenerData.ToAddress;
this.fromAddress = emailTraceListenerData.FromAddress;
this.subjectLineStarter = emailTraceListenerData.SubjectLineStarter;
this.subjectLineEnder = emailTraceListenerData.SubjectLineEnder;
this.smtpServer = emailTraceListenerData.SmtpServer;
this.smtpPort = emailTraceListenerData.SmtpPort;
}
public void SavesChangesToConfigurationObject()
{
EmailTraceListenerData sourceElement = new EmailTraceListenerData();
sourceElement.Filter = SourceLevels.Error;
sourceElement.Formatter = "formatter";
sourceElement.FromAddress = "from";
sourceElement.SmtpPort = 25;
sourceElement.SmtpServer = "server";
sourceElement.SubjectLineEnder = "ender";
sourceElement.SubjectLineStarter = "starter";
sourceElement.ToAddress = "to";
sourceElement.Filter = SourceLevels.Information;
sourceElement.TraceOutputOptions = TraceOptions.Callstack;
List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1);
EmailTraceListenerDataWmiMapper.GenerateWmiObjects(sourceElement, settings);
Assert.AreEqual(1, settings.Count);
EmailTraceListenerSetting setting = settings[0] as EmailTraceListenerSetting;
Assert.IsNotNull(setting);
setting.Formatter = "updated formatter";
setting.FromAddress = "updated from";
setting.SmtpPort = 26;
setting.SmtpServer = "updated server";
setting.SubjectLineEnder = "updated ender";
setting.SubjectLineStarter = "updated starter";
setting.ToAddress = "updated to";
setting.Filter = SourceLevels.All.ToString();
setting.TraceOutputOptions = TraceOptions.LogicalOperationStack.ToString();
;
setting.Commit();
Assert.AreEqual("updated formatter", sourceElement.Formatter);
Assert.AreEqual("updated from", sourceElement.FromAddress);
Assert.AreEqual(26, sourceElement.SmtpPort);
Assert.AreEqual("updated server", sourceElement.SmtpServer);
Assert.AreEqual("updated ender", sourceElement.SubjectLineEnder);
Assert.AreEqual("updated starter", sourceElement.SubjectLineStarter);
Assert.AreEqual("updated to", sourceElement.ToAddress);
Assert.AreEqual(SourceLevels.All, sourceElement.Filter);
Assert.AreEqual(TraceOptions.LogicalOperationStack, sourceElement.TraceOutputOptions);
}
public void CanDeserializeSerializedConfiguration()
{
string name = "name";
string toAddress = "[email protected]";
string fromAddress = "*****@*****.**";
string subjectStarter = "EntLib-Logging:";
string subjectEnder = "has occurred";
string server = "smtphost";
int port = 25;
string formatter = "formatter";
TraceListenerData data = new EmailTraceListenerData(name, toAddress, fromAddress, subjectStarter,
subjectEnder, server, port, formatter, TraceOptions.Callstack, SourceLevels.Critical);
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.AreEqual(SourceLevels.Critical, roSettigs.TraceListeners.Get(name).Filter);
Assert.AreSame(typeof(EmailTraceListenerData), roSettigs.TraceListeners.Get(name).GetType());
Assert.AreSame(typeof(EmailTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType);
Assert.AreSame(typeof(EmailTraceListener), roSettigs.TraceListeners.Get(name).Type);
Assert.AreEqual(formatter, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter);
Assert.AreEqual(fromAddress, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).FromAddress);
Assert.AreEqual(port, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).SmtpPort);
Assert.AreEqual(server, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).SmtpServer);
Assert.AreEqual(subjectEnder, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).SubjectLineEnder);
Assert.AreEqual(subjectStarter, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).SubjectLineStarter);
Assert.AreEqual(toAddress, ((EmailTraceListenerData)roSettigs.TraceListeners.Get(name)).ToAddress);
}
public EmailTraceListenerSetting(EmailTraceListenerData sourceElement,
string name,
string formatter,
string fromAddress,
int smtpPort,
string smtpServer,
string subjectLineEnder,
string subjectLineStarter,
string toAddress,
string traceOutputOptions,
string filter)
: base(sourceElement, name, traceOutputOptions, filter)
{
this.formatter = formatter;
this.fromAddress = fromAddress;
this.smtpPort = smtpPort;
this.smtpServer = smtpServer;
this.subjectLineEnder = subjectLineEnder;
this.subjectLineStarter = subjectLineStarter;
this.toAddress = toAddress;
}
public void AuthenticationModeIsNoneWhenUnspecified()
{
EmailTraceListenerData listenerData = CreateDefaultData();
Assert.AreEqual(EmailAuthenticationMode.None, listenerData.AuthenticationMode);
}
public void WhenCreatingInstanceUsingDefaultContructor_ThenListenerDataTypeIsSet()
{
var listener = new EmailTraceListenerData();
Assert.AreEqual(typeof(EmailTraceListenerData), listener.ListenerDataType);
}
public void WhenCreatingInstanceUsingDefaultContructor_ThenListenerDataTypeIsSet()
{
var listener = new EmailTraceListenerData();
Assert.AreEqual(typeof(EmailTraceListenerData), listener.ListenerDataType);
}
private void ApplyDefaultTraceListener()
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDebugTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDebugTraceListenerName))
{
CustomTraceListenerData listenerData = new CustomTraceListenerData();
listenerData.Formatter = Resources.TraceLogTextFormatterName;
listenerData.Type = typeof(FormattedDebugTraceListener);
listenerData.Name = Resources.FormattedDebugTraceListenerName;
listenerData.TraceOutputOptions = TraceOptions.None;
listenerData.Filter = SourceLevels.All;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
if (!this.loggingSettings.TraceListeners.Contains(Resources.TraceLogTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.TraceLogTraceListenerName))
{
CustomTraceListenerData listenerData = new CustomTraceListenerData();
listenerData.Formatter = Resources.TraceLogTextFormatterName;
listenerData.Type = typeof(FormattedTextWriterTraceListener);
listenerData.Name = Resources.TraceLogTraceListenerName;
listenerData.TraceOutputOptions = TraceOptions.None;
listenerData.Filter = SourceLevels.All;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
if (!this.loggingSettings.TraceListeners.Contains(Resources.EventLogTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.EventLogTraceListenerName))
{
FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData();
listenerData.Formatter = Resources.EventLogTextFormatterName;
listenerData.Type = typeof(FormattedEventLogTraceListener);
listenerData.Name = Resources.EventLogTraceListenerName;
listenerData.MachineName = ".";
listenerData.Source = AppDomain.CurrentDomain.SetupInformation.ApplicationName;
listenerData.Log = Resources.DefaultEventLogTraceListenerLogName;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
if (!this.loggingSettings.TraceListeners.Contains(Resources.RollingFlatFileTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.RollingFlatFileTraceListenerName))
{
RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData();
listenerData.Name = Resources.RollingFlatFileTraceListenerName;
listenerData.Formatter = Resources.TraceLogTextFormatterName;
listenerData.FileName = Path.ChangeExtension(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, ".log");
listenerData.Footer = String.Empty;
listenerData.Header = String.Empty;
listenerData.TimeStampPattern = Resources.RollingFlatFileTraceListenerTimeStampPattern;
listenerData.MaxArchivedFiles = 10;
listenerData.RollFileExistsBehavior = RollFileExistsBehavior.Increment;
listenerData.RollSizeKB = 10240;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
if (!this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName))
{
EmailTraceListenerData listenerData = new EmailTraceListenerData();
listenerData.Name = Resources.EmailTraceListenerName;
listenerData.AuthenticationMode = EmailAuthenticationMode.UserNameAndPassword;
listenerData.Formatter = Resources.EventLogTextFormatterName;
listenerData.SmtpPort = 25;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDatabaseTraceListenerName))
{
lock (this.listenerLock)
{
if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDatabaseTraceListenerName))
{
FormattedDatabaseTraceListenerData listenerData = new FormattedDatabaseTraceListenerData();
listenerData.Name = Resources.FormattedDatabaseTraceListenerName;
listenerData.AddCategoryStoredProcName = SqlCommandResources.AddCategoryStoredProcName;
listenerData.WriteLogStoredProcName = SqlCommandResources.WriteLogStoredProcName;
this.loggingSettings.TraceListeners.Add(listenerData);
}
}
}
}
public void CanDeserializeSerializedConfiguration()
{
const string name = "name";
const string toAddress = "[email protected]";
const string fromAddress = "*****@*****.**";
const string subjectStarter = "EntLib-Logging:";
const string subjectEnder = "has occurred";
const string server = "smtphost";
const int port = 25;
const string formatter = "formatter";
const string user = "******";
const string password = "******";
var data = new EmailTraceListenerData
{
Name = name,
ToAddress = toAddress,
FromAddress = fromAddress,
SubjectLineStarter = subjectStarter,
SubjectLineEnder = subjectEnder,
SmtpServer = server,
SmtpPort = port,
Formatter = formatter,
TraceOutputOptions = TraceOptions.Callstack,
Filter = SourceLevels.Critical,
AuthenticationMode = EmailAuthenticationMode.UserNameAndPassword,
UserName = user,
Password = password,
UseSSL = true
};
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 roSettings = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName);
Assert.AreEqual(1, roSettings.TraceListeners.Count);
var loadedData = (EmailTraceListenerData)roSettings.TraceListeners.Get(name);
Assert.IsNotNull(loadedData);
Assert.AreEqual(TraceOptions.Callstack, loadedData.TraceOutputOptions);
Assert.AreEqual(SourceLevels.Critical, loadedData.Filter);
Assert.AreSame(typeof(EmailTraceListenerData), loadedData.GetType());
Assert.AreSame(typeof(EmailTraceListenerData), loadedData.ListenerDataType);
Assert.AreSame(typeof(EmailTraceListener), loadedData.Type);
Assert.AreEqual(formatter, loadedData.Formatter);
Assert.AreEqual(fromAddress, loadedData.FromAddress);
Assert.AreEqual(port, loadedData.SmtpPort);
Assert.AreEqual(server, loadedData.SmtpServer);
Assert.AreEqual(subjectEnder, loadedData.SubjectLineEnder);
Assert.AreEqual(subjectStarter, loadedData.SubjectLineStarter);
Assert.AreEqual(toAddress, loadedData.ToAddress);
Assert.AreEqual(EmailAuthenticationMode.UserNameAndPassword, loadedData.AuthenticationMode);
Assert.AreEqual(user, loadedData.UserName);
Assert.AreEqual(password, loadedData.Password);
Assert.IsTrue(loadedData.UseSSL);
Assert.AreEqual(false, loadedData.Asynchronous);
Assert.AreEqual(30000, loadedData.AsynchronousBufferSize);
Assert.AreEqual(System.Threading.Timeout.InfiniteTimeSpan, loadedData.AsynchronousDisposeTimeout);
Assert.AreEqual(null, loadedData.AsynchronousMaxDegreeOfParallelism);
}
public void UseSSLDefaultsToFalseWhenUnspecified()
{
EmailTraceListenerData listenerData = CreateDefaultData();
Assert.IsFalse(listenerData.UseSSL);
}
