public async Task Should_Call_Handler_AndDispose()
        {
            LocalEventBus.Subscribe <MySimpleEventData, MySimpleTransientEventHandler>();

            await LocalEventBus.PublishAsync(new MySimpleEventData(1));

            await LocalEventBus.PublishAsync(new MySimpleEventData(2));

            await LocalEventBus.PublishAsync(new MySimpleEventData(3));

            Assert.Equal(3, MySimpleTransientEventHandler.HandleCount);
            Assert.Equal(3, MySimpleTransientEventHandler.DisposeCount);
        }
示例#2
0
        public async Task Should_Trigger_For_Inherited_Generic_2()
        {
            var triggeredEvent = false;

            LocalEventBus.Subscribe <EntityChangedEventData <Person> >(
                eventData =>
            {
                eventData.Entity.Id.ShouldBe(42);
                triggeredEvent = true;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new EntityChangedEventData <Student>(new Student(42)));

            triggeredEvent.ShouldBe(true);
        }
        public async Task Should_Throw_Aggregate_Exception_If_More_Than_One_Of_Handlers_Fail()
        {
            LocalEventBus.Subscribe <MySimpleEventData>(
                eventData => throw new Exception("This exception is intentionally thrown #1!"));

            LocalEventBus.Subscribe <MySimpleEventData>(
                eventData => throw new Exception("This exception is intentionally thrown #2!"));

            var aggrException = await Assert.ThrowsAsync <AggregateException>(async() =>
            {
                await LocalEventBus.PublishAsync(new MySimpleEventData(1));
            });

            aggrException.InnerExceptions.Count.ShouldBe(2);
            aggrException.InnerExceptions[0].Message.ShouldBe("This exception is intentionally thrown #1!");
            aggrException.InnerExceptions[1].Message.ShouldBe("This exception is intentionally thrown #2!");
        }
        public async Task Should_Not_Handle_Exception()
        {
            var retryAttempt = 0;

            LocalEventBus.Subscribe <MySimpleEventData>(eventData =>
            {
                retryAttempt++;
                throw new Exception("This exception is intentionally thrown!");
            });

            var appException = await Assert.ThrowsAsync <Exception>(async() =>
            {
                await LocalEventBus.PublishAsync(new MySimpleEventData(1));
            });

            retryAttempt.ShouldBe(1);
            appException.Message.ShouldBe("This exception is intentionally thrown!");
        }
示例#5
0
        public async Task Should_Handle_Exception()
        {
            var retryAttempt = 0;

            LocalEventBus.Subscribe <MyExceptionHandleEventData>(eventData =>
            {
                eventData.Value.ShouldBe(0);
                retryAttempt++;
                if (retryAttempt < 2)
                {
                    throw new Exception("This exception is intentionally thrown!");
                }

                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new MyExceptionHandleEventData(0));

            retryAttempt.ShouldBe(2);
        }
        public async Task Should_Call_Handler_With_Non_Generic_Trigger()
        {
            var totalData = 0;

            LocalEventBus.Subscribe <MySimpleEventData>(
                eventData =>
            {
                totalData += eventData.Value;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(typeof(MySimpleEventData), new MySimpleEventData(1));

            await LocalEventBus.PublishAsync(typeof(MySimpleEventData), new MySimpleEventData(2));

            await LocalEventBus.PublishAsync(typeof(MySimpleEventData), new MySimpleEventData(3));

            await LocalEventBus.PublishAsync(typeof(MySimpleEventData), new MySimpleEventData(4));

            Assert.Equal(10, totalData);
        }
        public async Task Should_Call_Action_On_Event_With_Correct_Source()
        {
            var totalData = 0;

            LocalEventBus.Subscribe <MySimpleEventData>(
                eventData =>
            {
                totalData += eventData.Value;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new MySimpleEventData(1));

            await LocalEventBus.PublishAsync(new MySimpleEventData(2));

            await LocalEventBus.PublishAsync(new MySimpleEventData(3));

            await LocalEventBus.PublishAsync(new MySimpleEventData(4));

            Assert.Equal(10, totalData);
        }
示例#8
0
        public async Task Should_Handle_Events_For_Derived_Classes()
        {
            var totalData = 0;

            LocalEventBus.Subscribe <MySimpleEventData>(
                eventData =>
            {
                totalData += eventData.Value;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new MySimpleEventData(1)).ConfigureAwait(false);  //Should handle directly registered class

            await LocalEventBus.PublishAsync(new MySimpleEventData(2)).ConfigureAwait(false);  //Should handle directly registered class

            await LocalEventBus.PublishAsync(new MyDerivedEventData(3)).ConfigureAwait(false); //Should handle derived class too

            await LocalEventBus.PublishAsync(new MyDerivedEventData(4)).ConfigureAwait(false); //Should handle derived class too

            Assert.Equal(10, totalData);
        }
示例#9
0
        public async Task Should_Not_Handle_Events_For_Base_Classes()
        {
            var totalData = 0;

            LocalEventBus.Subscribe <MyDerivedEventData>(
                eventData =>
            {
                totalData += eventData.Value;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new MySimpleEventData(1)).ConfigureAwait(false);  //Should not handle

            await LocalEventBus.PublishAsync(new MySimpleEventData(2)).ConfigureAwait(false);  //Should not handle

            await LocalEventBus.PublishAsync(new MyDerivedEventData(3)).ConfigureAwait(false); //Should handle

            await LocalEventBus.PublishAsync(new MyDerivedEventData(4)).ConfigureAwait(false); //Should handle

            Assert.Equal(7, totalData);
        }
示例#10
0
        public async Task Should_Throw_Exception_After_Error_Handle()
        {
            var retryAttempt = 0;

            LocalEventBus.Subscribe <MyExceptionHandleEventData>(eventData =>
            {
                eventData.Value.ShouldBe(0);

                retryAttempt++;

                throw new Exception("This exception is intentionally thrown!");
            });

            var appException = await Assert.ThrowsAsync <Exception>(async() =>
            {
                await LocalEventBus.PublishAsync(new MyExceptionHandleEventData(0));
            });

            retryAttempt.ShouldBe(4);
            appException.Message.ShouldBe("This exception is intentionally thrown!");
        }
        public async Task Should_Call_Action_On_Event_With_Correct_Source_Async()
        {
            int totalData = 0;

            LocalEventBus.Subscribe <MySimpleEventData>(
                async eventData =>
            {
                await Task.Delay(20);
                Interlocked.Add(ref totalData, eventData.Value);
                await Task.Delay(20);
            });

            await LocalEventBus.PublishAsync(new MySimpleEventData(1));

            await LocalEventBus.PublishAsync(new MySimpleEventData(2));

            await LocalEventBus.PublishAsync(new MySimpleEventData(3));

            await LocalEventBus.PublishAsync(new MySimpleEventData(4));

            Assert.Equal(10, totalData);
        }
        public async Task Should_Not_Call_Action_After_Unregister_1()
        {
            var totalData = 0;

            var registerDisposer = LocalEventBus.Subscribe <MySimpleEventData>(
                eventData =>
            {
                totalData += eventData.Value;
                return(Task.CompletedTask);
            });

            await LocalEventBus.PublishAsync(new MySimpleEventData(1));

            await LocalEventBus.PublishAsync(new MySimpleEventData(2));

            await LocalEventBus.PublishAsync(new MySimpleEventData(3));

            registerDisposer.Dispose();

            await LocalEventBus.PublishAsync(new MySimpleEventData(4));

            Assert.Equal(6, totalData);
        }