protected override Task Arrange()
        {
            _observer = new EndpointObserver(Harness);
            Harness.OnConfigureBus += cfg =>
            {
                cfg.ConnectBusObserver(new BusObserver(Harness, _observer));
            };

            Harness.OnConfigureReceiveEndpoint += x => x.ConcurrentMessageLimit = 1;

            _consumer = Harness.Consumer <SubmitOrderConsumer>();

            return(Task.CompletedTask);
        }
Example #2
0
        public async Task Setup()
        {
            _consumer = Harness.Consumer <CreateCommandConsumer>();

            Harness.OnConfigureBus += configurator =>
            {
                var sec5 = TimeSpan.FromSeconds(5);
                configurator.UseRetry(x => x.Exponential(2, sec5, sec5, sec5));
            };

            await Harness.Start();

            await Harness.Bus.Publish(new CreateCommand
            {
                Name = "Test"
            });
        }
            public async Task Setup()
            {
                _consumer = Harness.Consumer <TestCommandConsumer>();

                Harness.OnConfigureBus += cfg =>
                {
                    cfg.ReceiveEndpoint(Harness.InputQueueName + "_fault", x =>
                    {
                        _faultHandler = Harness.Handled <Fault <FailingCommand> >(x);
                    });
                };

                await Harness.Start();

                await Harness.InputQueueSendEndpoint.Send <FailingCommand>(new { CorrelationId = NewId.NextGuid() }, context =>
                {
                    context.CorrelationId = _correlationId;
                });
            }
Example #4
0
            public async Task Setup()
            {
                _consumer = Harness.Consumer <TestCommandConsumer>();

                await Harness.Start();

                _publish = new PublishObserver(Harness);
                Harness.Bus.ConnectPublishObserver(_publish);

                _send = new SendObserver(Harness);
                Harness.Bus.ConnectSendObserver(_send);

                _correlationId = NewId.NextGuid();

                await Harness.Bus.Publish <TestEvent>(new
                {
                    CorrelationId = _correlationId
                });
            }
        protected override Task Arrange()
        {
            _batchConsumer = new TestBatchConsumer(Harness.GetTask <Batch <SubmitOrder> >());

            var batchOptions = new BatchOptions
            {
                MessageLimit = 20,
                TimeLimit    = TimeSpan.FromSeconds(20)
            };

            Harness.Consumer(() => _batchConsumer, configurator =>
            {
                configurator.Options(batchOptions);
            });

            Harness.OnConfigureReceiveEndpoint += x =>
            {
                batchOptions.Configure(Harness.InputQueueName, x);
            };

            return(Task.CompletedTask);
        }
Example #6
0
            public Task Setup()
            {
                _consumer = Harness.Consumer <TestCommandConsumer>();

                return(Harness.Start());
            }
Example #7
0
        protected override Task Arrange()
        {
            _consumer = Harness.Consumer <SubmitOrderConsumer>();

            return(Task.CompletedTask);
        }