public void The_saga_should_be_subscribable() { var unsubscribeAction = LocalBus.Subscribe <CreateCustomerSaga>(); unsubscribeAction(); }
public void Multiple_Local_Services_Should_Be_Available() { ManualResetEvent _updateEvent = new ManualResetEvent(false); LocalBus.Subscribe <UpdateMessage>(msg => _updateEvent.Set()); ManualResetEvent _deleteEvent = new ManualResetEvent(false); LocalBus.Subscribe <DeleteMessage>( delegate { _deleteEvent.Set(); }); DeleteMessage dm = new DeleteMessage(); LocalBus.Publish(dm); UpdateMessage um = new UpdateMessage(); LocalBus.Publish(um); Assert.That(_deleteEvent.WaitOne(TimeSpan.FromSeconds(4), true), Is.True, "Timeout expired waiting for message"); Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(4), true), Is.True, "Timeout expired waiting for message"); }
public void The_message_should_be_delivered_to_a_remote_subscriber_with_a_reply() { ManualResetEvent _updateEvent = new ManualResetEvent(false); Action <UpdateMessage> handler = msg => { _updateEvent.Set(); RemoteBus.Publish(new UpdateAcceptedMessage()); }; ManualResetEvent _repliedEvent = new ManualResetEvent(false); RemoteBus.Subscribe(handler); LocalBus.Subscribe <UpdateAcceptedMessage>( delegate { _repliedEvent.Set(); }); UpdateMessage um = new UpdateMessage(); LocalBus.Publish(um); Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True, "Timeout expired waiting for message"); Assert.That(_repliedEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True, "NO response message received"); }
protected override void EstablishContext() { base.EstablishContext(); _sagaId = Guid.NewGuid(); _repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder); _initiateSimpleSagaUnsubscribe = MockRepository.GenerateMock <UnsubscribeAction>(); _completeSimpleSagaUnsubscribe = MockRepository.GenerateMock <UnsubscribeAction>(); _subscriptionEvent = MockRepository.GenerateMock <ISubscriptionEvent>(); _subscriptionEvent.Expect(x => x.SubscribedTo <InitiateSimpleSaga>()).Repeat.Any().Return(() => { _initiateSimpleSagaUnsubscribe(); return(true); }); _subscriptionEvent.Expect(x => x.SubscribedTo <CompleteSimpleSaga>()).Repeat.Any().Return(() => { _completeSimpleSagaUnsubscribe(); return(true); }); LocalBus.InboundPipeline.Configure(x => x.Register(_subscriptionEvent)); _remove = LocalBus.Subscribe <SimpleSaga>(); PipelineViewer.Trace(LocalBus.InboundPipeline); }
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())); }
public void A_response_should_be_sent_directly_if_a_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, context => context.SendResponseTo(LocalBus)); Assert.IsTrue(pong.IsAvailable(3.Seconds()), "No pong generated"); consumer.ShouldHaveReceivedMessage(pong.Message, 3.Seconds()); otherConsumer.ShouldNotHaveReceivedMessage(pong.Message, 1.Seconds()); }
public void Perform_a_large_request_response_pool() { const int repeatCount = 20000; int responsesReceived = 0; ManualResetEvent completed = new ManualResetEvent(false); LocalBus.Subscribe <PingMessage>(x => CurrentMessage.Respond(new PongMessage(x.CorrelationId))); LocalBus.Subscribe <PongMessage>(x => { if (Interlocked.Increment(ref responsesReceived) == repeatCount) { completed.Set(); } }); Thread.Sleep(3.Seconds()); Stopwatch stopwatch = Stopwatch.StartNew(); for (int index = 0; index < repeatCount; index++) { LocalBus.Publish(new PingMessage()); } bool success = completed.WaitOne(60.Seconds(), true); stopwatch.Stop(); 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)); }
public void A_message_should_only_reach_the_consumer_if_the_filter_passes_it_forward() { MessageFilter <RequestMessage> filter = new MessageFilter <RequestMessage>(delegate { return(false); }, _consumer); LocalBus.Subscribe(filter); RemoteBus.Publish(_message); Assert.That(_passed.WaitOne(TimeSpan.FromSeconds(1), true), Is.False, "Timeout waiting for message handler to be called"); }
protected override void EstablishContext() { base.EstablishContext(); ObjectBuilder .Stub(x => x.GetInstance <OrderDetailsWebServiceProxy>()) .Return(new OrderDetailsWebServiceProxy()); LocalBus.Subscribe <OrderDetailsWebServiceProxy>(); }
protected override void EstablishContext() { base.EstablishContext(); _sagaId = Guid.NewGuid(); _repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder); LocalBus.Subscribe <SimpleSaga>(); }
public void A_simple_saga_exists_and_is_waiting_for_approval() { LocalBus.Subscribe <SimpleSaga>(); AddExistingSaga(SagaId, x => { x.CustomerId = CustomerId; x.SetCurrentState(SimpleSaga.WaitingForApproval); }); }
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(); _sagaId = Guid.NewGuid(); _repository = SetupSagaRepository <SimpleSaga>(ObjectBuilder); _remove = LocalBus.Subscribe <SimpleSaga>(); PipelineViewer.Trace(LocalBus.InboundPipeline); }
public void It_should_be_received_by_one_subscribed_consumer_on_the_same_bus() { var consumer = new TestMessageConsumer <PingMessage>(); LocalBus.Subscribe(consumer); var message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, _timeout); }
public void A_simple_bus_should_be_able_to_subscribe_and_publish() { TestMessageConsumer <PingMessage> consumer = new TestMessageConsumer <PingMessage>(); LocalBus.Subscribe(consumer); PingMessage message = new PingMessage(); LocalBus.Publish(message); consumer.ShouldHaveReceivedMessage(message, 500.Milliseconds()); }
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 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 A_consumer_object_should_receive_the_message() { FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>(); PingHandler handler = new PingHandler(fm); LocalBus.Subscribe(handler); int old = PingHandler.Pinged; RemoteBus.Publish(new PingMessage()); fm.IsAvailable(1.Seconds()); Assert.That(PingHandler.Pinged, Is.GreaterThan(old)); }
public void Should_properly_register_the_consumers_for_each_endpoint() { var firstSub = new FirstSybsystem(); var secondSub = new SecondSubsystem(); LocalBus.Subscribe(firstSub); LocalBus.Subscribe(secondSub); Thread.Sleep(2500); var inspector = new CorrelatedRouterPipelineInspector(); RemoteBus.OutboundPipeline.Inspect(inspector); inspector.PipelineHasRightRoutings.ShouldBeTrue("OutboundPipeline on publisher should contains 'CorrelatedMessageSinkRouter' for IncomingMessage with 'FirstSybsystemCorrelationId' and 'SecondSubsystemCorrelationId' correlations id's."); }
public void The_message_should_be_delivered_to_a_local_subscriber() { ManualResetEvent _updateEvent = new ManualResetEvent(false); LocalBus.Subscribe <UpdateMessage>( delegate { _updateEvent.Set(); }); UpdateMessage um = new UpdateMessage(); LocalBus.Publish(um); Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(3), true), Is.True, "Timeout expired waiting for message"); }
public void I_Should_be_able_to_subscribe() { Consumer c = new Consumer(LocalBus); LocalBus.Subscribe(c); SpecialGroup group = MessageGroup.Build <SpecialGroup>() .Add(new PingMessage()) .Add(new PongMessage()); LocalBus.Publish(group); Assert.That(c.Received.WaitOne(TimeSpan.FromSeconds(5), true), Is.True, "No message received by consumer"); }
public void The_response_address_should_pass() { FutureMessage <PingMessage> received = new FutureMessage <PingMessage>(); LocalBus.Subscribe <PingMessage>(message => { Assert.AreEqual(LocalBus.Endpoint.Uri, CurrentMessage.Headers.ResponseAddress); received.Set(message); }); LocalBus.Publish(new PingMessage(), context => context.SendResponseTo(LocalBus)); Assert.IsTrue(received.IsAvailable(5.Seconds()), "No message was received"); }
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 The_batch_should_not_be_dispatched() { ObjectBuilder.Stub(x => x.GetInstance <TestBatchConsumer <IndividualBatchMessage, Guid> >()) .Return(new TestBatchConsumer <IndividualBatchMessage, Guid>()); LocalBus.Subscribe <TestBatchConsumer <IndividualBatchMessage, Guid> >(); Guid batchId = Guid.NewGuid(); const int batchLength = 0; LocalBus.Publish(new IndividualBatchMessage(batchId, batchLength)); TestBatchConsumer <IndividualBatchMessage, Guid> .AnyShouldHaveReceivedBatch(batchId, 115.Seconds()); }
public void The_timeout_should_be_added_to_the_storage() { var _timedOut = new ManualResetEvent(false); LocalBus.Subscribe <TimeoutExpired>(x => _timedOut.Set()); LocalBus.Publish(new ScheduleTimeout(_correlationId, 1.Seconds())); Stopwatch watch = Stopwatch.StartNew(); Assert.IsTrue(_timedOut.WaitOne(TimeSpan.FromSeconds(5), true)); watch.Stop(); Debug.WriteLine(string.Format("Timeout took {0}ms", watch.ElapsedMilliseconds)); }
public void The_method_should_be_called_for_each_destination_endpoint() { LocalBus.Subscribe <PingMessage>(x => { }); var ping = new PingMessage(); List <Uri> consumers = new List <Uri>(); LocalBus.Publish(ping, x => { x.ForEachSubscriber <PingMessage>((message, endpoint) => consumers.Add(endpoint.Uri)); }); Assert.AreEqual(1, consumers.Count); Assert.AreEqual(LocalBus.Endpoint.Uri, consumers[0]); }
public void The_exception_should_not_disrupt_the_flow_of_messages() { CrashingService service = new CrashingService(); LocalBus.Subscribe(service); LocalEndpoint.Send(new BogusMessage()); CrashingService.Received.WaitOne(5.Seconds(), true).ShouldBeTrue("No message received"); CrashingService.Received.Reset(); LocalEndpoint.Send(new LegitMessage()); CrashingService.LegitReceived.WaitOne(5.Seconds(), true).ShouldBeTrue("No message received"); }
public void The_method_should_not_carry_over_to_the_next_call_context() { var ping = new PingMessage(); List <Uri> consumers = new List <Uri>(); LocalBus.Publish(ping, x => { x.ForEachSubscriber <PingMessage>((message, endpoint) => consumers.Add(endpoint.Uri)); }); LocalBus.Subscribe <PingMessage>(x => { }); LocalBus.Publish(ping); Assert.AreEqual(0, consumers.Count); }
public void A_consumer_type_should_be_created_to_receive_the_message() { FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>(); PingHandler ph = new PingHandler(fm); ObjectBuilder.Stub(x => x.GetInstance <PingHandler>()).Return(ph); ObjectBuilder.Stub(x => x.GetInstance <PingHandler>(new Hashtable())).IgnoreArguments().Return(ph); LocalBus.Subscribe <PingHandler>(); int old = PingHandler.Pinged; RemoteBus.Publish(new PingMessage()); fm.IsAvailable(1.Seconds()); Assert.That(PingHandler.Pinged, Is.GreaterThan(old)); }
public void It_should_be_received_by_multiple_subscribed_consumers() { var localConsumer = new TestMessageConsumer <PingMessage>(); LocalBus.Subscribe(localConsumer); var remoteConsumer = new TestMessageConsumer <PingMessage>(); RemoteBus.Subscribe(remoteConsumer); PingMessage message = new PingMessage(); LocalBus.Publish(message); localConsumer.ShouldHaveReceivedMessage(message, _timeout); remoteConsumer.ShouldHaveReceivedMessage(message, _timeout); }