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);
}
