public void Issue_1851() { Scenario.Define <Context>() .WithEndpoint <Publisher>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { if (s.SubscriberReturnAddress.Queue.Contains("Subscriber3")) { context.Subscriber3Subscribed = true; } })) .When(c => c.Subscriber3Subscribed, bus => bus.Publish <IFoo>()) ) .WithEndpoint <Subscriber3>(b => b.Given((bus, context) => { bus.Subscribe <IFoo>(); if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.Subscriber3Subscribed = true; } })) .Done(c => c.Subscriber3GotTheEvent) .Repeat(r => r.For(Transports.Default)) .Should(c => Assert.True(c.Subscriber3GotTheEvent)) .Run(); }
public void Should_be_delivered_to_all_subscribers() { Scenario.Define <Context>() .WithEndpoint <Publisher>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { if (s.SubscriberReturnAddress.Queue.Contains("myinputqueue")) { context.Subscriber1Subscribed = true; } })) .When(c => c.Subscriber1Subscribed, bus => bus.Publish(new MyEvent())) ) .WithEndpoint <Subscriber1>(b => b.Given((bus, context) => { bus.Subscribe <MyEvent>(); if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.Subscriber1Subscribed = true; } })) .Done(c => c.Subscriber1GotTheEvent) .Repeat(r => r.For(Transports.Default)) .Should(c => Assert.True(c.Subscriber1GotTheEvent)) .Run(); }
public void Both_events_should_be_delivered() { var rootContext = new Context(); Scenario.Define(rootContext) .WithEndpoint <Publisher1>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(args => { if (args.MessageType.Contains(typeof(IMyEvent).Name)) { context.SubscribedToIMyEvent = true; } if (args.MessageType.Contains(typeof(MyEvent2).Name)) { context.SubscribedToMyEvent2 = true; } })) .When(c => c.SubscribedToIMyEvent && c.SubscribedToMyEvent2, bus => bus.Publish(new MyEvent1()))) .WithEndpoint <Publisher2>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(args => { if (args.MessageType.Contains(typeof(IMyEvent).Name)) { context.SubscribedToIMyEvent = true; } if (args.MessageType.Contains(typeof(MyEvent2).Name)) { context.SubscribedToMyEvent2 = true; } })) .When(c => c.SubscribedToIMyEvent && c.SubscribedToMyEvent2, bus => bus.Publish(new MyEvent2()))) .WithEndpoint <Subscriber1>(b => b.Given((bus, context) => { bus.Subscribe <IMyEvent>(); bus.Subscribe <MyEvent2>(); if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.SubscribedToIMyEvent = true; context.SubscribedToMyEvent2 = true; } })) .Done(c => c.SubscriberGotIMyEvent && c.SubscriberGotMyEvent2) .Run(); Assert.True(rootContext.SubscriberGotIMyEvent); Assert.True(rootContext.SubscriberGotMyEvent2); }
public void Should_trigger_the_catch_all_handler_for_message_driven_subscriptions() { Scenario.Define <Context>() .WithEndpoint <MessageDrivenPublisher>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { context.LocalEndpointSubscribed = true; })) .When(c => c.LocalEndpointSubscribed, bus => bus.Publish(new EventHandledByLocalEndpoint())) ) .Done(c => c.CatchAllHandlerGotTheMessage) .Repeat(r => r.For <AllTransportsWithMessageDrivenPubSub>()) .Should(c => Assert.True(c.CatchAllHandlerGotTheMessage)) .Run(); }
[Test]//https://github.com/NServiceBus/NServiceBus/issues/1101 public void Should_only_publish_one_event() { Scenario.Define <Context>() .WithEndpoint <Publisher>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { if (s.SubscriberReturnAddress.Queue != "MyEndpoint") { return; } context.NumberOfSubcriptionsReceived++; })) .When(c => c.NumberOfSubcriptionsReceived >= 2, (bus, c) => { c.SubcribersOfTheEvent = Configure.Instance.Builder.Build <ISubscriptionStorage>() .GetSubscriberAddressesForMessage(new[] { new MessageType(typeof(MyEvent)) }).Select(a => a.ToString()).ToList(); }) ) .WithEndpoint <Subscriber1>(b => b.Given((bus, context) => { bus.Subscribe <MyEvent>(); if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.NumberOfSubcriptionsReceived++; } })) .WithEndpoint <Subscriber2>(b => b.Given((bus, context) => { bus.Subscribe <MyEvent>(); if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.NumberOfSubcriptionsReceived++; } })) .Done(c => c.SubcribersOfTheEvent != null) .Repeat(r => r.For(Transports.SqlServer) .For <AllSubscriptionStorages>(SubscriptionStorages.Msmq)) .Should(c => { Assert.AreEqual(1, c.SubcribersOfTheEvent.Count(), "There should only be one logical subscriber"); }) .MaxTestParallelism(1) //we force the endpoint names so we can't run this is parallell .Run(); }
public void should_receive_events_from_all_publishers() { var cc = new Context(); Scenario.Define(cc) .WithEndpoint <Publisher1>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { if (s.SubscriberReturnAddress.Queue.Contains("Subscriber1")) { context.SubscribedToPublisher1 = true; } })) .When(c => c.SubscribedToPublisher1, bus => bus.Publish(new DerivedEvent1())) ) .WithEndpoint <Publisher2>(b => b.Given((bus, context) => Subscriptions.OnEndpointSubscribed(s => { if (s.SubscriberReturnAddress.Queue.Contains("Subscriber1")) { context.SubscribedToPublisher2 = true; } })) .When(c => c.SubscribedToPublisher2, bus => bus.Publish(new DerivedEvent2())) ) .WithEndpoint <Subscriber1>(b => b.Given((bus, context) => { if (!Feature.IsEnabled <MessageDrivenSubscriptions>()) { context.SubscribedToPublisher1 = true; context.SubscribedToPublisher2 = true; } })) .Done(c => c.GotTheEventFromPublisher1 && c.GotTheEventFromPublisher2) .Run(); Assert.True(cc.GotTheEventFromPublisher1); Assert.True(cc.GotTheEventFromPublisher2); }