public async Task When_Sending_A_Command_And_The_Policy_Is_Not_In_The_Registry_Async()
        {
            _exception = await Catch.ExceptionAsync(() => _commandProcessor.SendAsync(_myCommand));

            //_should_throw_an_exception
            _exception.Should().BeOfType <KeyNotFoundException>();
            //_should_give_the_name_of_the_missing_policy
            _exception.Should().NotBeNull();
            _exception.Message.Should().Contain("The given key 'MyDivideByZeroPolicy' was not present in the dictionary");
        }
Esempio n. 2
0
        public async Task When_There_Are_Multiple_Possible_Command_Handlers_Async()
        {
            _exception = await Catch.ExceptionAsync(() => _commandProcessor.SendAsync(_myCommand));

            //_should_fail_because_multiple_receivers_found
            _exception.Should().BeOfType <ArgumentException>();
            //_should_have_an_error_message_that_tells_you_why = () => _exception
            _exception.Should().NotBeNull();
            _exception.Message.Should().Contain("More than one handler was found for the typeof command Paramore.Brighter.Core.Tests.CommandProcessors.TestDoubles.MyCommand - a command should only have one handler.");
        }
Esempio n. 3
0
        public async Task When_There_Are_Multiple_Subscribers_Async()
        {
            _exception = await Catch.ExceptionAsync(() => _commandProcessor.PublishAsync(_myEvent));

            //_should_not_throw_an_exception
            _exception.Should().BeNull();
            //_should_publish_the_command_to_the_first_event_handler
            _receivedMessages.Should().Contain(nameof(MyEventHandlerAsync), _myEvent.Id);
            //_should_publish_the_command_to_the_second_event_handler
            _receivedMessages.Should().Contain(nameof(MyOtherEventHandlerAsync), _myEvent.Id);
        }
Esempio n. 4
0
        public async Task When_The_Message_Is_Already_In_The_Command_Store_Async()
        {
            await _sqlCommandStore.AddAsync(_raisedCommand, _contextKey);

            _exception = await Catch.ExceptionAsync(() => _sqlCommandStore.AddAsync(_raisedCommand, _contextKey));

            //_should_succeed_even_if_the_message_is_a_duplicate
            _exception.Should().BeNull();
            var exists = await _sqlCommandStore.ExistsAsync <MyCommand>(_raisedCommand.Id, _contextKey);

            exists.Should().BeTrue();
        }
Esempio n. 5
0
        public async Task Command_Is_Not_Stored_If_The_Handler_Is_Not_Successful()
        {
            Guid id = Guid.NewGuid();
            await Catch.ExceptionAsync(async() => await _commandProcessor.SendAsync(new MyCommandToFail()
            {
                Id = id
            }));

            var exists = await _inbox.ExistsAsync <MyCommandToFail>(id, typeof(MyStoredCommandToFailHandlerAsync).FullName);

            exists.Should().BeFalse();
        }
        public async Task When_The_Message_Is_Already_In_The_Inbox_Async()
        {
            await _sqlInbox.AddAsync(_raisedCommand, _contextKey);

            _exception = await Catch.ExceptionAsync(() => _sqlInbox.AddAsync(_raisedCommand, _contextKey));

            //_should_succeed_even_if_the_message_is_a_duplicate
            _exception.Should().BeNull();
            var exists = await _sqlInbox.ExistsAsync <MyCommand>(_raisedCommand.Id, _contextKey);

            AssertionExtensions.Should((bool)exists).BeTrue();
        }
Esempio n. 7
0
        public async Task When_Publishing_To_Multiple_Subscribers_Should_Aggregate_Exceptions_Async()
        {
            _exception = await Catch.ExceptionAsync(async() => await _commandProcessor.PublishAsync(_myEvent));

            //_should_throw_an_aggregate_exception
            _exception.Should().BeOfType <AggregateException>();
            //_should_have_an_inner_exception_from_the_handler
            ((AggregateException)_exception).InnerException.Should().BeOfType <InvalidOperationException>();
            //_should_publish_the_command_to_the_first_event_handler
            _receivedMessages.Should().Contain(nameof(MyEventHandlerAsync), _myEvent.Id);
            //_should_publish_the_command_to_the_second_event_handler
            _receivedMessages.Should().Contain(nameof(MyOtherEventHandlerAsync), _myEvent.Id);
        }
        public async Task When_there_are_multiple_messages_in_the_message_store_and_a_range_by_index_is_fetched()
        {
            await _dynamoDbMessageStore.AddAsync(_messageEarliest);

            await Task.Delay(100);

            await _dynamoDbMessageStore.AddAsync(_message1);

            await Task.Delay(100);

            await _dynamoDbMessageStore.AddAsync(_message2);

            var exception = await Catch.ExceptionAsync(() => _dynamoDbMessageStore.GetAsync(1, 3));

            exception.Should().BeOfType <NotSupportedException>();
        }
