public void WillReturnTrueIfQueueCreated()
{
TestMessageQueue.Delete();
using (var queue = TestMessageQueue.Create())
Assert.True(queue.EnsureQueueExists());
}
public void WillReturnTrueIfQueueAlreadyExists()
{
TestMessageQueue.Delete();
MessageQueue.InitializeMessageQueue(TestMessageQueue.Path + ";subqueue");
Assert.True(MessageQueue.InitializeMessageQueue(TestMessageQueue.Path));
}
public WhenReceivingMessages()
{
messageProcessor = new FakeMessageProcessor <String>();
testQueue = TestMessageQueue.Create();
testQueue.EnsureQueueExists();
testQueue.Purge();
}
public WhenSendingMessages()
{
serializer = new BinarySerializer();
messageSender = new MessageSender <String>(TestMessageQueue.Path, serializer);
testQueue = TestMessageQueue.Create();
testQueue.EnsureQueueExists();
testQueue.Purge();
}
public void WillReturnTrueIfQueueAlreadyExists()
{
using (var queue = TestMessageQueue.Create())
{
queue.EnsureQueueExists();
Assert.True(queue.EnsureQueueExists());
}
}
public WhenInitializingMessageReceiver()
{
messageProcessor = new FakeMessageProcessor <String>();
processingQueue = TestMessageQueue.Create("processing");
testQueue = TestMessageQueue.Create();
testQueue.EnsureQueueExists();
testQueue.Purge();
}
public void WillMoveMessageToPoisonQueueIfUnableToProcessMessage()
{
var message = testQueue.SendMessage("Test Message");
using (new MessageReceiver <String>(TestMessageQueue.Path, new BinarySerializer(), messageProcessor))
{
messageProcessor.WaitForMessage();
messageProcessor.ThrowException(new InvalidOperationException());
}
using (var poisonQueue = TestMessageQueue.Create("poison"))
Assert.NotNull(poisonQueue.PeekById(message.Id));
}
public void WillMoveMessagesToIntermediateProcessingQueue()
{
var message = testQueue.SendMessage("Test Message");
using (new MessageReceiver <String>(TestMessageQueue.Path, new BinarySerializer(), messageProcessor))
using (var processingQueue = TestMessageQueue.Create("processing"))
{
messageProcessor.WaitForMessage();
Assert.NotNull(processingQueue.PeekById(message.Id));
messageProcessor.ProcessNextMessage();
}
}
public async Task <IMessage> Add(string endpointId, IMessage message, uint _)
{
TestMessageQueue queue = this.GetQueue(endpointId);
long offset = await queue.Add(message);
return(new Message(
message.MessageSource,
message.Body,
message.Properties,
message.SystemProperties,
offset,
message.EnqueuedTime,
message.DequeuedTime));
}
public void WillMoveMessagesFromMainQueueToSubQueue()
{
using (var mainQueue = TestMessageQueue.Create())
using (var subQueue = TestMessageQueue.Create("subqueue"))
{
var message = new System.Messaging.Message("Message")
{
Recoverable = true
};
mainQueue.Send(message);
mainQueue.Move(mainQueue.PeekById(message.Id), subQueue);
Assert.NotNull(subQueue.ReceiveById(message.Id));
}
}
public void WillMoveMessagesBetweenSubQueues()
{
using (var mainQueue = TestMessageQueue.Create())
using (var subQueue1 = TestMessageQueue.Create("subqueue1"))
using (var subQueue2 = TestMessageQueue.Create("subqueue2"))
{
var message = new System.Messaging.Message("Message")
{
Recoverable = true
};
mainQueue.Send(message);
mainQueue.Move(mainQueue.PeekById(message.Id), subQueue1);
subQueue1.Move(subQueue1.PeekById(message.Id), subQueue2);
Assert.NotNull(subQueue2.ReceiveById(message.Id));
}
}
public void WillMoveMessageToPoisonQueueIfUnableToDeserializeMessage()
{
var message = new System.Messaging.Message("Invalid Message")
{
Recoverable = true
};
testQueue.Send(message);
using (new MessageReceiver <String>(TestMessageQueue.Path, new BinarySerializer(), messageProcessor))
{
testQueue.SendMessage("Valid Message");
messageProcessor.ProcessMessages(count: 1);
}
using (var poisonQueue = TestMessageQueue.Create("poison"))
Assert.NotNull(poisonQueue.PeekById(message.Id));
}
public void Dispose()
{
TestMessageQueue.Delete();
}
public Task <long> Add(string endpointId, IMessage message)
{
TestMessageQueue queue = this.GetQueue(endpointId);
return(queue.Add(message));
}
public void Dispose()
{
TestMessageQueue.Purge();
}
public void WillReturnTrueIfQueueCreated()
{
TestMessageQueue.Delete();
Assert.True(MessageQueue.InitializeMessageQueue(TestMessageQueue.Path));
}
public WhenMovingMessages()
{
testQueue = TestMessageQueue.Create();
testQueue.EnsureQueueExists();
testQueue.Purge();
}
public WhenDisposing()
{
TestMessageQueue.Create();
}
