Beispiel #1
0
        public void Many_publish_request_should_work()
        {
            const int repeatCount = 5000;

            LocalBus.SubscribeHandler <PingMessage>(x => LocalBus.Context().Respond(new PongMessage()));

            ManualResetEvent completed = new ManualResetEvent(false);
            int responsesReceived      = 0;

            Stopwatch stopwatch = Stopwatch.StartNew();

            for (int i = 0; i < repeatCount; i++)
            {
                LocalBus.PublishRequestAsync(new PingMessage(), x =>
                {
                    x.Handle <PongMessage>(message =>
                    {
                        if (Interlocked.Increment(ref responsesReceived) == repeatCount)
                        {
                            completed.Set();
                        }
                    });
                });
            }

            bool success = completed.WaitOne(60.Seconds());

            Assert.IsTrue(success, "The repeat series did not complete");

            Trace.WriteLine(string.Format("Elapsed Time for {0} requests = {1}", repeatCount, stopwatch.Elapsed));
            Trace.WriteLine(string.Format("Requests Per Second = {0}", repeatCount * 1000 / stopwatch.ElapsedMilliseconds));

            Trace.WriteLine(string.Format("Elapsed Time for {0} messages = {1}", repeatCount * 2, stopwatch.Elapsed));
            Trace.WriteLine(string.Format("Messages Per Second = {0}", repeatCount * 2000 / stopwatch.ElapsedMilliseconds));
        }
Beispiel #2
0
        public void Should_not_complete_timeout_if_handler_completes()
        {
            var pongReceived   = new FutureMessage <PongMessage>();
            var continueCalled = new FutureMessage <Task <PongMessage> >();
            var timeoutCalled  = new FutureMessage <PingMessage>();

            TimeSpan timeout = 8.Seconds();

            var ping = new PingMessage();
            ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
            {
                x.HandleTimeout(4.Seconds(), timeoutCalled.Set);

                x.Handle <PongMessage>(pongReceived.Set)
                .ContinueWith(continueCalled.Set);
            });

            pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received");

            request.Task.Wait(timeout).ShouldBeTrue("Task was not completed");

            request.GetResponseTask <PongMessage>().Wait(timeout).ShouldBeTrue("The response task was not completed");

            continueCalled.IsAvailable(timeout).ShouldBeTrue("The continuation was not called");

            timeoutCalled.IsAvailable(2.Seconds()).ShouldBeFalse("The timeout should not have been called");
        }
Beispiel #3
0
        public void Should_call_timeout_callback_if_timeout_occurs()
        {
            var pongCompleted = new FutureMessage <PongMessage>();
            var pongCancelled = new FutureMessage <bool>();

            Task <PongMessage> pongTask;

            var ping = new PingMessage();
            ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
            {
                x.SetTimeout(1.Seconds());

                pongTask = x.Handle <PongMessage>(message => { });
                pongTask.ContinueWith(t => pongCompleted.Set(t.Result), TaskContinuationOptions.OnlyOnRanToCompletion);
                pongTask.ContinueWith((Task t) => pongCancelled.Set(t.IsCanceled), TaskContinuationOptions.OnlyOnCanceled);
            });

            var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds()));

            Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First());

            pongCompleted.IsAvailable(1.Seconds()).ShouldBeFalse("We only asked to be notified on success");

            pongCancelled.IsAvailable(1.Seconds()).ShouldBeTrue("We like to know we were cancelled due to timeout");
        }
Beispiel #4
0
        public void Should_throw_an_exception_from_the_timeout()
        {
            var ping = new PingMessage();
            ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { x.SetTimeout(1.Seconds()); });

            var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds()));

            Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First());
        }
        public void Should_call_timeout_callback_if_timeout_occurs()
        {
            var ping = new Messages.PingMessage();
            ITaskRequest <Messages.PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
            {
                //
                x.SetTimeout(1.Seconds());
            });

            var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds()));

            Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First());
        }
Beispiel #6
0
        public void Should_call_timeout_callback_if_timeout_occurs_and_not_fault()
        {
            var continueCalled = new FutureMessage <PingMessage>();

            var ping = new PingMessage();
            ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x =>
            {
                //
                x.HandleTimeout(1.Seconds(), continueCalled.Set);
            });

            request.Task.Wait(8.Seconds()).ShouldBeTrue("Should have completed successfully");

            continueCalled.IsAvailable(8.Seconds()).ShouldBeTrue("The timeout continuation was not called");
        }