public SQSBufferedConsumerTests()
{
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
_channelFactory = new ChannelFactory(awsConnection);
var channelName = $"Buffered-Consumer-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_topicName = $"Buffered-Consumer-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
//we need the channel to create the queues and notifications
var routingKey = new RoutingKey(_topicName);
var channel = _channelFactory.CreateChannel(new SqsSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
bufferSize: BUFFER_SIZE
));
//we want to access via a consumer, to receive multiple messages - we don't want to expose on channel
//just for the tests, so create a new consumer from the properties
_consumer = new SqsMessageConsumer(awsConnection, channel.Name.ToValidSQSQueueName(), routingKey, BUFFER_SIZE);
_messageProducer = new SqsMessageProducer(awsConnection, new SqsPublication {
MakeChannels = OnMissingChannel.Create, RoutingKey = routingKey
});
}
public AWSAssumeQueuesTests()
{
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);
var subscription = new SqsSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
makeChannels: OnMissingChannel.Assume
);
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
//create the topic, we want the queue to be the issue
var _ = new SqsMessageProducer(awsConnection,
new SqsPublication
{
MakeChannels = OnMissingChannel.Create,
RoutingKey = routingKey
});
_channelFactory = new ChannelFactory(awsConnection);
var channel = _channelFactory.CreateChannel(subscription);
//We need to create the topic at least, to check the queues
_consumer = new SqsMessageConsumer(awsConnection, channel.Name.ToValidSQSQueueName(), routingKey);
}
public SQSBufferedConsumerTests()
{
//Must have credentials stored in the SDK Credentials store or shared credentials file
var credentialChain = new CredentialProfileStoreChain();
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
_channelFactory = new ChannelFactory(awsConnection, new SqsMessageConsumerFactory(awsConnection));
var channelName = $"Buffered-Consumer-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_topicName = $"Buffered-Consumer-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
//we need the channel to create the queues and notifications
_channelFactory.CreateChannel(new Connection <MyCommand>(
name: new ConnectionName(channelName),
channelName: new ChannelName(channelName),
routingKey: new RoutingKey(_topicName),
bufferSize: BUFFER_SIZE
));
//we want to access via a consumer, to receive multiple messages - we don't want to expose on channel
//just for the tests, so create a new consumer from the properties
var sqsQueueName = new ChannelName(channelName).ToValidSQSQueueName();
_consumer = new SqsMessageConsumer(awsConnection, sqsQueueName, BUFFER_SIZE);
_messageProducer = new SqsMessageProducer(awsConnection);
}
public AWSValidateQueuesTests()
{
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);
_subscription = new SqsSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
makeChannels: OnMissingChannel.Validate
);
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
_awsConnection = new AWSMessagingGatewayConnection(credentials, region);
//We need to create the topic at least, to check the queues
var producer = new SqsMessageProducer(_awsConnection,
new SqsPublication
{
MakeChannels = OnMissingChannel.Create
});
producer.ConfirmTopicExists(topicName);
}
public SqsMessageConsumerRequeueTests()
{
_myCommand = new MyCommand {
Value = "Test"
};
Guid correlationId = Guid.NewGuid();
string replyTo = "http:\\queueUrl";
string contentType = "text\\plain";
var channelName = $"Consumer-Requeue-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
string topicName = $"Consumer-Requeue-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
);
_message = new Message(
new MessageHeader(_myCommand.Id, topicName, MessageType.MT_COMMAND, correlationId, replyTo, contentType),
new MessageBody(JsonSerializer.Serialize((object)_myCommand, JsonSerialisationOptions.Options))
);
//Must have credentials stored in the SDK Credentials store or shared credentials file
(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
_channelFactory = new ChannelFactory(awsConnection);
_channel = _channelFactory.CreateChannel(subscription);
_messageProducer = new SqsMessageProducer(awsConnection, new SnsPublication {
MakeChannels = OnMissingChannel.Create
});
}
public SqsMessageProducerSendTests()
{
_myCommand = new MyCommand {
Value = "Test"
};
_correlationId = Guid.NewGuid();
_replyTo = "http:\\queueUrl";
_contentType = "text\\plain";
var channelName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_topicName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_connection = new Connection <MyCommand>(
name: new ConnectionName(channelName),
channelName: new ChannelName(channelName),
routingKey: new RoutingKey(_topicName)
);
_message = new Message(
new MessageHeader(_myCommand.Id, _topicName, MessageType.MT_COMMAND, _correlationId, _replyTo, _contentType),
new MessageBody(JsonConvert.SerializeObject((object)_myCommand))
);
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
_channelFactory = new ChannelFactory(awsConnection, new SqsMessageConsumerFactory(awsConnection));
_channel = _channelFactory.CreateChannel(_connection);
_messageProducer = new SqsMessageProducer(awsConnection);
}
public SqsMessageProducerSendTests()
{
_myCommand = new MyCommand {
Value = "Test"
};
_correlationId = Guid.NewGuid();
_replyTo = "http:\\queueUrl";
_contentType = "text\\plain";
var channelName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_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
);
_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);
_channelFactory = new ChannelFactory(awsConnection);
_channel = _channelFactory.CreateChannel(subscription);
_messageProducer = new SqsMessageProducer(awsConnection, new SnsPublication {
Topic = new RoutingKey(_topicName), MakeChannels = OnMissingChannel.Create
});
}
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 SqsRawMessageDeliveryTests()
{
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
var awsConnection = new AWSMessagingGatewayConnection(credentials, region);
_channelFactory = new ChannelFactory(awsConnection);
var channelName = $"Raw-Msg-Delivery-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_topicName = $"Raw-Msg-Delivery-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
var routingKey = new RoutingKey(_topicName);
var bufferSize = 10;
//Set rawMessageDelivery to false
_channel = _channelFactory.CreateChannel(new SqsSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
bufferSize: bufferSize,
makeChannels: OnMissingChannel.Create,
rawMessageDelivery: false));
_messageProducer = new SqsMessageProducer(awsConnection,
new SnsPublication
{
MakeChannels = OnMissingChannel.Create
});
}
public AWSValidateMissingTopicTests()
{
string topicName = $"Producer-Send-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_routingKey = new RoutingKey(topicName);
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
_awsConnection = new AWSMessagingGatewayConnection(credentials, region);
//Because we don't use channel factory to create the infrastructure -it won't exist
}
public SnsReDrivePolicySDlqTests()
{
Guid correlationId = Guid.NewGuid();
string replyTo = "http:\\queueUrl";
string contentType = "text\\plain";
var channelName = $"Redrive-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_dlqChannelName = $"Redrive-DLQ-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
_topicName = $"Redrive-Tests-{Guid.NewGuid().ToString()}".Truncate(45);
var routingKey = new RoutingKey(_topicName);
//how are we consuming
var subscription = new SqsSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
//don't block the redrive policy from owning retry management
requeueCount: -1,
//delay before requeuing
requeueDelayInMs: 50,
//we want our SNS subscription to manage requeue limits using the DLQ for 'too many requeues'
redrivePolicy: new RedrivePolicy
(
deadLetterQueueName: new ChannelName(_dlqChannelName),
maxReceiveCount: 2
));
//what do we send
var myCommand = new MyDeferredCommand {
Value = "Hello Redrive"
};
_message = new Message(
new MessageHeader(myCommand.Id, _topicName, MessageType.MT_COMMAND, correlationId, replyTo, contentType),
new MessageBody(JsonSerializer.Serialize((object)myCommand, JsonSerialisationOptions.Options))
);
//Must have credentials stored in the SDK Credentials store or shared credentials file
(AWSCredentials credentials, RegionEndpoint region) = CredentialsChain.GetAwsCredentials();
_awsConnection = new AWSMessagingGatewayConnection(credentials, region);
//how do we send to the queue
_sender = new SqsMessageProducer(_awsConnection, new SnsPublication {
MakeChannels = OnMissingChannel.Create
});
//We need to do this manually in a test - will create the channel from subscriber parameters
_channelFactory = new ChannelFactory(_awsConnection);
_channel = _channelFactory.CreateChannel(subscription);
//how do we handle a command
IHandleRequests <MyDeferredCommand> handler = new MyDeferredCommandHandler();
//hook up routing for the command processor
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <MyDeferredCommand, MyDeferredCommandHandler>();
//once we read, how do we dispatch to a handler. N.B. we don't use this for reading here
_commandProcessor = new CommandProcessor(
subscriberRegistry: subscriberRegistry,
handlerFactory: new QuickHandlerFactory(() => handler),
requestContextFactory: new InMemoryRequestContextFactory(),
policyRegistry: new PolicyRegistry()
);
//pump messages from a channel to a handler - in essence we are building our own dispatcher in this test
IAmAMessageMapper <MyDeferredCommand> mapper = new MyDeferredCommandMessageMapper(_topicName);
_messagePump = new MessagePumpBlocking <MyDeferredCommand>(_commandProcessor, mapper)
{
Channel = _channel, TimeoutInMilliseconds = 5000, RequeueCount = 3
};
}