Exemple #1
0
    public async Task Then_The_Pipeline_Should_Only_Contain_User_Specified_Middlewares()
    {
        // Arrange
        var handler        = new InspectableHandler <SimpleMessage>();
        var testMiddleware = new InspectableMiddleware <SimpleMessage>();

        var services = GivenJustSaying()
                       .ConfigureJustSaying((builder) =>
                                            MessagingBusBuilderTestExtensions.WithLoopbackTopic <SimpleMessage>(builder,
                                                                                                                UniqueName,
                                                                                                                c => c.WithMiddlewareConfiguration(m =>
        {
            m.Use(testMiddleware);
            m.UseHandler(_ => handler);
        })))
                       .AddJustSayingHandlers(new[] { handler });

        string json = "";

        await WhenAsync(
            services,
            (_, listener, _, _) =>
        {
            dynamic middlewares = ((dynamic)listener.Interrogate().Data).Middleware;

            json = JsonConvert.SerializeObject(middlewares, Formatting.Indented)
                   .Replace(UniqueName, "TestQueueName");

            return(Task.CompletedTask);
        });

        json.ShouldMatchApproved(c => c.SubFolder("Approvals"));
    }
        public async Task Add_Different_Handler_Per_Queue()
        {
            // Arrange
            string group1     = "group1";
            string group2     = "group2";
            string queueName1 = "queue1";
            string queueName2 = "queue2";

            JustSaying.JustSayingBus bus = CreateBus();

            var middleware1 = new InspectableMiddleware <TestJustSayingMessage>();
            var middleware2 = new InspectableMiddleware <TestJustSayingMessage>();

            bus.AddMessageMiddleware <TestJustSayingMessage>(queueName1, middleware1);
            bus.AddMessageMiddleware <TestJustSayingMessage>(queueName2, middleware2);

            ISqsQueue queue1 = TestQueue(bus.SerializationRegister, queueName1);
            ISqsQueue queue2 = TestQueue(bus.SerializationRegister, queueName2);

            bus.AddQueue(group1, queue1);
            bus.AddQueue(group2, queue2);

            using var cts = new CancellationTokenSource();

            // Act
            await bus.StartAsync(cts.Token);

            await Patiently.AssertThatAsync(_outputHelper,
                                            () =>
            {
                middleware1.Handler.ReceivedMessages.Count.ShouldBeGreaterThan(0);
                middleware2.Handler.ReceivedMessages.Count.ShouldBeGreaterThan(0);
            });

            cts.Cancel();
            await bus.Completion;

            foreach (var message in middleware1.Handler.ReceivedMessages)
            {
                message.QueueName.ShouldBe(queueName1);
            }

            foreach (var message in middleware2.Handler.ReceivedMessages)
            {
                message.QueueName.ShouldBe(queueName2);
            }

            bus.Dispose();
        }