public void Should_call_the_message_handler_again() { var responded = new FutureMessage <Message <string> >(); LocalBus.Endpoint.SendRequest(new Message <int> { Body = 27 }, LocalBus, x => { x.Handle <Message <string> >(responded.Set); }); responded.IsAvailable(8.Seconds()).ShouldBeTrue(); responded.Message.Body.ShouldEqual("27"); responded = new FutureMessage <Message <string> >(); LocalBus.Endpoint.SendRequest(new Message <int> { Body = 69 }, LocalBus, x => { x.Handle <Message <string> >(responded.Set); }); responded.IsAvailable(8.Seconds()).ShouldBeTrue(); responded.Message.Body.ShouldEqual("69"); }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _future = new FutureMessage<PingMessage, Guid>(_ping.CorrelationId); _unsubscribe = RemoteBus.SubscribeHandler<PingMessage>(message => { _future.Set(message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); //LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); Trace.WriteLine("LocalBus"); LocalBus.OutboundPipeline.Trace(); Trace.WriteLine("RemoteBus"); RemoteBus.OutboundPipeline.Trace(); LocalBus.Publish(_ping); }
public void A_response_should_be_published_if_no_reply_address_is_specified() { PingMessage ping = new PingMessage(); TestMessageConsumer<PongMessage> otherConsumer = new TestMessageConsumer<PongMessage>(); RemoteBus.Subscribe(otherConsumer); TestCorrelatedConsumer<PongMessage, Guid> consumer = new TestCorrelatedConsumer<PongMessage, Guid>(ping.CorrelationId); LocalBus.Subscribe(consumer); FutureMessage<PongMessage> pong = new FutureMessage<PongMessage>(); RemoteBus.Subscribe<PingMessage>(message => { pong.Set(new PongMessage(message.CorrelationId)); CurrentMessage.Respond(pong.Message); }); LocalBus.Publish(ping); Assert.IsTrue(pong.IsAvailable(3.Seconds()), "No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 3.Seconds()); otherConsumer.ShouldHaveReceivedMessage(pong.Message, 1.Seconds()); }
public void Should_support_send_as_well() { var pongReceived = new FutureMessage<PongMessage>(); var pingReceived = new FutureMessage<PingMessage>(); RemoteBus.SubscribeContextHandler<PingMessage>(x => { pingReceived.Set(x.Message); x.Respond(new PongMessage {TransactionId = x.Message.TransactionId}); }); LocalBus.ShouldHaveSubscriptionFor<PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 8.Seconds(); RemoteBus.Endpoint.SendRequest(ping, LocalBus, x => { x.Handle<PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
protected override void EstablishContext() { base.EstablishContext(); _faultFuture = new FutureMessage <Fault <PingMessage, Guid> >(); LocalBus.SubscribeHandler <PingMessage>(message => { using (new TransactionScope()) { } }); LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message => { if (_faultFuture.IsAvailable(TimeSpan.Zero)) { return; } _faultFuture.Set(message); }); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <Fault <PingMessage, Guid> >(); _ping = new PingMessage(); LocalBus.Publish(_ping); }
public void A_clean_method_of_a_request_reply_should_be_possible() { var ponged = new FutureMessage<PongMessage>(); RemoteBus.SubscribeHandler<PingMessage>(x => { // timing issue here it seems, but that's what Respond() is for, to RESPOND to messages // and not publish responses RemoteBus.ShouldHaveSubscriptionFor<PongMessage>(); RemoteBus.Publish(new PongMessage(x.CorrelationId)); }); LocalBus.ShouldHaveSubscriptionFor<PingMessage>(); var ping = new PingMessage(); LocalBus.PublishRequest(ping, x => { x.Handle<PongMessage>(message => { message.CorrelationId.ShouldEqual(ping.CorrelationId); ponged.Set(message); }); x.HandleTimeout(8.Seconds(), () => { }); }); ponged.IsAvailable(8.Seconds()).ShouldBeTrue("No ping response received"); }
public void Should_ignore_a_response_that_was_not_for_us() { var pongReceived = new FutureMessage<PongMessage>(); var pingReceived = new FutureMessage<PingMessage>(); var badResponse = new FutureMessage<PongMessage>(); LocalBus.SubscribeHandler<PongMessage>(pongReceived.Set); RemoteBus.SubscribeContextHandler<PingMessage>(x => { pingReceived.Set(x.Message); RemoteBus.Publish(new PongMessage {TransactionId = x.Message.TransactionId}); }); LocalBus.ShouldHaveSubscriptionFor<PingMessage>(); var ping = new PingMessage(); TimeSpan timeout = 8.Seconds(); Assert.Throws<RequestTimeoutException>(() => { RemoteBus.Endpoint.SendRequest(ping, LocalBus, x => { x.Handle<PongMessage>(badResponse.Set); x.SetTimeout(timeout); }); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); badResponse.IsAvailable(2.Seconds()).ShouldBeFalse("Should not have received a response"); }
public void Adding_many_dynamic_and_removing_should_retain_dynamics() { var dynamicA = new FutureMessage <A>(); var dynamicB = new FutureMessage <B>(); var dynamicC = new FutureMessage <C>(); var dynamicD = new FutureMessage <D>(); UnsubscribeAction subscriptionA = RemoteBus.SubscribeHandler <A>(dynamicA.Set); UnsubscribeAction subscriptionB = RemoteBus.SubscribeHandler <B>(dynamicB.Set); UnsubscribeAction subscriptionC = RemoteBus.SubscribeHandler <C>(dynamicC.Set); UnsubscribeAction subscriptionD = RemoteBus.SubscribeHandler <D>(dynamicD.Set); LocalBus.HasSubscription <D>(8.Seconds()).Any().ShouldBeTrue("No D subscription"); try { subscriptionA().ShouldBeFalse("A static not remaining"); subscriptionB().ShouldBeFalse("B static not remaining"); subscriptionC().ShouldBeFalse("C static not remaining"); LocalBus.Publish(new A()); LocalBus.Publish(new B()); LocalBus.Publish(new C()); LocalBus.Publish(new D()); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("A not received"); _receivedB.IsAvailable(8.Seconds()).ShouldBeTrue("B not received"); _receivedC.IsAvailable(8.Seconds()).ShouldBeTrue("C not received"); dynamicD.IsAvailable(8.Seconds()).ShouldBeTrue("D should have been received"); } finally { subscriptionD(); } }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _future = new FutureMessage <PingMessage, Guid>(_ping.CorrelationId); _unsubscribe = RemoteBus.SubscribeHandler <PingMessage>(message => { _future.Set(message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); Trace.WriteLine("LocalBus"); LocalBus.OutboundPipeline.Trace(); Trace.WriteLine("RemoteBus"); RemoteBus.OutboundPipeline.Trace(); LocalBus.Publish(_ping); }
public void The_retry_count_should_be_set_on_the_message() { var future = new FutureMessage<PingMessage>(); bool first = true; LocalBus.SubscribeHandler<PingMessage>(message => { if (first) { Assert.AreEqual(0, LocalBus.Context().RetryCount); LocalBus.MessageContext<PingMessage>().RetryLater(); first = false; } else { Assert.AreEqual(1, LocalBus.Context().RetryCount); future.Set(message); } }); LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); LocalBus.Publish(new PingMessage()); Assert.IsTrue(future.IsAvailable(20.Seconds())); }
public void A_response_should_be_published_if_no_reply_address_is_specified() { var ping = new PingMessage(); var otherConsumer = new TestMessageConsumer<PongMessage>(); RemoteBus.SubscribeInstance(otherConsumer); var consumer = new TestCorrelatedConsumer<PongMessage, Guid>(ping.CorrelationId); LocalBus.SubscribeInstance(consumer); var pong = new FutureMessage<PongMessage>(); RemoteBus.SubscribeHandler<PingMessage>(message => { pong.Set(new PongMessage(message.CorrelationId)); RemoteBus.Context().Respond(pong.Message); }); LocalBus.Publish(ping); pong.IsAvailable(8.Seconds()).ShouldBeTrue("No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds()); otherConsumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds()); }
public void Should_support_the_asynchronous_programming_model() { var pongReceived = new FutureMessage<PongMessage>(); var pingReceived = new FutureMessage<PingMessage>(); var callbackCalled = new FutureMessage<IAsyncResult>(); RemoteBus.SubscribeHandler<PingMessage>(x => { pingReceived.Set(x); RemoteBus.MessageContext<PingMessage>().Respond(new PongMessage(x.CorrelationId)); }); var ping = new PingMessage(); var timeout = 8.Seconds(); LocalBus.BeginPublishRequest(ping, callbackCalled.Set, null, x => { x.Handle<PongMessage>(message => { message.CorrelationId.ShouldEqual(ping.CorrelationId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); callbackCalled.IsAvailable(timeout).ShouldBeTrue("The callback was not called"); LocalBus.EndRequest(callbackCalled.Message); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
public void Should_use_a_clean_syntax_following_standard_conventions() { var pongReceived = new FutureMessage<PongMessage>(); var pingReceived = new FutureMessage<PingMessage>(); RemoteBus.SubscribeHandler<PingMessage>(x => { pingReceived.Set(x); RemoteBus.MessageContext<PingMessage>().Respond(new PongMessage(x.CorrelationId)); }); var ping = new PingMessage(); var timeout = 8.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle<PongMessage>(message => { message.CorrelationId.ShouldEqual(ping.CorrelationId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
public void Adding_many_dynamic_and_removing_should_retain_dynamics() { var dynamicA = new FutureMessage<A>(); var dynamicB = new FutureMessage<B>(); var dynamicC = new FutureMessage<C>(); var dynamicD = new FutureMessage<D>(); UnsubscribeAction subscriptionA = RemoteBus.SubscribeHandler<A>(dynamicA.Set); UnsubscribeAction subscriptionB = RemoteBus.SubscribeHandler<B>(dynamicB.Set); UnsubscribeAction subscriptionC = RemoteBus.SubscribeHandler<C>(dynamicC.Set); UnsubscribeAction subscriptionD = RemoteBus.SubscribeHandler<D>(dynamicD.Set); LocalBus.HasSubscription<D>(8.Seconds()).Any().ShouldBeTrue("No D subscription"); try { subscriptionA().ShouldBeFalse("A static not remaining"); subscriptionB().ShouldBeFalse("B static not remaining"); subscriptionC().ShouldBeFalse("C static not remaining"); LocalBus.Publish(new A()); LocalBus.Publish(new B()); LocalBus.Publish(new C()); LocalBus.Publish(new D()); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("A not received"); _receivedB.IsAvailable(8.Seconds()).ShouldBeTrue("B not received"); _receivedC.IsAvailable(8.Seconds()).ShouldBeTrue("C not received"); dynamicD.IsAvailable(8.Seconds()).ShouldBeTrue("D should have been received"); } finally { subscriptionD(); } }
public void A_consumer_is_being_tested() { _test = TestFactory.ForHandler<InputMessage>() .New(x => { x.Handler((bus,message) => { bus.MessageContext<InputMessage>().Respond(new OutputMessage()); }); x.Send(new InputMessage(), c => c.SendResponseTo(_test.Scenario.Bus)); x.Send(new InputMessage(), c => c.SendResponseTo(_test.Scenario.Bus)); }); _test.Execute(); _test.Received.Any<InputMessage>().ShouldBeTrue(); _test.Sent.Any<OutputMessage>().ShouldBeTrue(); _future = new FutureMessage<ReceivedMessageTraceList>(); _test.Scenario.Bus.GetMessageTrace(_test.Scenario.Bus.ControlBus.Endpoint, _future.Set); _future.IsAvailable(8.Seconds()).ShouldBeTrue(); _list = _future.Message; }
public void Should_allow_publish_request_with_custom_headers() { var pongReceived = new FutureMessage<PongMessage>(); var pingReceived = new FutureMessage<PingMessage>(); RemoteBus.SubscribeContextHandler<PingMessage>(x => { pingReceived.Set(x.Message); var transactionIdFromHeader = new Guid(x.Headers["PingTransactionId"]); x.Respond(new PongMessage { TransactionId = transactionIdFromHeader }); }); LocalBus.ShouldHaveSubscriptionFor<PingMessage>(); var ping = new PingMessage { TransactionId = Guid.NewGuid() }; TimeSpan timeout = 8.Seconds(); LocalBus.PublishRequest(ping, x => { x.Handle<PongMessage>(message => { message.TransactionId.ShouldEqual(ping.TransactionId, "The response correlationId did not match"); pongReceived.Set(message); }); x.SetTimeout(timeout); }, ctx => { ctx.SetHeader("PingTransactionId", ping.TransactionId.ToString()); }); pingReceived.IsAvailable(timeout).ShouldBeTrue("The ping was not received"); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); }
public void A_response_should_be_sent_directly_if_a_reply_address_is_specified() { var ping = new PingMessage(); var otherConsumer = new TestMessageConsumer<PongMessage>(); RemoteBus.SubscribeInstance(otherConsumer); var consumer = new TestCorrelatedConsumer<PongMessage, Guid>(ping.CorrelationId); LocalBus.SubscribeInstance(consumer); var pong = new FutureMessage<PongMessage>(); RemoteBus.SubscribeHandler<PingMessage>(message => { pong.Set(new PongMessage(message.CorrelationId)); RemoteBus.Context().Respond(pong.Message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor<PongMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor<PongMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus)); Assert.IsTrue(pong.IsAvailable(8.Seconds()), "No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 8.Seconds()); otherConsumer.ShouldNotHaveReceivedMessage(pong.Message, 1.Seconds()); }
public void The_retry_count_should_be_set_on_the_message() { FutureMessage<PingMessage> future = new FutureMessage<PingMessage>(); bool first = true; LocalBus.Subscribe<PingMessage>(message => { if(first) { Assert.AreEqual(0, CurrentMessage.Headers.RetryCount); CurrentMessage.RetryLater(); first = false; } else { Assert.AreEqual(1, CurrentMessage.Headers.RetryCount); future.Set(message); } }); LocalBus.Publish(new PingMessage()); Assert.IsTrue(future.IsAvailable(5.Seconds())); }
private void OnFutureMessage(FutureMessage evt) { var node = new FutureMessageNode(evt.Id, evt.Message, evt.ActorRef); if (this._map.TryAdd(evt.Id, node)) { this._queue.Enqueue(node, evt.FireTime); } }
protected override void EstablishContext() { base.EstablishContext(); _faultFuture = new FutureMessage<Fault<PingMessage, Guid>>(); LocalBus.Subscribe<PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); }); LocalBus.Subscribe<Fault<PingMessage, Guid>>(message => _faultFuture.Set(message)); _ping = new PingMessage(); LocalBus.Publish(_ping); }
private void MakeSagaDown() { MakeSagaSuspect(); var fm = new FutureMessage<TimeoutExpired>(); RemoteBus.Subscribe<TimeoutExpired>(fm.Set); Thread.Sleep(500); LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 2}); fm.IsAvailable(1.Seconds()).ShouldBeTrue(); var saga = Repository.Where(x => x.CorrelationId == _id).First(); saga.CurrentState.ShouldEqual(HealthSaga.Down, "MakeSagaDown failed"); }
protected override void EstablishContext() { base.EstablishContext(); _future = new FutureMessage<PingMessage>(); LocalBus.Subscribe<PingMessage>(message => _future.Set(message)); _ping = new PingMessage(); LocalBus.Publish(_ping); }
protected override void EstablishContext() { base.EstablishContext(); _future = new FutureMessage <PingMessage>(); LocalBus.SubscribeHandler <PingMessage>(message => _future.Set(message)); _ping = new PingMessage(); LocalBus.Publish(_ping); }
protected override void EstablishContext() { base.EstablishContext(); _faultFuture = new FutureMessage <Fault <PingMessage, Guid> >(); LocalBus.Subscribe <PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); }); LocalBus.Subscribe <Fault <PingMessage, Guid> >(message => _faultFuture.Set(message)); _ping = new PingMessage(); LocalBus.Publish(_ping); }
public void Dynamic_should_receive_the_message() { var receivedDynamic = new FutureMessage<A>(); UnsubscribeAction subscription = RemoteBus.SubscribeHandler<A>(receivedDynamic.Set); using (subscription.Disposable()) { LocalBus.Publish(new A()); receivedDynamic.IsAvailable(8.Seconds()).ShouldBeTrue("Dynamic not received"); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received"); } }
public void MakeSagaSuspect() { LocalBus.Publish(new EndpointCameOnline(_id, LocalBus.ControlBus.Endpoint.Uri,LocalBus.Endpoint.Uri, 0)); var fm = new FutureMessage<TimeoutExpired>(); RemoteBus.Subscribe<TimeoutExpired>(fm.Set); Thread.Sleep(5000); LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 1}); fm.IsAvailable(5.Seconds()).ShouldBeTrue(); var saga = Repository.Where(x => x.CorrelationId == _id).FirstOrDefault(); saga.ShouldNotBeNull(); saga.CurrentState.ShouldEqual(HealthSaga.Suspect, "MakeSagaSuspect failed"); }
public void Should_Parse_FutureMessage_Culture_Independent(string cultureName) { // Arrange TestHelper.SetThreadCulture(cultureName); var message = "@ESU18,@ESZ18,@ESH19,@ESM19,@ESU19,"; // Act var futureMessageParsed = FutureMessage.Parse(message); var futureMessage = new Future("@ESU18", "@ES", new DateTime(2018, 09, 01)); // Assert Assert.AreEqual(futureMessageParsed.Chains.First(), futureMessage); }
public void Configuring_a_service_bus_easily() { FutureMessage<PingMessage> received; using (IServiceBus bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/queue"); })) { received = new FutureMessage<PingMessage>(); bus.SubscribeHandler<PingMessage>(received.Set); bus.Publish(new PingMessage()); received.IsAvailable(8.Seconds()).ShouldBeTrue(); } }
public void Configuring_a_service_bus_easily() { using (var bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/queue"); })) { var received = new FutureMessage <PingMessage>(); bus.SubscribeHandler <PingMessage>(received.Set); bus.Publish(new PingMessage()); received.IsAvailable(8.Seconds()).ShouldBeTrue(); } }
public void Subscring_to_an_endpoint_should_accept_and_dispatch_messages() { FutureMessage<PingMessage> fm=new FutureMessage<PingMessage>(); bool workDid = false; LocalBus.Subscribe<PingMessage>( (msg)=> {workDid = true; fm.Set(msg); }, delegate { return true; }); RemoteBus.Publish(_message); fm.IsAvailable(1.Seconds()); Assert.That(workDid, Is.True, "Lazy Test!"); }
public void Dynamic_should_receive_the_message() { var receivedDynamic = new FutureMessage <A>(); UnsubscribeAction subscription = RemoteBus.SubscribeHandler <A>(receivedDynamic.Set); using (subscription.Disposable()) { LocalBus.Publish(new A()); receivedDynamic.IsAvailable(8.Seconds()).ShouldBeTrue("Dynamic not received"); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received"); } }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _future = new FutureMessage<PingMessage, Guid>(_ping.CorrelationId); RemoteBus.SubscribeHandler<PingMessage>(message => { _future.Set(message); }); LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); LocalBus.Publish(_ping); }
public void If_a_saga_is_suspect_a_pingtimeout_should_make_it_down() { MakeSagaSuspect(); var fm = new FutureMessage<TimeoutExpired>(); RemoteBus.Subscribe<TimeoutExpired>(fm.Set); Thread.Sleep(250); LocalBus.Publish(new TimeoutExpired {CorrelationId = _id, Tag = 2}); fm.IsAvailable(100.Seconds()).ShouldBeTrue("never got message"); Thread.Sleep(100000); var saga = Repository.Where(x => x.CorrelationId == _id).First(); saga.CurrentState.ShouldEqual(HealthSaga.Down); }
public void The_destination_address_should_pass() { FutureMessage<PingMessage> received = new FutureMessage<PingMessage>(); LocalBus.Subscribe<PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.DestinationAddress); received.Set(message); }); LocalBus.Publish(new PingMessage()); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
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"); }
public void Static_should_remain_after_dynamic_removed() { var receivedDynamic = new FutureMessage<A>(); UnsubscribeAction subscription = RemoteBus.SubscribeHandler<A>(receivedDynamic.Set); var result = subscription(); result.ShouldBeFalse("Should still have a static subscription"); LocalBus.Publish(new A()); receivedDynamic.IsAvailable(8.Seconds()).ShouldBeFalse("Dynamic should not have received"); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received"); }
public void Static_should_remain_after_dynamic_removed() { var receivedDynamic = new FutureMessage <A>(); UnsubscribeAction subscription = RemoteBus.SubscribeHandler <A>(receivedDynamic.Set); var result = subscription(); result.ShouldBeFalse("Should still have a static subscription"); LocalBus.Publish(new A()); receivedDynamic.IsAvailable(8.Seconds()).ShouldBeFalse("Dynamic should not have received"); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("Static not received"); }
public void Should_request_an_instance_of_the_consumer_for_each_message() { var called = new FutureMessage<PingMessage>(); var ping = new PingMessage(); var getter = MockRepository.GenerateMock<HandlerSelector<PingMessage>>(); getter.Expect(x => x(null)).IgnoreArguments().Return(x => called.Set(x.Message)); LocalBus.SubscribeHandlerSelector(getter); LocalBus.Publish(ping); called.IsAvailable(3.Seconds()).ShouldBeTrue(); }
private void MakeSagaDown() { MakeSagaSuspect(); var fm = new FutureMessage <TimeoutExpired>(); RemoteBus.Subscribe <TimeoutExpired>(fm.Set); Thread.Sleep(500); LocalBus.Publish(new TimeoutExpired { CorrelationId = _id, Tag = 2 }); fm.IsAvailable(1.Seconds()).ShouldBeTrue(); var saga = Repository.Where(x => x.CorrelationId == _id).First(); saga.CurrentState.ShouldEqual(HealthSaga.Down, "MakeSagaDown failed"); }
public void The_message_type_should_be_properly_set_on_the_message_envelope() { PingMessage ping = new PingMessage(); FutureMessage <PingMessage> received = new FutureMessage <PingMessage>(); RemoteBus.Subscribe <PingMessage>(message => { Assert.AreEqual(typeof(PingMessage).ToMessageName(), CurrentMessage.Headers.MessageType); received.Set(message); }); LocalBus.Publish(ping); Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message"); }
public void MakeSagaSuspect() { LocalBus.Publish(new EndpointCameOnline(_id, LocalBus.ControlBus.Endpoint.Uri, LocalBus.Endpoint.Uri, 0)); var fm = new FutureMessage <TimeoutExpired>(); RemoteBus.Subscribe <TimeoutExpired>(fm.Set); Thread.Sleep(5000); LocalBus.Publish(new TimeoutExpired { CorrelationId = _id, Tag = 1 }); fm.IsAvailable(5.Seconds()).ShouldBeTrue(); var saga = Repository.Where(x => x.CorrelationId == _id).FirstOrDefault(); saga.ShouldNotBeNull(); saga.CurrentState.ShouldEqual(HealthSaga.Suspect, "MakeSagaSuspect failed"); }
public void The_message_type_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(typeof(PingMessage).ToMessageName(), LocalBus.Context().MessageType); received.Set(message); }); LocalBus.Publish(ping); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void The_fault_address_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Address.Uri, LocalBus.Context().FaultAddress); received.Set(message); }); LocalBus.Publish(ping, context => context.SendFaultTo(LocalBus.Endpoint.Address.Uri)); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void The_response_address_should_be_properly_set_on_the_message_envelope() { PingMessage ping = new PingMessage(); FutureMessage <PingMessage> received = new FutureMessage <PingMessage>(); RemoteBus.Subscribe <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.ResponseAddress); received.Set(message); }); LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus.Endpoint.Uri)); Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message"); }
public void If_a_saga_is_suspect_a_pingtimeout_should_make_it_down() { MakeSagaSuspect(); var fm = new FutureMessage <TimeoutExpired>(); RemoteBus.Subscribe <TimeoutExpired>(fm.Set); Thread.Sleep(250); LocalBus.Publish(new TimeoutExpired { CorrelationId = _id, Tag = 2 }); fm.IsAvailable(100.Seconds()).ShouldBeTrue("never got message"); Thread.Sleep(100000); var saga = Repository.Where(x => x.CorrelationId == _id).First(); saga.CurrentState.ShouldEqual(HealthSaga.Down); }
public void The_destination_address_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(RemoteBus.Endpoint.Address.Uri, LocalBus.Context().DestinationAddress); received.Set(message); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(ping); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void It_should_leave_the_message_in_the_queue_if_an_exception_is_thrown() { FutureMessage <PingMessage> future = new FutureMessage <PingMessage>(); RemoteBus.Subscribe <PingMessage>(m => { future.Set(m); throw new ApplicationException("Boing!"); }); var message = new PingMessage(); LocalBus.Publish(message); future.IsAvailable(_timeout).ShouldBeTrue("Message was not received"); RemoteEndpoint.ShouldNotContain(message); }
public void ShouldNotReTryCookFoodMessage() { var publisherMock = new Mock <IPublisher>(); FutureMessage msg = null; publisherMock.Setup(x => x.Publish(It.IsAny <FutureMessage>())) .Callback <FutureMessage>(r => msg = r); var regularMidget = new RegularMidget(publisherMock.Object); var msgToDeliver = new CookFood(new Order(), "cu"); regularMidget.Handle(new OrderCooked(new Order(), string.Empty)); regularMidget.Handle(new FutureMessage(msgToDeliver, DateTime.MaxValue)); publisherMock.Verify(p => p.Publish(It.IsAny <FutureMessage>()), Times.Never); publisherMock.Verify(p => p.Publish(It.IsAny <CookFood>()), Times.Never); publisherMock.Verify(p => p.Publish(It.IsAny <PriceOrdered>())); }
public void The_timeout_should_be_added_to_the_storage() { var timedOut = new FutureMessage <TimeoutExpired>(); LocalBus.SubscribeHandler <TimeoutExpired>(timedOut.Set); LocalBus.HasSubscription <TimeoutExpired>(8.Seconds()).Any() .ShouldBeTrue("No subscription"); LocalBus.Publish(new ScheduleTimeout(_correlationId, 2.Seconds())); Stopwatch watch = Stopwatch.StartNew(); timedOut.IsAvailable(8.Seconds()).ShouldBeTrue("Did not get timeout message"); watch.Stop(); Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds)); }
public void A_clean_method_of_a_request_reply_should_be_possible() { FutureMessage<PongMessage> ponged = new FutureMessage<PongMessage>(); LocalBus.SubscribeHandler<PingMessage>(x => LocalBus.Publish(new PongMessage(x.CorrelationId))); PingMessage ping = new PingMessage(); LocalBus.MakeRequest(bus => bus.Publish(ping, context => context.SendResponseTo(bus))) .When<PongMessage>().RelatedTo(ping.CorrelationId).IsReceived(pong => { Assert.AreEqual(ping.CorrelationId, pong.CorrelationId); ponged.Set(pong); }) .TimeoutAfter(5.Seconds()) .Send(); Assert.IsTrue(ponged.IsAvailable(1.Seconds()), "No response received"); }
public void The_retry_count_should_be_properly_set_on_the_message_envelope() { PingMessage ping = new PingMessage(); FutureMessage <PingMessage> received = new FutureMessage <PingMessage>(); var retryCount = 69; RemoteBus.Subscribe <PingMessage>(message => { Assert.AreEqual(retryCount, CurrentMessage.Headers.RetryCount); received.Set(message); }); LocalBus.Publish(ping, context => context.SetRetryCount(retryCount)); Assert.IsTrue(received.IsAvailable(3.Seconds()), "Timeout waiting for message"); }
public void The_timeout_should_be_added_to_the_storage() { var timedOut = new FutureMessage<TimeoutExpired>(); LocalBus.SubscribeHandler<TimeoutExpired>(timedOut.Set); LocalBus.HasSubscription<TimeoutExpired>(8.Seconds()).Any() .ShouldBeTrue("No subscription"); LocalBus.Publish(new ScheduleTimeout(_correlationId, 2.Seconds())); Stopwatch watch = Stopwatch.StartNew(); timedOut.IsAvailable(8.Seconds()).ShouldBeTrue("Did not get timeout message"); watch.Stop(); Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds)); }
public void The_retry_count_should_be_properly_set_on_the_message_envelope() { var ping = new PingMessage(); var received = new FutureMessage <PingMessage>(); int retryCount = 69; RemoteBus.SubscribeHandler <PingMessage>(message => { Assert.AreEqual(retryCount, LocalBus.Context().RetryCount); received.Set(message); }); LocalBus.ShouldHaveSubscriptionFor <PingMessage>(); LocalBus.Publish(ping, context => context.SetRetryCount(retryCount)); Assert.IsTrue(received.IsAvailable(10.Seconds()), "Timeout waiting for message"); }
public void Should_do_something_nicely() { var ding = new PingMessage(); var future = new FutureMessage<PingMessage>(); var bus = MockRepository.GenerateMock<IServiceBus>(); bus.Stub(x => x.Publish<PingMessage>(null)).Callback<PingMessage>(message => { if(message != ding ) Assert.Fail("Bugger me"); future.Set(message); return true; }); bus.Publish(ding); future.IsAvailable(TimeSpan.Zero).ShouldBeTrue(); }
public void ShouldReTryCookFoodMessage() { var publisherMock = new Mock <IPublisher>(); FutureMessage msg = null; publisherMock.Setup(x => x.Publish(It.IsAny <FutureMessage>())) .Callback <FutureMessage>(r => msg = r); var regularMidget = new RegularMidget(publisherMock.Object); var msgToDeliver = new CookFood(new Order(), "cu"); regularMidget.Handle(new FutureMessage(msgToDeliver, DateTime.MaxValue)); publisherMock.Verify(p => p.Publish(It.IsAny <FutureMessage>())); publisherMock.Verify(p => p.Publish(It.IsAny <CookFood>())); msg.MessageToDeliver.MessageId .ShouldEqual(msgToDeliver.MessageId); }
public void Should_work_through_the_saga() { var response = new FutureMessage <OrderDetailsReceived>(); const string orderId = "ABC123"; const string customerId = "12345"; LocalBus.Subscribe <OrderDetailsReceived>(message => { response.Set(message); }, x => x.OrderId == orderId && x.CustomerId == customerId); RetrieveOrderDetails request = new RetrieveOrderDetailsRequest(customerId, orderId); LocalBus.Publish(request, x => x.SendResponseTo(LocalBus.Endpoint)); Assert.IsTrue(response.WaitUntilAvailable(555.Seconds()), "The response was not received"); Assert.AreEqual(orderId, response.Message.OrderId); Assert.AreEqual(customerId, response.Message.CustomerId); }
public void Should_return_the_matching_details_for_the_order() { var response = new FutureMessage <OrderDetailsResponse>(); LocalBus.Subscribe <OrderDetailsResponse>(response.Set); const string orderId = "ABC123"; const string customerId = "12345"; var request = new SendOrderDetailsRequest { RequestId = CombGuid.Generate(), CustomerId = customerId, OrderId = orderId, }; LocalBus.Publish(request, x => x.SendResponseTo(LocalBus.Endpoint)); Assert.IsTrue(response.WaitUntilAvailable(5.Seconds()), "The response was not received"); Assert.AreEqual(orderId, response.Message.OrderId); Assert.AreEqual(customerId, response.Message.CustomerId); }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _faultFuture = new FutureMessage <Fault <PingMessage, Guid> >(); _future = new FutureMessage <PingMessage, Guid>(_ping.CorrelationId); LocalBus.SubscribeHandler <PingMessage>(message => { _future.Set(message); throw new NotSupportedException("I am a naughty consumer! I go boom!"); }); LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message => _faultFuture.Set(message)); LocalBus.Publish(_ping); _future.WaitUntilAvailable(1.Seconds()); }
public void A_consumer_is_being_tested() { _test = TestFactory.ForHandler <InputMessage>() .New(x => { x.Handler((context, message) => context.Respond(new OutputMessage())); x.Send(new InputMessage(), (scenario, context) => context.SendResponseTo(scenario.Bus)); x.Send(new InputMessage(), (scenario, context) => context.SendResponseTo(scenario.Bus)); }); _test.Execute(); _test.Received.Any <InputMessage>().ShouldBeTrue(); _test.Sent.Any <OutputMessage>().ShouldBeTrue(); _future = new FutureMessage <ReceivedMessageTraceList>(); _test.Scenario.Bus.GetMessageTrace(_test.Scenario.Bus.ControlBus.Endpoint, _future.Set); _future.IsAvailable(8.Seconds()).ShouldBeTrue(); _list = _future.Message; }
protected override void EstablishContext() { base.EstablishContext(); _faultFuture = new FutureMessage <Fault <PingMessage, Guid> >(); LocalBus.SubscribeHandler <PingMessage>(message => { throw new NotSupportedException("I am a naughty consumer! I go boom!"); }); LocalBus.SubscribeHandler <Fault <PingMessage, Guid> >(message => { if (_faultFuture.IsAvailable(TimeSpan.Zero)) { return; } _faultFuture.Set(message); }); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <Fault <PingMessage, Guid> >(); _ping = new PingMessage(); LocalBus.Publish(_ping); }