public void When_Acknowledge_Is_Called_On_A_Channel()
{
_channel.Acknowledge(_receivedMessage);
//_should_ackonwledge_the_message
A.CallTo(() => _gateway.Acknowledge(_receivedMessage)).MustHaveHappened();
}
public void When_reading_a_message_from_a_channel_with_multiple_topics()
{
_messageProducer.Send(_messageTopic1);
_messageProducer.Send(_messageTopic2);
var topic1Result = _messageConsumer.Receive(10000).First();
_messageConsumer.Acknowledge(topic1Result);
var topic2Result = _messageConsumer.Receive(10000).First();
_messageConsumer.Acknowledge(topic2Result);
// should_received_a_message_from_test1_with_same_topic_and_body
topic1Result.Header.Topic.Should().Be(_messageTopic1.Header.Topic);
topic1Result.Body.Value.Should().BeEquivalentTo(_messageTopic1.Body.Value);
// should_received_a_message_from_test2_with_same_topic_and_body
topic2Result.Header.Topic.Should().Be(_messageTopic2.Header.Topic);
topic2Result.Body.Value.Should().BeEquivalentTo(_messageTopic2.Body.Value);
}
public void When_a_message_is_sent_keep_order()
{
IAmAMessageConsumer consumer = null;
try
{
//Send a sequence of messages to Kafka
var msgId = SendMessage();
var msgId2 = SendMessage();
var msgId3 = SendMessage();
var msgId4 = SendMessage();
consumer = CreateConsumer();
//Now read those messages in order
var firstMessage = ConsumeMessages(consumer);
var message = firstMessage.First();
message.Id.Should().Be(msgId);
consumer.Acknowledge(message);
var secondMessage = ConsumeMessages(consumer);
message = secondMessage.First();
message.Id.Should().Be(msgId2);
consumer.Acknowledge(message);
var thirdMessages = ConsumeMessages(consumer);
message = thirdMessages.First();
message.Id.Should().Be(msgId3);
consumer.Acknowledge(message);
var fourthMessage = ConsumeMessages(consumer);
message = fourthMessage.First();
message.Id.Should().Be(msgId4);
consumer.Acknowledge(message);
}
finally
{
consumer?.Dispose();
}
}
public void When_posting_a_message_via_the_messaging_gateway()
{
_messageConsumer.Receive(30000); //Need to receive to subscribe to feed, before we send a message. This returns an empty message we discard
_messageProducer.Send(_message);
_sentMessage = _messageConsumer.Receive(30000).Single();
_messageBody = _sentMessage.Body.Value;
_messageConsumer.Acknowledge(_sentMessage);
//_should_send_a_message_via_restms_with_the_matching_body
_messageBody.Should().Be(_message.Body.Value);
//_should_have_an_empty_pipe_after_acknowledging_the_message
((RestMsMessageConsumer)_messageConsumer).NoOfOutstandingMessages(30000).Should().Be(0);
}
public void When_reading_a_delayed_message_via_the_messaging_gateway()
{
_messageProducer.SendWithDelay(_message, 3000);
var immediateResult = _messageConsumer.Receive(0).First();
var deliveredWithoutWait = immediateResult.Header.MessageType == MessageType.MT_NONE;
immediateResult.Header.HandledCount.Should().Be(0);
immediateResult.Header.DelayedMilliseconds.Should().Be(0);
//_should_have_not_been_able_get_message_before_delay
deliveredWithoutWait.Should().BeTrue();
var delayedResult = _messageConsumer.Receive(10000).First();
//_should_send_a_message_via_rmq_with_the_matching_body
delayedResult.Body.Value.Should().Be(_message.Body.Value);
delayedResult.Header.MessageType.Should().Be(MessageType.MT_COMMAND);
delayedResult.Header.HandledCount.Should().Be(0);
delayedResult.Header.DelayedMilliseconds.Should().Be(3000);
_messageConsumer.Acknowledge(delayedResult);
}
public void When_infrastructure_exists_can_verify()
{
//arrange
_messageProducer.Send(_message);
Task.Delay(1000).Wait();
var messages = _consumer.Receive(5000);
//Assert
var message = messages.First();
message.Id.Should().Be(_myCommand.Id);
//clear the queue
_consumer.Acknowledge(message);
}
private Message[] ConsumeMessages(string groupId, int batchLimit)
{
var consumedMessages = new List <Message>();
using (IAmAMessageConsumer consumer = CreateConsumer(groupId))
{
for (int i = 0; i < batchLimit; i++)
{
consumedMessages.Add(ConsumeMessage(consumer));
}
}
return(consumedMessages.ToArray());
Message ConsumeMessage(IAmAMessageConsumer consumer)
{
Message[] messages = new [] { new Message() };
int maxTries = 0;
do
{
try
{
maxTries++;
Task.Delay(500).Wait(); //Let topic propogate in the broker
messages = consumer.Receive(1000);
if (messages[0].Header.MessageType != MessageType.MT_NONE)
{
consumer.Acknowledge(messages[0]);
return(messages[0]);
}
}
catch (ChannelFailureException cfx)
{
//Lots of reasons to be here as Kafka propogates a topic, or the test cluster is still initializing
_output.WriteLine($" Failed to read from topic:{_topic} because {cfx.Message} attempt: {maxTries}");
}
} while (maxTries <= 3);
return(messages[0]);
}
}
public void When_rejecting_a_message_due_to_queue_length()
{
_messageProducer.Send(_messageOne);
_messageProducer.Send(_messageTwo);
//check messages are flowing - absence needs to be expiry
var messages = _messageConsumer.Receive(5000);
var message = messages.First();
_messageConsumer.Acknowledge(message);
//should be the first message
//try to grab the next message
var nextMessages = _messageConsumer.Receive(5000);
message = nextMessages.First();
message.Header.MessageType.Should().Be(MessageType.MT_NONE);
}
public void When_a_consumer_declares_topics_on_a_confluent_cluster()
{
var message = new Message(
new MessageHeader(Guid.NewGuid(), _topic, MessageType.MT_COMMAND)
{
PartitionKey = _partitionKey
},
new MessageBody($"test content [{_queueName}]"));
//This should fail, if consumer can't create the topic as set to Assume
_producer.Send(message);
Message[] messages = new Message[0];
int maxTries = 0;
do
{
try
{
maxTries++;
Task.Delay(500).Wait(); //Let topic propogate in the broker
messages = _consumer.Receive(10000);
_consumer.Acknowledge(messages[0]);
if (messages[0].Header.MessageType != MessageType.MT_NONE)
{
break;
}
}
catch (ChannelFailureException cfx)
{
//Lots of reasons to be here as Kafka propogates a topic, or the test cluster is still initializing
_output.WriteLine($" Failed to read from topic:{_topic} because {cfx.Message} attempt: {maxTries}");
}
} while (maxTries <= 3);
messages.Length.Should().Be(1);
messages[0].Header.MessageType.Should().Be(MessageType.MT_COMMAND);
messages[0].Header.PartitionKey.Should().Be(_partitionKey);
messages[0].Body.Value.Should().Be(message.Body.Value);
}
public void When_a_message_consumer_reads_multiple_messages()
{
//Post one more than batch size messages
var messageOne = new Message(new MessageHeader(Guid.NewGuid(), _topic, MessageType.MT_COMMAND), new MessageBody("test content One"));
_messageProducer.Send(messageOne);
var messageTwo = new Message(new MessageHeader(Guid.NewGuid(), _topic, MessageType.MT_COMMAND), new MessageBody("test content Two"));
_messageProducer.Send(messageTwo);
var messageThree = new Message(new MessageHeader(Guid.NewGuid(), _topic, MessageType.MT_COMMAND), new MessageBody("test content Three"));
_messageProducer.Send(messageThree);
var messageFour = new Message(new MessageHeader(Guid.NewGuid(), _topic, MessageType.MT_COMMAND), new MessageBody("test content Four"));
_messageProducer.Send(messageFour);
//let them arrive
Task.Delay(5000);
//Now retrieve messages from the consumer
var messages = _messageConsumer.Receive(1000);
//We should only have three messages
messages.Length.Should().Be(3);
//ack those to remove from the queue
foreach (var message in messages)
{
_messageConsumer.Acknowledge(message);
}
//Allow ack to register
Task.Delay(1000);
//Now retrieve again
messages = _messageConsumer.Receive(500);
//This time, just the one message
messages.Length.Should().Be(1);
}
public void When_reading_a_message_via_the_messaging_gateway()
{
_sender.Send(_sentMessage);
_receivedMessage = _receiver.Receive(2000);
_receiver.Acknowledge(_receivedMessage);
//should_send_a_message_via_sqs_with_the_matching_body
Assert.AreEqual(_sentMessage.Body, _receivedMessage.Body);
//should_send_a_message_via_sqs_with_the_matching_header_handled_count
Assert.AreEqual(_sentMessage.Header.HandledCount, _receivedMessage.Header.HandledCount);
//should_send_a_message_via_sqs_with_the_matching_header_id
Assert.AreEqual(_sentMessage.Header.Id, _receivedMessage.Header.Id);
//should_send_a_message_via_sqs_with_the_matching_header_message_type
Assert.AreEqual(_sentMessage.Header.MessageType, _receivedMessage.Header.MessageType);
//should_send_a_message_via_sqs_with_the_matching_header_time_stamp
Assert.AreEqual(_sentMessage.Header.TimeStamp, _receivedMessage.Header.TimeStamp);
//should_send_a_message_via_sqs_with_the_matching_header_topic
Assert.AreEqual(_sentMessage.Header.Topic, _receivedMessage.Header.Topic);
//should_remove_the_message_from_the_queue
Assert.Null(_testQueueListener.Listen());
}
public void When_reading_a_message_via_the_messaging_gateway()
{
_sender.Send(_sentMessage);
_receivedMessage = _receiver.Receive(2000);
_receiver.Acknowledge(_receivedMessage);
//should_send_a_message_via_sqs_with_the_matching_body
_receivedMessage.Body.Should().Be(_sentMessage.Body);
//should_send_a_message_via_sqs_with_the_matching_header_handled_count
_receivedMessage.Header.HandledCount.Should().Be(_sentMessage.Header.HandledCount);
//should_send_a_message_via_sqs_with_the_matching_header_id
_receivedMessage.Header.Id.Should().Be(_sentMessage.Header.Id);
//should_send_a_message_via_sqs_with_the_matching_header_message_type
_receivedMessage.Header.MessageType.Should().Be(_sentMessage.Header.MessageType);
//should_send_a_message_via_sqs_with_the_matching_header_time_stamp
_receivedMessage.Header.TimeStamp.Should().Be(_sentMessage.Header.TimeStamp);
//should_send_a_message_via_sqs_with_the_matching_header_topic
_receivedMessage.Header.Topic.Should().Be(_sentMessage.Header.Topic);
//should_remove_the_message_from_the_queue
_testQueueListener.Listen().Should().BeNull();
}
/// <summary>
/// Acknowledges the specified message.
/// </summary>
/// <param name="message">The message.</param>
public void Acknowledge(Message message)
{
_messageConsumer.Acknowledge(message);
}