public async Task It_should_deliver_the_message_to_both_subscribers()
{
var result = await Scenario.Define <Context>()
.WithRouter("Router", (c, cfg) =>
{
cfg.AddInterface <TestTransport>("Left", t => t.BrokerAlpha()).InMemorySubscriptions();
var leftIface = cfg.AddInterface <AzureServiceBusTransport>("Right", t =>
{
var connString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString");
t.ConnectionString(connString);
var topology = t.UseEndpointOrientedTopology();
topology.RegisterPublisher(typeof(MyAsbEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
});
leftIface.LimitMessageProcessingConcurrencyTo(1); //To ensure when tracer arrives the subscribe request has already been processed.;
cfg.AddRule(_ => new SuppressTransactionScopeRule());
cfg.UseStaticRoutingProtocol().AddForwardRoute("Left", "Right");
})
.WithEndpoint <Publisher>(c => c.When(x => x.EventSubscribed, s => s.Publish(new MyAsbEvent())))
.WithEndpoint <Subscriber>(c => c.When(async s =>
{
await s.Subscribe <MyAsbEvent>().ConfigureAwait(false);
await s.Send(new TracerMessage()).ConfigureAwait(false);
}))
.Done(c => c.EventDelivered)
.Run();
Assert.IsTrue(result.EventDelivered);
}
void ConfigureRouter(Context c, RouterConfiguration cfg)
{
cfg.AddInterface <TestTransport>("Left", t => t.BrokerAlpha()).EnableMessageDrivenPublishSubscribe(subscriptionStorage);
var leftIface = cfg.AddInterface <AzureServiceBusTransport>("Right", t =>
{
var connString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString");
t.ConnectionString(connString);
var settings = t.GetSettings();
var builder = new ConventionsBuilder(settings);
builder.DefiningEventsAs(EventConvention);
settings.Set <NServiceBus.Conventions>(builder.Conventions);
var topology = t.UseEndpointOrientedTopology();
topology.EnableMigrationToForwardingTopology();
topology.RegisterPublisher(typeof(MyAsbEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
var serializer = Tuple.Create(new NewtonsoftSerializer() as SerializationDefinition, new SettingsHolder());
settings.Set("MainSerializer", serializer);
});
leftIface.LimitMessageProcessingConcurrencyTo(1); //To ensure when tracer arrives the subscribe request has already been processed.;
cfg.AddRule(_ => new SuppressTransactionScopeRule());
cfg.UseStaticRoutingProtocol().AddForwardRoute("Left", "Right");
}
static void PreventInconclusiveTestsFromRunning(string endpointName)
{
if (endpointName == Conventions.EndpointNamingConvention(typeof(When_publishing_from_sendonly.SendOnlyPublisher)))
{
Assert.Inconclusive("Test is not using endpoint naming conventions in hardcoded subscription storage. Should be fixed in core vNext.");
}
}
public HardcodedSubscriptionManager()
{
addressTask = Task.FromResult(new[]
{
new Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber(Conventions.EndpointNamingConvention(typeof(Subscriber)), null)
}.AsEnumerable());
}
public Publisher()
{
EndpointSetup <DefaultPublisher>(b => b.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber1))))
{
context.Subscriber1Subscribed = true;
}
}));
}
public Endpoint()
{
EndpointSetup <DefaultServer>(config =>
{
config.EnableFeature <TimeoutManager>();
config.UsePersistence <FakeTimeoutPersistence>();
config.SendFailedMessagesTo(Conventions.EndpointNamingConvention(typeof(Endpoint)));
config.RegisterComponents(c => c.ConfigureComponent <FakeTimeoutStorage>(DependencyLifecycle.SingleInstance));
config.Pipeline.Register <BehaviorThatLogsControlMessageDelivery.Registration>();
});
}
public Publisher1()
{
EndpointSetup <DefaultPublisher>(b => b.OnEndpointSubscribed <Context>((s, context) =>
{
context.AddTrace($"{Conventions.EndpointNamingConvention(typeof(Publisher1))} SubscriberEndpoint={s.SubscriberEndpoint}");
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber1))))
{
context.SubscribedToPublisher1 = true;
}
}));
}
public Publisher3()
{
EndpointSetup <DefaultPublisher>(b => b.OnEndpointSubscribed <Context>((s, context) =>
{
var subscriber3 = Conventions.EndpointNamingConvention(typeof(Subscriber3));
if (s.SubscriberEndpoint.Contains(subscriber3))
{
context.AddTrace($"{subscriber3} is now subscribed");
context.Subscriber3Subscribed = true;
}
}));
}
public Publisher()
{
EndpointSetup <DefaultPublisher>(c =>
{
c.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber))))
{
context.SubscribedMessageDriven = true;
}
});
}).IncludeType <TestingInMemorySubscriptionPersistence>();
}
public Publisher(string connectionString, bool supportsPublishSubscribe)
{
EndpointSetup(new CustomizedServer(_connectionString, supportsPublishSubscribe), (c, rd) =>
{
c.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber))))
{
context.SubscribedMessageDriven = true;
}
});
}).IncludeType <TestingInMemorySubscriptionPersistence>();
}
public Endpoint()
{
EndpointSetup <DefaultServer>((config, runDescriptor) =>
{
config.EnableFeature <TimeoutManager>();
config.UsePersistence <FakeTimeoutPersistence>();
config.SendFailedMessagesTo(Conventions.EndpointNamingConvention(typeof(Endpoint)));
config.RegisterComponents(c => c.ConfigureComponent <FakeTimeoutStorage>(DependencyLifecycle.SingleInstance));
config.Pipeline.Register <BehaviorThatLogsControlMessageDelivery.Registration>();
config.LimitMessageProcessingConcurrencyTo(1);
config.UseTransport(runDescriptor.GetTransportType()).Transactions(TransportTransactionMode.TransactionScope);
});
}
public Publisher()
{
EndpointSetup <DefaultPublisher>((c, r) =>
{
c.Pipeline.Register("EventTypeSpy", new EventTypeSpy((Context)r.ScenarioContext), "EventTypeSpy");
c.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber))))
{
context.Subscribed = true;
}
});
});
}
public Publisher()
{
EndpointSetup <DefaultPublisher>(c =>
{
c.Conventions().DefiningEventsAs(t => t.Namespace != null && t.Name.EndsWith("Event"));
c.Pipeline.Register("EventTypeSpy", typeof(EventTypeSpy), "EventTypeSpy");
c.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber))))
{
context.Subscribed = true;
}
});
}).ExcludeType <MyEvent>(); // remove that type from assembly scanning to simulate what would happen with true unobtrusive mode
}
public Endpoint()
{
EndpointSetup <DefaultServer>(config =>
{
config.EnableFeature <TimeoutManager>();
config.UsePersistence <FakeTimeoutPersistence>();
config.SendFailedMessagesTo(Conventions.EndpointNamingConvention(typeof(Endpoint)));
config.RegisterComponents(c =>
{
c.AddSingleton <FakeTimeoutStorage>();
c.AddSingleton <IPersistTimeouts>(sp => sp.GetRequiredService <FakeTimeoutStorage>());
c.AddSingleton <IQueryTimeouts>(sp => sp.GetRequiredService <FakeTimeoutStorage>());
});
config.Pipeline.Register <BehaviorThatLogsControlMessageDelivery.Registration>();
});
}
void ConfigureRouter(Context c, RouterConfiguration cfg)
{
cfg.AddInterface <TestTransport>("Left", t => t.BrokerAlpha()).EnableMessageDrivenPublishSubscribe(subscriptionStorage);
var leftIface = cfg.AddInterface <AzureServiceBusTransport>("Right", t =>
{
var connString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString");
t.ConnectionString(connString);
var topology = t.UseEndpointOrientedTopology();
topology.EnableMigrationToForwardingTopology();
topology.RegisterPublisher(typeof(MyAsbEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
});
leftIface.LimitMessageProcessingConcurrencyTo(1); //To ensure when tracer arrives the subscribe request has already been processed.;
cfg.AddRule(_ => new SuppressTransactionScopeRule());
cfg.UseStaticRoutingProtocol().AddForwardRoute("Left", "Right");
}
public async Task Should_receive_event()
{
Requires.EndpointOrientedTopology();
var context = await Scenario.Define <Context>()
// Publish event only when it was signaled that events went out
.WithEndpoint <Publisher>(b =>
{
b.CustomConfig(c =>
{
var transport = c.ConfigureAzureServiceBus();
transport.NamespacePartitioning().AddNamespace("publisherNamespace", publisherConnectionString);
transport.UseEndpointOrientedTopology();
})
.When(c => c.ReceiverSubscribedToEvents, async messageSession =>
{
await messageSession.Publish <MyEvent>();
});
})
.WithEndpoint <Subscriber>(b =>
{
b.CustomConfig(c =>
{
var transport = c.ConfigureAzureServiceBus();
transport.NamespacePartitioning().AddNamespace("subscriberNamespace", subscriberConnectionString);
var namespaceInfo = transport.NamespaceRouting().AddNamespace("publisherNamespace", publisherConnectionString);
namespaceInfo.RegisteredEndpoints.Add(Conventions.EndpointNamingConvention(typeof(Publisher)));
transport.UseEndpointOrientedTopology()
.RegisterPublisher(typeof(MyEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
})
.When(async(session, c) =>
{
await session.Subscribe <MyEvent>();
c.ReceiverSubscribedToEvents = true;
});
})
.Done(ctx => ctx.SubscriberGotTheEvent)
.Run();
Assert.That(context.SubscriberGotTheEvent, Is.True, "Should receive the event");
}
public Publisher()
{
EndpointSetup <DefaultPublisher>(b =>
{
b.OnEndpointSubscribed <Context>((s, context) =>
{
if (s.SubscriberEndpoint.Contains(Conventions.EndpointNamingConvention(typeof(Subscriber))))
{
if (s.MessageType == typeof(IEventA).AssemblyQualifiedName)
{
context.EventASubscribed = true;
}
if (s.MessageType == typeof(IEventB).AssemblyQualifiedName)
{
context.EventBSubscribed = true;
}
}
});
});
}
public Publisher()
{
EndpointSetup <DefaultPublisher>(b =>
{
b.OnEndpointSubscribed <Context>((s, context) =>
{
var subscriber1 = Conventions.EndpointNamingConvention(typeof(Subscriber1));
if (s.SubscriberEndpoint.Contains(subscriber1))
{
context.Subscriber1Subscribed = true;
context.AddTrace($"{subscriber1} is now subscribed");
}
var subscriber2 = Conventions.EndpointNamingConvention(typeof(Subscriber2));
if (s.SubscriberEndpoint.Contains(subscriber2))
{
context.AddTrace($"{subscriber2} is now subscribed");
context.Subscriber2Subscribed = true;
}
});
b.DisableFeature <AutoSubscribe>();
});
}
public async Task Should_reply_to_configured_return_address()
{
var ctx = await Scenario.Define <Context>()
.WithEndpoint <SendingEndpoint>(c => c
.CustomConfig(b => b.OverridePublicReturnAddress(Conventions.EndpointNamingConvention(typeof(OtherEndpoint))))
.When(b => b.Send(new MyMessage())))
.WithEndpoint <ReplyingEndpoint>()
.WithEndpoint <OtherEndpoint>()
.Done(c => c.OtherEndpointGotResponse)
.Run();
Assert.IsTrue(ctx.OtherEndpointGotResponse);
Assert.IsFalse(ctx.SendingEndpointGotResponse);
}
