public void Publish_Success_With_Ack()
{
var _waitHandle = new AutoResetEvent(false);
var _messageProperties = Substitute.For <IBasicProperties>();
this.c_channel.CreateBasicProperties().Returns(_messageProperties);
this.c_channel.NextPublishSeqNo.Returns(1UL);
this.c_channel
.When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>()))
.Do(callInfo => _waitHandle.Set());
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
_SUT.Start(); // Can't capture result due to compiler treating warnings as errors - var is not used
var _publication = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, this.c_taskCompletionSource);
this.c_publicationQueue.Add(_publication);
_waitHandle.WaitOne(); // Allow publication to complete
this.c_channel.BasicAcks += Raise.EventWith(this.c_channel, new BasicAckEventArgs {
Multiple = false, DeliveryTag = 1
});
Assert.IsTrue(_publication.ResultTask.IsCompleted);
_messageProperties.Received().ContentType = "application/json";
_messageProperties.Received().DeliveryMode = (byte)this.c_messageDelivery.DeliveryMode;
_messageProperties.Received().Type = this.c_messageDelivery.TypeHeader;
_messageProperties.Received().MessageId = this.c_myEvent.Id.ToString();
_messageProperties.Received().CorrelationId = this.c_myEvent.CorrelationId;
this.c_channel.Received().BasicPublish(this.c_messageDelivery.ExchangeName, this.c_messageDelivery.RoutingKeyFunc(this.c_myEvent), _messageProperties, Arg.Any <byte[]>());
}
public void Publish_Success_Channel_Shutdown_Before_Acked()
{
var _waitHandle = new CountdownEvent(2);
this.c_channel.NextPublishSeqNo.Returns(1Ul, 2UL);
this.c_channel
.When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>()))
.Do(callInfo => _waitHandle.Signal());
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
_SUT.Start();
var _taskCompletionSource1 = new TaskCompletionSource <PublicationResult>();
var _publication1 = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, _taskCompletionSource1);
var _taskCompletionSource2 = new TaskCompletionSource <PublicationResult>();
var _publication2 = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, _taskCompletionSource2);
this.c_publicationQueue.Add(_publication1);
this.c_publicationQueue.Add(_publication2);
_waitHandle.Wait(); // Allow channel publications to complete
this.c_channel.ModelShutdown += Raise.EventWith(this.c_channel, new ShutdownEventArgs(ShutdownInitiator.Peer, 1, "Bang!"));
// Since all running on the same thread we do not need to wait - this is also not realistic as we know the channel shutdown event will happen on a different thread
Assert.IsTrue(_publication1.ResultTask.IsCompleted);
Assert.AreEqual(PublicationResultStatus.ChannelShutdown, _publication1.ResultTask.Result.Status);
Assert.IsTrue(_publication1.ResultTask.Result.StatusContext.Contains("Bang!"));
Assert.IsTrue(_publication2.ResultTask.IsCompleted);
Assert.AreEqual(PublicationResultStatus.ChannelShutdown, _publication2.ResultTask.Result.Status);
Assert.IsTrue(_publication2.ResultTask.Result.StatusContext.Contains("Bang!"));
}
public void InstantiateAndStartPublisher()
{
this.c_connection = new ConnectionFactory {
Uri = Configuration.LocalConnectionUri
}.CreateConnection();
this.c_publicationQueue = new BlockingCollection <PMCG.Messaging.Client.Publication>();
this.c_cancellationTokenSource = new CancellationTokenSource();
this.c_publisher = new PMCG.Messaging.Client.Publisher(
this.c_connection,
this.c_publicationQueue,
this.c_cancellationTokenSource.Token);
this.c_publisher.Start();
}
public void Publish_Failure_Channel_Is_Closed_Task_Continues()
{
this.c_channel.IsOpen.Returns(false);
var _publication = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, this.c_taskCompletionSource);
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
var _publisherTask = _SUT.Start();
this.c_publicationQueue.Add(_publication);
// We wait 5 seconds to show that the task is still running and working - adding meesage back on to collection and trying to publish again in a continuous loop
// Assert that the task has not completed as it is long lived.
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.IsFalse(_publication.ResultTask.IsCompleted);
}
public void Publish_Failure_Unhandled_Exception_Task_Terminates()
{
this.c_channel.CreateBasicProperties().Returns(callInfo => { throw new Exception("Channel not open !"); });
var _publication = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, this.c_taskCompletionSource);
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
var _publisherTask = _SUT.Start();
this.c_publicationQueue.Add(_publication);
bool _isFaultedPublisherTask = false;
try { _publisherTask.Wait(); } catch { _isFaultedPublisherTask = true; }
Assert.IsTrue(_isFaultedPublisherTask);
}
public void Publish_Failure_Handled_Exception_Task_Continues()
{
this.c_channel
.When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>()))
.Do(callInfo => { throw new ApplicationException("Bang !"); });
var _publication = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, this.c_taskCompletionSource);
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
var _publisherTask = _SUT.Start();
this.c_publicationQueue.Add(_publication);
// We wait 5 seconds to show that the task is still running and working - adding meesage back on to collection and trying to publish again in a continuous loop
// Assert that the task has not completed as it is long lived.
Task.Delay(5000).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.IsFalse(_publication.ResultTask.IsCompleted);
}
public void Publish_Success_Multiple_Publications_Only_Some_Acked()
{
var _waitHandle = new CountdownEvent(100);
var _nextPublishSeqNo = 1UL;
this.c_channel.NextPublishSeqNo.Returns(callInfo => _nextPublishSeqNo++); // Would not work when I used .Returns(1Ul, 2UL, 3UL); Not sure why this works !
this.c_channel
.When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>()))
.Do(callInfo => _waitHandle.Signal());
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
_SUT.Start();
var _publications = new List <Publication>();
for (var _index = 1; _index <= 100; _index++)
{
var _myEvent = new MyEvent(Guid.NewGuid(), "CorrlationId_1", "Detail", _index);
var _taskCompletionSource = new TaskCompletionSource <PublicationResult>();
var _publication = new Publication(this.c_logger, this.c_messageDelivery, _myEvent, _taskCompletionSource);
this.c_publicationQueue.Add(_publication);
_publications.Add(_publication);
}
_waitHandle.Wait(); // Allow channel publications to complete
foreach (var _publication in _publications)
{
Assert.IsFalse(_publication.ResultTask.IsCompleted);
}
var _deliveryTagToAcknowledge = 73;
this.c_channel.BasicAcks += Raise.EventWith(this.c_channel, new BasicAckEventArgs {
Multiple = true, DeliveryTag = (ulong)_deliveryTagToAcknowledge
});
Assert.AreEqual(_deliveryTagToAcknowledge, _publications.Count(publication => publication.ResultTask.IsCompleted), "A1");
Assert.AreEqual(_deliveryTagToAcknowledge, _publications.Count(publication => publication.ResultTask.IsCompleted && publication.ResultTask.Result.Status == PublicationResultStatus.Acked), "A2");
Assert.AreEqual(100 - _deliveryTagToAcknowledge, _publications.Count(publication => !publication.ResultTask.IsCompleted), "A3");
}
public void Publish_Success_Nacked()
{
var _waitHandle = new AutoResetEvent(false);
this.c_channel.NextPublishSeqNo.Returns(1Ul);
this.c_channel
.When(channel => channel.BasicPublish(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IBasicProperties>(), Arg.Any <byte[]>()))
.Do(callInfo => _waitHandle.Set());
var _SUT = new PMCG.Messaging.Client.Publisher(this.c_connection, this.c_publicationQueue);
_SUT.Start();
var _publication = new Publication(this.c_logger, this.c_messageDelivery, this.c_myEvent, this.c_taskCompletionSource);
this.c_publicationQueue.Add(_publication);
_waitHandle.WaitOne(); // Allow channel publication to complete
this.c_channel.BasicNacks += Raise.EventWith(this.c_channel, new BasicNackEventArgs {
Multiple = true, DeliveryTag = 1UL
});
Assert.IsTrue(_publication.ResultTask.IsCompleted);
Assert.AreEqual(PublicationResultStatus.Nacked, _publication.ResultTask.Result.Status);
Assert.IsNull(_publication.ResultTask.Result.StatusContext);
}
public void InstantiateAndStartPublisher()
{
this.c_connection = new ConnectionFactory { Uri = Configuration.LocalConnectionUri }.CreateConnection();
this.c_publicationQueue = new BlockingCollection<PMCG.Messaging.Client.Publication>();
this.c_cancellationTokenSource = new CancellationTokenSource();
this.c_publisher = new PMCG.Messaging.Client.Publisher(
this.c_connection,
this.c_publicationQueue,
this.c_cancellationTokenSource.Token);
this.c_publisher.Start();
}
