public void EnsureIntrinsicPropertiesInitializedAreNotPickedUpDuringDeserialization()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
LogSource source = new LogSource("unnamed", new List <TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
Trace.CorrelationManager.ActivityId = Guid.NewGuid();
LogEntry entry = CommonUtil.GetDefaultLogEntry();
source.TraceData(TraceEventType.Error, 1, entry);
// Resetting context before deserialization to ensure that
// the intrinsic properties picked ud during deserealization
Trace.CorrelationManager.ActivityId = Guid.Empty;
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
// Ensure that the deserialized intrinsic properties remain the same
// as the Log Entry
Assert.AreEqual(deserializedEntry.ActivityId, entry.ActivityId);
}
public void CanCreatePoliciesForMsmqTraceListenerWithFormatter()
{
MsmqTraceListenerData listenerData
= new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, "binary");
listenerData.TraceOutputOptions = TraceOptions.Callstack | TraceOptions.ProcessId;
listenerData.Filter = SourceLevels.Error;
loggingSettings.TraceListeners.Add(listenerData);
loggingSettings.Formatters.Add(new BinaryLogFormatterData("binary"));
using (var container = CreateContainer())
{
MsmqTraceListener createdObject =
(MsmqTraceListener)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.IsInstanceOfType(createdObject.Formatter, typeof(BinaryLogFormatter));
Assert.AreEqual(CommonUtil.MessageQueuePath, createdObject.QueuePath);
}
// there's currently no way to test for other properties
}
public void CanSendMessageToQueue()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
LogSource source = new LogSource("unnamed", new List <TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
LogEntry entry = CommonUtil.GetDefaultLogEntry();
source.TraceData(TraceEventType.Error, 1, entry);
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
Assert.AreEqual(MessageQueueTransactionType.None, MockMsmqInterface.Instance.transactionType);
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
}
/// <summary>
/// Initializes an MSMQ Logging Target
/// </summary>
/// <param name="logName">Enterprise library log name</param>
/// <param name="queuePath">MSMQ path e.g., ".\\Private$\\NOC" (backslashes need to be escaped) </param>
/// <param name="backupLog">Instance of the backup log used in case instantion fails.</param>
/// <param name="priorities">One or more priorities that this target will log</param>
public MSMQLog(string logName, string queuePath, ILoggingTarget backupLog,
params enumEventPriority [] priorities)
{
_priorities = priorities;
_backupLog = backupLog;
try
{
_msmqLogger = new MsmqTraceListener(logName, queuePath, new TextFormatter(),
MessagePriority.Normal, true, TimeSpan.FromDays(1), TimeSpan.FromDays(1), false, true, false,
MessageQueueTransactionType.None);
}
catch (Exception ex)
{
string errMsg = string.Format("Could not create MSMQ Logger with queuePath: {0} errorMsg: {1} \r\n"
, ex
, queuePath);
_backupLog.Write(errMsg
, true
, 0
, 0
, EventLogEntryType.Error
, enumEventPriority.Critical);
throw new ExceptionEvent(enumExceptionEventCodes.EventLogSourceCreateFailed, errMsg, ex);
}
}
public void WritingMessageSendsSameMessageToMsmq()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
listener.Write("message");
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(typeof(string), message.Body.GetType());
Assert.AreEqual("message", message.Body);
}
public void IllFormattedMessageWritesInEventLog()
{
MsmqReceiverTestWrapper testSync = new MsmqReceiverTestWrapper(logWriter, CommonUtil.MessageQueuePath, eventLogger);
MsmqTraceListener mqTracelistener = new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, new BinaryLogFormatter(),
MessagePriority.Normal, false, new TimeSpan(0, 1, 0), new TimeSpan(0, 1, 0),
false, true, false, MessageQueueTransactionType.None);
mqTracelistener.Write("this is a plain trace message");
try
{
testSync.CheckForMessages();
}
catch (LoggingException) { }
string eventlogEntry = CommonUtil.GetLastEventLogEntry();
Assert.IsTrue(-1 != eventlogEntry.IndexOf("Unable to deserialize message"));
}
public void CanCreateInstanceFromConfigurationFile()
{
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.Formatters.Add(new FormatterData(formatterName, typeof(BinaryLogFormatter)));
loggingSettings.TraceListeners.Add(new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, formatterName));
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings), reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(MsmqTraceListener));
MsmqTraceListener msmqTraceListener = listener as MsmqTraceListener;
Assert.IsNotNull(msmqTraceListener.Formatter);
Assert.AreEqual(msmqTraceListener.Formatter.GetType(), typeof(BinaryLogFormatter));
Assert.AreEqual(CommonUtil.MessageQueuePath, msmqTraceListener.QueuePath);
}
public void CanBuildCorrectMessageWithBinaryLogFormatter()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MessageQueueTransactionType.None);
LogEntry entry = CommonUtil.GetDefaultLogEntry();
Message message = listener.CreateMessage(entry);
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
Assert.AreEqual(entry.Message, deserializedEntry.Message);
}
public void MsmqTraceListenerTest()
{
var path = @"FormatName:DIRECT=OS:.\private$\test2";
path = @".\private$\test2";
var listener = new MsmqTraceListener(path);
listener = xSolon.TraceListeners.Extensions.Wrap <MsmqTraceListener>(listener);
var source = new TraceSource("MSMQTEST1", SourceLevels.All);
source.Listeners.Add(listener);
source.Listeners.Add(new ConsoleTraceListener());
source.TraceInformation("test1");
source.TraceEvent(TraceEventType.Information, 1, "Test 2 {0}", 123);
}
public void MessageIsDeserializedWhenUsingJsonFormatterWithMsmqTraceListener()
{
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", MsmqUtil.MessageQueuePath, new JsonLogFormatter(), MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MessageQueueTransactionType.None);
LogEntry entry = MsmqUtil.GetDefaultLogEntry();
Message message = listener.CreateMessage(entry);
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
LogEntry deserializedEntry = JsonLogFormatter.Deserialize <LogEntry>(message.Body as string);
Assert.IsNotNull(deserializedEntry);
Assert.AreEqual(entry.Message, deserializedEntry.Message);
}
public void CanCreateInstanceFromConfigurationFile()
{
LoggingSettings loggingSettings = new LoggingSettings();
loggingSettings.Formatters.Add(new FormatterData(formatterName, typeof(BinaryLogFormatter)));
loggingSettings.TraceListeners.Add(new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, formatterName));
TraceListener listener =
GetListener("listener\u200cimplementation", CommonUtil.SaveSectionsAndGetConfigurationSource(loggingSettings));
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(MsmqTraceListener));
MsmqTraceListener msmqTraceListener = listener as MsmqTraceListener;
Assert.IsNotNull(msmqTraceListener.Formatter);
Assert.AreEqual(msmqTraceListener.Formatter.GetType(), typeof(BinaryLogFormatter));
Assert.AreEqual(CommonUtil.MessageQueuePath, msmqTraceListener.QueuePath);
}
public void CanBuildCorrectMessageWithBinaryLogFormatter()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MessageQueueTransactionType.None);
LogEntry entry = CommonUtil.GetDefaultLogEntry();
Message message = listener.CreateMessage(entry);
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
Assert.AreEqual(entry.Message, deserializedEntry.Message);
}
public void LogToMsmqUsingDirectObjectOnlyResultsInOneMessage()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
TraceSource source = new TraceSource("unnamed", SourceLevels.All);
source.Listeners.Add(listener);
int numMessages = MockMsmqInterface.Instance.MessageCount;
source.TraceData(TraceEventType.Error, 1, new TestCustomObject());
source.Close();
int newNumMessages = MockMsmqInterface.Instance.MessageCount;
Assert.AreEqual(numMessages, newNumMessages - 1);
}
public void CanCreateInstanceFromGivenConfiguration()
{
TraceListenerData listenerData = new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, formatterName);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.Formatters.Add(new BinaryLogFormatterData(formatterName));
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, listenerData, helper.configurationSource, reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(MsmqTraceListener));
MsmqTraceListener msmqTraceListener = listener as MsmqTraceListener;
Assert.AreEqual("listener", listener.Name);
Assert.IsNotNull(msmqTraceListener.Formatter);
Assert.AreEqual(msmqTraceListener.Formatter.GetType(), typeof(BinaryLogFormatter));
Assert.AreEqual(CommonUtil.MessageQueuePath, msmqTraceListener.QueuePath);
}
public void CanCreateInstanceFromGivenName()
{
TraceListenerData listenerData = new MsmqTraceListenerData("listener", CommonUtil.MessageQueuePath, formatterName);
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.TraceListeners.Add(listenerData);
helper.loggingSettings.Formatters.Add(new BinaryLogFormatterData(formatterName));
TraceListener listener = GetListener("listener\u200cimplementation", helper.configurationSource);
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(MsmqTraceListener));
MsmqTraceListener msmqTraceListener = listener as MsmqTraceListener;
Assert.AreEqual("listener\u200cimplementation", listener.Name);
Assert.IsNotNull(msmqTraceListener.Formatter);
Assert.AreEqual(msmqTraceListener.Formatter.GetType(), typeof(BinaryLogFormatter));
Assert.AreEqual(CommonUtil.MessageQueuePath, msmqTraceListener.QueuePath);
}
public void SetUp()
{
CommonUtil.ValidateMsmqIsRunning();
CommonUtil.DeletePrivateTestQ();
CreateQueueForTesting();
clientListener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, new BinaryLogFormatter(),
MessagePriority.Normal, false, new TimeSpan(0, 1, 0), new TimeSpan(0, 1, 0),
false, true, false, MessageQueueTransactionType.Single);
clientSource = new LogSource("unnamed", new[] { clientListener }, SourceLevels.All);
LogSource distributorSource = new LogSource("unnamed", new[] { new MockTraceListener() }, SourceLevels.All);
Dictionary <string, LogSource> traceSources = new Dictionary <string, LogSource>();
Logger.SetLogWriter(new LogWriter(new List <ILogFilter>(), traceSources, distributorSource, null, new LogSource("errors"), "default", false, false), false);
eventLogger = new DistributorEventLogger(TestEventSource);
msmqDistributor = new MsmqLogDistributor(CommonUtil.MessageQueuePath, eventLogger);
msmqDistributor.StopReceiving = false;
}
public void CanSendMessageToQueue()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
LogSource source = new LogSource("unnamed", new List<TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
LogEntry entry = CommonUtil.GetDefaultLogEntry();
source.TraceData(TraceEventType.Error, 1, entry);
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
Assert.AreEqual(MessageQueueTransactionType.None, MockMsmqInterface.Instance.transactionType);
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
}
public void EntryIsWrittenWhenMSMQGeneralCategory()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
var msmqListener = new MsmqTraceListener("TestMSMQProg", MsmqUtil.MessageQueuePath, new BinaryLogFormatter(),
MessagePriority.Normal, false, new TimeSpan(0, 1, 0), new TimeSpan(0, 1, 0),
false, true, false, MessageQueueTransactionType.None);
msmqListener.Filter = new EventTypeFilter(SourceLevels.All);
MsmqUtil.ValidateMsmqIsRunning();
MsmqUtil.DeletePrivateTestQ();
MsmqUtil.CreatePrivateTestQ();
LogSource clientSource = new LogSource("TestMSMQProg", new[] { msmqListener }, SourceLevels.All);
LogSource distributorSource = new LogSource("TestMSMQProg", new[] { new MockTraceListener() }, SourceLevels.All);
Dictionary <string, LogSource> traceSources = new Dictionary <string, LogSource>();
this.writer = new LogWriter(new List <ILogFilter>(), traceSources, distributorSource, null, new LogSource("errors"), "General", false, false);
Logger.SetLogWriter(this.writer);
DistributorEventLogger eventLogger = new DistributorEventLogger();
MsmqLogDistributor msmqDistributor = new MsmqLogDistributor(MsmqUtil.MessageQueuePath, eventLogger);
msmqDistributor.StopReceiving = false;
LogEntry logEntry = MsmqUtil.GetDefaultLogEntry();
logEntry.Categories = new string[] { "MockCategoryOne" };
logEntry.Message = MsmqUtil.MsgBody;
logEntry.Severity = TraceEventType.Information;
clientSource.TraceData(logEntry.Severity, 1, logEntry);
msmqDistributor.CheckForMessages();
Assert.AreEqual(1, MockTraceListener.Entries.Count);
Assert.AreEqual(MsmqUtil.MsgBody, MockTraceListener.LastEntry.Message, "Body");
}
public void ShouldNotSendMessageToQueue()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
// Filter only Critical
listener.Filter = new EventTypeFilter(SourceLevels.Critical);
LogSource source = new LogSource("unnamed", new List <TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
MockMsmqInterface.Instance.ResetMessageCount();
LogEntry entry = CommonUtil.GetDefaultLogEntry();
// Trace an Information LogEntry
source.TraceData(TraceEventType.Information, 1, entry);
Assert.AreEqual(0, MockMsmqInterface.Instance.MessageCount);
}
public void ShouldNotSendMessageToQueue()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
// Filter only Critical
listener.Filter = new EventTypeFilter(SourceLevels.Critical);
LogSource source = new LogSource("unnamed", new List<TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
MockMsmqInterface.Instance.ResetMessageCount();
LogEntry entry = CommonUtil.GetDefaultLogEntry();
// Trace an Information LogEntry
source.TraceData(TraceEventType.Information, 1, entry);
Assert.AreEqual(0, MockMsmqInterface.Instance.MessageCount);
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds a <see cref="MsmqTraceListener"/> based on an instance of <see cref="MsmqTraceListenerData"/>.
/// </summary>
/// <seealso cref="TraceListenerCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="MsmqTraceListenerData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="MsmqTraceListener"/>.</returns>
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
MsmqTraceListenerData castedObjectConfiguration
= (MsmqTraceListenerData)objectConfiguration;
ILogFormatter formatter = GetFormatter(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new MsmqTraceListener(
castedObjectConfiguration.Name,
castedObjectConfiguration.QueuePath,
formatter,
castedObjectConfiguration.MessagePriority,
castedObjectConfiguration.Recoverable,
castedObjectConfiguration.TimeToReachQueue,
castedObjectConfiguration.TimeToBeReceived,
castedObjectConfiguration.UseAuthentication,
castedObjectConfiguration.UseDeadLetterQueue,
castedObjectConfiguration.UseEncryption,
castedObjectConfiguration.TransactionType);
return(createdObject);
}
public void EnsureIntrinsicPropertiesInitializedAreNotPickedUpDuringDeserialization()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
LogSource source = new LogSource("unnamed", new List<TraceListener>(new TraceListener[] { listener }), SourceLevels.All);
MockMsmqInterface.Instance.transactional = false;
Trace.CorrelationManager.ActivityId = Guid.NewGuid();
LogEntry entry = CommonUtil.GetDefaultLogEntry();
source.TraceData(TraceEventType.Error, 1, entry);
// Resetting context before deserialization to ensure that
// the intrinsic properties picked ud during deserealization
Trace.CorrelationManager.ActivityId = Guid.Empty;
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(message.Body.GetType(), typeof(string));
LogEntry deserializedEntry = BinaryLogFormatter.Deserialize(message.Body as string);
Assert.IsNotNull(deserializedEntry);
// Ensure that the deserialized intrinsic properties remain the same
// as the Log Entry
Assert.AreEqual(deserializedEntry.ActivityId, entry.ActivityId);
}
public void LogToMsmqUsingDirectObjectOnlyResultsInOneMessage()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
TraceSource source = new TraceSource("unnamed", SourceLevels.All);
source.Listeners.Add(listener);
int numMessages = MockMsmqInterface.Instance.MessageCount;
source.TraceData(TraceEventType.Error, 1, new TestCustomObject());
source.Close();
int newNumMessages = MockMsmqInterface.Instance.MessageCount;
Assert.AreEqual(numMessages, newNumMessages - 1);
}
public void WritingMessageSendsSameMessageToMsmq()
{
ILogFormatter formatter = new BinaryLogFormatter();
MsmqTraceListener listener =
new MsmqTraceListener("unnamed", CommonUtil.MessageQueuePath, formatter, MessagePriority.Low, true,
MsmqTraceListenerData.DefaultTimeToBeReceived, MsmqTraceListenerData.DefaultTimeToReachQueue,
false, false, false, MsmqTraceListenerData.DefaultTransactionType, new MockMsmqInterfaceFactory());
listener.Write("message");
Message message = MockMsmqInterface.Instance.message;
Assert.IsNotNull(message);
Assert.IsNotNull(message.Body);
Assert.AreEqual(typeof(string), message.Body.GetType());
Assert.AreEqual("message", message.Body);
}