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);
        }
Пример #4
0
        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);
        }
Пример #5
0
        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
            });
        }
Пример #8
0
      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);
      }
Пример #9
0
        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
            };
        }