Esempio n. 9
0
        public async Task When_Sending_A_Command_That_Repeatedly_Fails_Break_The_Circuit_Async()
        {
            //First two should be caught, and increment the count
            _firstException = await Catch.ExceptionAsync(async() => await _commandProcessor.SendAsync(_myCommand));

            _secondException = await Catch.ExceptionAsync(async() => await _commandProcessor.SendAsync(_myCommand));

            //this one should tell us that the circuit is broken
            _thirdException = await Catch.ExceptionAsync(async() => await _commandProcessor.SendAsync(_myCommand));

            //_should_send_the_command_to_the_command_handler
            MyFailsWithDivideByZeroHandlerAsync.ShouldReceive(_myCommand).Should().BeTrue();
            //_should_bubble_up_the_first_exception
            _firstException.Should().BeOfType <DivideByZeroException>();
            //_should_bubble_up_the_second_exception
            _secondException.Should().BeOfType <DivideByZeroException>();
            //_should_break_the_circuit_after_two_fails
            _thirdException.Should().BeOfType <BrokenCircuitException>();
        }
Esempio n. 10
0
        public async Task When_Monitoring_We_Should_Record_But_Rethrow_Exceptions_Async()
        {
            _exception = await Catch.ExceptionAsync(() => _commandProcessor.SendAsync(_command));

            _controlBusSender.Observe <MonitorEvent>();
            _afterEvent = _controlBusSender.Observe <MonitorEvent>();

            //_should_pass_through_the_exception_not_swallow
            _exception.Should().NotBeNull();
            //_should_monitor_the_exception
            _afterEvent.Exception.Should().BeOfType <Exception>();
            //_should_surface_the_error_message
            _afterEvent.Exception.Message.Should().Contain("monitored");
            //_should_have_an_instance_name_after
            _afterEvent.InstanceName.Should().Be("UnitTests");
            //_should_post_the_handler_fullname_to_the_control_bus_after
            _afterEvent.HandlerFullAssemblyName.Should().Be(typeof(MyMonitoredHandlerThatThrowsAsync).AssemblyQualifiedName);
            //_should_post_the_handler_name_to_the_control_bus_after
            _afterEvent.HandlerName.Should().Be(typeof(MyMonitoredHandlerThatThrowsAsync).FullName);
            //_should_include_the_underlying_request_details_after
            _afterEvent.RequestBody.Should().Be(_originalRequestAsJson);
            //should_post_the_time_of_the_request_after
            _afterEvent.EventTime.AsUtc().Should().BeAfter(_at.AsUtc());
        }
Esempio n. 11
0
 public async Task When_Posting_A_Message_And_There_Is_No_Outbox_Async()
 {
     _exception = await Catch.ExceptionAsync(() => _commandProcessor.PostAsync(_myCommand));
 }
Esempio n. 12
0
        public async void When_There_Is_No_Message_In_The_Sql_Inbox()
        {
            var exception = await Catch.ExceptionAsync(() => _dynamoDbInbox.GetAsync <MyCommand>(Guid.NewGuid(), "some key"));

            exception.Should().BeOfType <RequestNotFoundException <MyCommand> >();
        }
Esempio n. 13
0
            public async Task non_throwing_action_should_return_null()
            {
                var exception = await Catch.ExceptionAsync(() => new AsyncStub().NonThrowAsync());

                exception.ShouldBe(null);
            }
Esempio n. 14
0
            public async Task throwing_action_should_return_same_exception()
            {
                var exception = await Catch.ExceptionAsync(() => new AsyncStub().ThrowAsync());

                exception.ShouldBeOfType <InvalidOperationException>();
            }