Example #1
0
        public async void WhenMessageVisibilityIsRenewed_ThenItsNotVisibleForOthers()
        {
            //arrange

            var transportFactory = new AmazonSQSTransportFactory();

            const string inputqueueName  = "inputQueue";
            var          inputQueue      = transportFactory.Create(TestConfig.QueueName(inputqueueName), TimeSpan.FromSeconds(3));
            const string inputqueueName2 = "outputQueue";
            var          outputQueue     = transportFactory.Create(TestConfig.QueueName(inputqueueName2));

            await WithContext(async context =>
            {
                await outputQueue.Send(inputqueueName, MessageWith("hej"), context);
            });

            await WithContext(async context =>
            {
                var transportMessage = await inputQueue.Receive(context);


                await WithContext(async innerContext =>
                {
                    Thread.Sleep(6000);
                    var innerMessage = await inputQueue.Receive(innerContext);

                    Assert.That(innerMessage, Is.Null);
                });


                Assert.That(transportMessage, Is.Not.Null);
            });
        }
        public async void WhenMessageVisibilityIsRenewed_ThenItsNotVisibleForOthers()
        {
            //arrange

            var transportFactory = new AmazonSQSTransportFactory();

            const string inputqueueName = "inputQueue";
            var inputQueue = transportFactory.Create(TestConfig.QueueName(inputqueueName), TimeSpan.FromSeconds(3));
            const string inputqueueName2 = "outputQueue";
            var outputQueue = transportFactory.Create(TestConfig.QueueName(inputqueueName2));

            await WithContext(async context =>
                                    {
                                        await outputQueue.Send(inputqueueName, MessageWith("hej"), context);
                                    });

            await WithContext(async context =>
                                    {
                                        var transportMessage = await inputQueue.Receive(context);


                                        await WithContext(async innerContext =>
                                                                {
                                                                    Thread.Sleep(6000);
                                                                    var innerMessage = await inputQueue.Receive(innerContext);

                                                                    Assert.That(innerMessage, Is.Null);
                                                                });


                                        Assert.That(transportMessage, Is.Not.Null);

                                    });

        }
        public async void WhenMessageVisibilityIsRenewed_ThenItsNotVisibleForOthers()
        {
            //arrange
            var peeklockDuration = TimeSpan.FromSeconds(3);

            var transportFactory = new AmazonSQSTransportFactory();

            var inputqueueName = TestConfig.QueueName("inputQueue");
            var inputQueue     = transportFactory.Create(inputqueueName, peeklockDuration);

            var inputqueueName2 = TestConfig.QueueName("outputQueue");
            var outputQueue     = transportFactory.Create(inputqueueName2);

            await WithContext(async context =>
            {
                await outputQueue.Send(inputqueueName, MessageWith("hej"), context);
            });

            await WithContext(async context =>
            {
                var transportMessage = await inputQueue.Receive(context);

                Assert.That(transportMessage, Is.Not.Null, "Expected to receive the message that we just sent");

                // pretend that it takes a while to handle the message
                Thread.Sleep(6000);

                // pretend that another thread attempts to receive from the same input queue
                await WithContext(async innerContext =>
                {
                    var innerMessage = await inputQueue.Receive(innerContext);

                    Assert.That(innerMessage, Is.Null, "Did not expect to receive a message here because its peek lock should have been renewed automatically");
                });
            });
        }
        public async void WhenMessageVisibilityIsRenewed_ThenItsNotVisibleForOthers()
        {
            //arrange
            var peeklockDuration = TimeSpan.FromSeconds(3);

            var transportFactory = new AmazonSQSTransportFactory();

            var inputqueueName = TestConfig.QueueName("inputQueue");
            var inputQueue = transportFactory.Create(inputqueueName, peeklockDuration);

            var inputqueueName2 = TestConfig.QueueName("outputQueue");
            var outputQueue = transportFactory.Create(inputqueueName2);

            await WithContext(async context =>
            {
                await outputQueue.Send(inputqueueName, MessageWith("hej"), context);
            });

            await WithContext(async context =>
            {
                var transportMessage = await inputQueue.Receive(context);

                Assert.That(transportMessage, Is.Not.Null, "Expected to receive the message that we just sent");

                // pretend that it takes a while to handle the message
                Thread.Sleep(6000);

                // pretend that another thread attempts to receive from the same input queue
                await WithContext(async innerContext =>
                {
                    var innerMessage = await inputQueue.Receive(innerContext);

                    Assert.That(innerMessage, Is.Null, "Did not expect to receive a message here because its peek lock should have been renewed automatically");
                });
            });
        }
 protected override void SetUp()
 {
     base.SetUp();
     _transportFactory = new AmazonSQSTransportFactory();
 }
        protected override void SetUp()
        {
            base.SetUp();
            _transportFactory = new AmazonSQSTransportFactory();

        }