/// <summary>
/// Initializes a new instance of the <see cref="InputChannel"/> class.
/// </summary>
/// <param name="queueName">Name of the queue.</param>
/// <param name="messageConsumer">The messageConsumer.</param>
public InputChannel(string channelName, IAmAMessageConsumer messageConsumer)
{
_channelName = channelName;
_messageConsumer = messageConsumer;
_messageConsumerSupportsDelay = _messageConsumer is IAmAMessageConsumerSupportingDelay && (_messageConsumer as IAmAMessageGatewaySupportingDelay).DelaySupported;
_messageConsumerSupportsCache = _messageConsumer is IAmAMessageConsumerSupportingCache && (_messageConsumer as IAmAMessageGatewaySupportingCache).CacheSupported;
}
/// <summary>
/// Initializes a new instance of the <see cref="InputChannel"/> class.
/// </summary>
/// <param name="queueName">Name of the queue.</param>
/// <param name="messageConsumer">The messageConsumer.</param>
public InputChannel(string channelName, IAmAMessageConsumer messageConsumer)
{
_channelName = channelName;
_messageConsumer = messageConsumer;
_messageConsumerSupportsDelay = _messageConsumer is IAmAMessageConsumerSupportingDelay && (_messageConsumer as IAmAMessageGatewaySupportingDelay).DelaySupported;
_messageConsumerSupportsCache = _messageConsumer is IAmAMessageConsumerSupportingCache && (_messageConsumer as IAmAMessageGatewaySupportingCache).CacheSupported;
}
public RmqAssumeExistingInfrastructureTests()
{
_message = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange(Guid.NewGuid().ToString())
};
_messageProducer = new RmqMessageProducer(rmqConnection, new RmqPublication {
MakeChannels = OnMissingChannel.Assume
});
_messageConsumer = new RmqMessageConsumer(
connection: rmqConnection,
queueName: _message.Header.Topic,
routingKey: _message.Header.Topic,
isDurable: false,
highAvailability: false,
makeChannels: OnMissingChannel.Assume);
//This creates the infrastructure we want
new QueueFactory(rmqConnection, _message.Header.Topic).Create(3000);
}
public AWSValidateInfrastructureByArnTests()
{
_myCommand = new MyCommand {
Value = "Test"
};
Guid correlationId = Guid.NewGuid();
string replyTo = "http:\\queueUrl";
string contentType = "text\\plain";
var channelName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
string topicName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
var routingKey = new RoutingKey(topicName);
SqsSubscription <MyCommand> subscription = new(
name : new SubscriptionName(channelName),
channelName : new ChannelName(channelName),
routingKey : routingKey,
makeChannels : OnMissingChannel.Create
);
_message = new Message(
new MessageHeader(_myCommand.Id, topicName, MessageType.MT_COMMAND, correlationId, replyTo, contentType),
new MessageBody(JsonSerializer.Serialize((object)_myCommand, JsonSerialisationOptions.Options))
);
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
//We need to do this manually in a test - will create the channel from subscriber parameters
//This doesn't look that different from our create tests - this is because we create using the channel factory in
//our AWS transport, not the consumer (as it's a more likely to use infrastructure declared elsewhere)
_channelFactory = new ChannelFactory(awsConnection);
var channel = _channelFactory.CreateChannel(subscription);
var topicArn = FindTopicArn(credentials, region, routingKey.Value);
var routingKeyArn = new RoutingKey(topicArn);
//Now change the subscription to validate, just check what we made
subscription = new(
name : new SubscriptionName(channelName),
channelName : channel.Name,
routingKey : routingKeyArn,
findTopicBy : TopicFindBy.Arn,
makeChannels : OnMissingChannel.Validate
);
_messageProducer = new SqsMessageProducer(
awsConnection,
new SqsPublication
{
TopicArns = new Dictionary <string, string>()
{
{ topicName, topicArn }
},
FindTopicBy = TopicFindBy.Arn,
MakeChannels = OnMissingChannel.Validate
});
_consumer = new SqsMessageConsumerFactory(awsConnection).Create(subscription);
}
public RmqMessageProducerTTLTests()
{
_messageOne = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
_messageTwo = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(
connection: rmqConnection,
queueName: _messageOne.Header.Topic,
routingKey: _messageOne.Header.Topic,
isDurable: false,
highAvailability: false,
ttl: 10000,
makeChannels: OnMissingChannel.Create
);
//create the infrastructure
_messageConsumer.Receive(0);
}
public void When_a_message_is_sent_keep_order()
{
IAmAMessageConsumer consumer = _consumer;
try
{
//Send a sequence of messages to Kafka
var msgId = SendMessage();
var msgId2 = SendMessage();
var msgId3 = SendMessage();
var msgId4 = SendMessage();
//Now read those messages in order
var firstMessage = ConsumeMessages(consumer);
var message = firstMessage.First();
message.Id.Should().Be(msgId);
var secondMessage = ConsumeMessages(consumer);
message = secondMessage.First();
message.Id.Should().Be(msgId2);
var thirdMessages = ConsumeMessages(consumer);
message = thirdMessages.First();
message.Id.Should().Be(msgId3);
var fourthMessage = ConsumeMessages(consumer);
message = fourthMessage.First();
message.Id.Should().Be(msgId4);
}
finally
{
consumer?.Dispose();
}
}
private IEnumerable <Message> ConsumeMessages(IAmAMessageConsumer consumer)
{
var messages = new Message[0];
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)
{
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);
return(messages);
}
public void When_queue_is_Purged()
{
IAmAMessageConsumer consumer = _consumer;
try
{
//Send a sequence of messages to Kafka
var msgId = SendMessage();
var msgId2 = SendMessage();
var msgId3 = SendMessage();
var msgId4 = SendMessage();
//Now read those messages in order
var firstMessage = ConsumeMessages(consumer);
var message = firstMessage.First();
message.Id.Should().Be(msgId);
_consumer.Purge();
//Next Message should not exists (default will be returned)
var nextMessage = ConsumeMessages(consumer);
message = nextMessage.First();
Assert.Equal(new Message(), message);
}
finally
{
consumer?.Dispose();
}
}
public ChannelRequeueWithoutDelayTest()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway);
_requeueMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
}
public RestMsMessageProducerSendTests()
{
var configuration = new RestMSMessagingGatewayConfiguration
{
Feed = new Feed { Name = "test", Type = "Default"},
RestMS = new RestMsSpecification { Uri = new Uri("http://localhost:3416/restms/domain/default"), Id = "dh37fgj492je", User ="******", Key ="wBgvhp1lZTr4Tb6K6+5OQa1bL9fxK7j8wBsepjqVNiQ=", Timeout=2000}
};
_messageProducer = new RestMsMessageProducer(configuration);
_messageConsumer = new RestMsMessageConsumer(configuration, QueueName, Topic);
_message = new Message(new MessageHeader(Guid.NewGuid(), Topic, MessageType.MT_COMMAND), new MessageBody("test content"));
}
public PurgeTest()
{
var testHelper = new MsSqlTestHelper();
testHelper.SetupQueueDb();
var sub = new Subscription <MyCommand>(new SubscriptionName(_queueName),
new ChannelName(_topic), new RoutingKey(_topic));
_producer = new MsSqlMessageProducerFactory(testHelper.QueueConfiguration).Create();
_consumer = new MsSqlMessageConsumerFactory(testHelper.QueueConfiguration).Create(sub);
}
public ChannelMessageReceiveTests()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway);
_sentMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
A.CallTo(() => _gateway.Receive(1000)).Returns(_sentMessage);
}
public ChannelAcknowledgeTests()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway);
_receivedMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
_receivedMessage.DeliveryTag = 12345UL;
}
public void Establish()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway);
_receivedMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
_receivedMessage.SetDeliveryTag(12345UL);
}
public void Establish()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway);
_requeueMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
_stopWatch = new Stopwatch();
}
public ChannelRequeueWithUsnpportedDelayTests()
{
_consumer = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _consumer);
_requeueMessage = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("a test body"));
_stopWatch = new Stopwatch();
}
public SqsMessageProducerRequeueTests()
{
var messageHeader = new MessageHeader(Guid.NewGuid(), "TestSqsTopic", MessageType.MT_COMMAND);
messageHeader.UpdateHandledCount();
_sentMessage = new Message(messageHeader, new MessageBody("test content"));
var credentials = new AnonymousAWSCredentials();
_sender = new SqsMessageProducer(credentials);
_receiver = new SqsMessageConsumer(credentials, _queueUrl);
_testQueueListener = new TestAWSQueueListener(credentials, _queueUrl);
}
/// <summary>
/// Initializes a new instance of the <see cref="Channel" /> class.
/// </summary>
/// <param name="channelName">Name of the queue.</param>
/// <param name="messageConsumer">The messageConsumer.</param>
/// <param name="maxQueueLength">What is the maximum buffer size we will accelt</param>
public Channel(string channelName, IAmAMessageConsumer messageConsumer, int maxQueueLength = 1)
{
_channelName = channelName;
_messageConsumer = messageConsumer;
if (maxQueueLength < 1 || maxQueueLength > 10)
{
throw new ConfigurationException(
"The channel buffer must have one item, and cannot have more than 10");
}
_maxQueueLength = maxQueueLength;
}
public RMQBufferedConsumerTests()
{
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(rmqConnection, _topic, _topic, false, false, BatchSize);
//create the queue, so that we can receive messages posted to it
new QueueFactory(rmqConnection, _topic).Create(3000);
}
public BufferedChannelTests()
{
_gateway = A.Fake <IAmAMessageConsumer>();
_channel = new Channel("test", _gateway, BufferLimit);
_messageOne = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("FirstMessage"));
_messageTwo = new Message(
new MessageHeader(Guid.NewGuid(), "key", MessageType.MT_EVENT),
new MessageBody("SecondMessage"));
}
public RmqMessageProducerSendMessageTests()
{
_message = new Message(new MessageHeader(Guid.NewGuid(), "test1", MessageType.MT_COMMAND), new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(rmqConnection, _message.Header.Topic, _message.Header.Topic, false, 1, false);
_messageConsumer.Purge();
_client = new TestRMQListener(rmqConnection, _message.Header.Topic);
}
public RmqMessageProducerSendMessageTests()
{
_message = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(rmqConnection, _message.Header.Topic, _message.Header.Topic, false, false);
new QueueFactory(rmqConnection, _message.Header.Topic).Create(3000);
}
public void Establish()
{
var messageHeader = new MessageHeader(Guid.NewGuid(), "TestSqsTopic", MessageType.MT_COMMAND);
messageHeader.UpdateHandledCount();
_message = new Message(header: messageHeader, body: new MessageBody("test content"));
var credentials = new AnonymousAWSCredentials();
_sender = new SqsMessageProducer(credentials);
_receiver = new SqsMessageConsumer(credentials, _queueUrl);
_testQueueListener = new TestAWSQueueListener(credentials, _queueUrl);
_sender.Send(_message);
_listenedMessage = _receiver.Receive(1000);
}
public OrderTest()
{
var testHelper = new MsSqlTestHelper();
testHelper.SetupQueueDb();
var sub = new Subscription <MyCommand>(new SubscriptionName(_queueName),
new ChannelName(_topic), new RoutingKey(_topic));
_producerRegistry = new MsSqlProducerRegistryFactory(
testHelper.QueueConfiguration,
new Publication[] { new Publication()
{
Topic = new RoutingKey(_topic)
} }
).Create();
_consumer = new MsSqlMessageConsumerFactory(testHelper.QueueConfiguration).Create(sub);
}
public RmqMessageConsumerMultipleTopicTests()
{
_messageTopic1 = new Message(new MessageHeader(Guid.NewGuid(), "test1", MessageType.MT_COMMAND), new MessageBody("test content for topic test 1"));
_messageTopic2 = new Message(new MessageHeader(Guid.NewGuid(), "test2", MessageType.MT_COMMAND), new MessageBody("test content for topic test 2"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var topics = new[] { _messageTopic1.Header.Topic, _messageTopic2.Header.Topic };
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(rmqConnection, "Multiple.Topic.Queue", topics, false, 1, false);
_messageConsumer.Purge();
_client = new TestRMQListener(rmqConnection, "Multiple.Topic.Queue", topics);
}
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 RmqMessageConsumerOperationInterruptedTests()
{
var messageHeader = new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND);
messageHeader.UpdateHandledCount();
_sentMessage = new Message(messageHeader, new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_sender = new RmqMessageProducer(rmqConnection);
_receiver = new RmqMessageConsumer(rmqConnection, _sentMessage.Header.Topic, _sentMessage.Header.Topic, false, false);
_badReceiver = new OperationInterruptedRmqMessageConsumer(rmqConnection, _sentMessage.Header.Topic, _sentMessage.Header.Topic, false, 1, false);
_sender.Send(_sentMessage);
}
public void Establish()
{
var messageHeader = new MessageHeader(Guid.NewGuid(), "test2", MessageType.MT_COMMAND);
messageHeader.UpdateHandledCount();
_sentMessage = new Message(header: messageHeader, body: new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_sender = new RmqMessageProducer(rmqConnection);
_receiver = new RmqMessageConsumer(rmqConnection, _sentMessage.Header.Topic, _sentMessage.Header.Topic, false, 1, false);
_badReceiver = new NotSupportedRmqMessageConsumer(rmqConnection, _sentMessage.Header.Topic, _sentMessage.Header.Topic, false, 1, false);
_receiver.Purge();
_sender.Send(_sentMessage);
}
public IAmAChannel CreateChannel(Subscription subscription)
{
if (!(subscription is AzureServiceBusSubscription azureServiceBusSubscription))
{
throw new ConfigurationException("We expect an AzureServiceBusSubscription or AzureServiceBusSubscription<T> as a parameter");
}
if (subscription.TimeoutInMiliseconds < 400)
{
throw new ArgumentException("The minimum allowed timeout is 400 milliseconds");
}
IAmAMessageConsumer messageConsumer = _azureServiceBusConsumerFactory.Create(azureServiceBusSubscription);
return(new Channel(
channelName: subscription.ChannelName,
messageConsumer: messageConsumer,
maxQueueLength: subscription.BufferSize
));
}
public KafkaMessageProducerSendTests(ITestOutputHelper output)
{
_output = output;
_producer = new KafkaMessageProducerFactory(
new KafkaMessagingGatewayConfiguration
{
Name = "Kafka Producer Send Test",
BootStrapServers = new[] { "localhost:9092" }
}).Create();
_consumer = new KafkaMessageConsumerFactory(
new KafkaMessagingGatewayConfiguration
{
Name = "Kafka Consumer Test",
BootStrapServers = new[] { "localhost:9092" }
}).Create(new Connection <MyCommand>(
channelName: new ChannelName(_queueName),
routingKey: new RoutingKey(_topic)
)
);
}
public RmqMessageProducerDelayedMessageTests()
{
var header = new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND);
var originalMessage = new Message(header, new MessageBody("test3 content"));
var mutatedHeader = new MessageHeader(header.Id, Guid.NewGuid().ToString(), MessageType.MT_COMMAND);
mutatedHeader.Bag.Add(HeaderNames.DELAY_MILLISECONDS, 1000);
_message = new Message(mutatedHeader, originalMessage.Body);
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.delay.brighter.exchange", supportDelay: true)
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageConsumer = new RmqMessageConsumer(rmqConnection, _message.Header.Topic, _message.Header.Topic, false, false);
new QueueFactory(rmqConnection, _message.Header.Topic).Create(3000);
}
