Example #1
0
        public async void Reuses_MessageSender_ForTheSameQueueName_OnConcurrentTasks()
        {
            // prepare
            const string queueName = "test-queue";

            int taskCount = 5;

            IMessageSender[] messageSenders = new IMessageSender[taskCount];
            Task[]           tasks          = new Task[taskCount];

            for (int i = 0; i < taskCount; i++)
            {
                var y = i; // CLOSURE - we dont want to capture i as it is changing outside of the delegate!!!
                tasks[i] = Task.Run(
                    () => messageSenders[y] = _messageSenderFactory.GetMessageSender(queueName));
            }

            // execute
            await Task.WhenAll(tasks);

            // test
            foreach (var ms in messageSenders)
            {
                Assert.NotNull(ms);
            }

            // each message sender is for the same queue
            var groupedByPath = messageSenders.GroupBy(x => x.Path);

            Assert.Single(groupedByPath);

            // each message sender has the same client Id
            var groupedByClientId = messageSenders.GroupBy(x => x.ClientId);

            Assert.Single(groupedByClientId);

            // finally check that each message sender is indeed the same object
            var firstMs = messageSenders[0];

            for (int i = 1; i < taskCount; i++)
            {
                Assert.True(object.ReferenceEquals(firstMs, messageSenders[i]));
            }
        }
Example #2
0
        public async void Reuses_MessageSenders_ForMultipleQueueNames_OnConcurrentTasks()
        {
            // prepare
            const string queueName0 = "test-queue-0";
            const string queueName1 = "test-queue-1";

            int taskCount = 6;

            IMessageSender[] messageSenders = new IMessageSender[taskCount];
            Task[]           tasks          = new Task[taskCount];

            for (int i = 0; i < taskCount; i++)
            {
                var y = i; // CLOSURE - we dont want to capture i as it is changing outside of the delegate!!!
                tasks[i] = Task.Run(
                    () => {
                    // each "even" message sender gets test-queue-0
                    // each "odd" message sender gets test-queue-1
                    var suffix        = y % 2 == 0 ? 0 : 1;
                    messageSenders[y] = _messageSenderFactory.GetMessageSender($"test-queue-{suffix}");
                });
            }

            // execute
            await Task.WhenAll(tasks);

            // test
            foreach (var ms in messageSenders)
            {
                Assert.NotNull(ms);
            }

            // each message sender is for the same queue
            var groupedByPath = messageSenders.GroupBy(x => x.Path);

            Assert.Equal(2, groupedByPath.Count());

            // check all even senders are the same object
            var evenSenders = messageSenders.Where(s => s.Path.Equals(queueName0)).ToList();
            var evenSender0 = evenSenders[0];

            Assert.True(object.ReferenceEquals(evenSender0, evenSenders[1]));
            Assert.True(object.ReferenceEquals(evenSender0, evenSenders[2]));

            // check all odd senders are the same object
            var oddSenders = messageSenders.Where(s => s.Path.Equals(queueName1)).ToList();
            var oddSender0 = oddSenders[0];

            Assert.True(object.ReferenceEquals(oddSender0, oddSenders[1]));
            Assert.True(object.ReferenceEquals(oddSender0, oddSenders[2]));

            // check odd and even senders are different objects
            Assert.False(object.ReferenceEquals(evenSender0, oddSender0));
        }