public void Determines_there_should_be_a_topic_bundle_created()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
var definition = sectionManager.DetermineResourcesToCreate(new QueueBindings());
var result = definition.Entities.Where(ei => ei.Type == EntityType.Topic && ei.Namespace.ConnectionString == Connectionstring && ei.Path.StartsWith("bundle-"));
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result, Has.Exactly(1).Matches <EntityInfo>(x => x.Path == "bundle-1"));
Assert.That(result, Has.Exactly(1).Matches <EntityInfo>(x => x.Path == "bundle-2"));
}
public void Creates_subscription_on_each_topic_in_bundle()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.UseForwardingTopology().NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
sectionManager.DetermineResourcesToCreate(new QueueBindings());
var section = sectionManager.DetermineResourcesToSubscribeTo(typeof(SomeTestEvent));
Assert.That(section.Entities.Count(), Is.EqualTo(2));
// TODO: need to verify that subscription is done on each topic
}
public async Task Receives_incoming_messages_from_endpoint_queue()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
// cleanup
await TestUtility.Delete("sales");
// setting up the environment
var container = new TransportPartsContainer();
var topology = await SetupEndpointOrientedTopology(container, "sales");
// setup the operator
var topologyOperator = (IOperateTopology)container.Resolve(typeof(TopologyOperator));
var completed = new AsyncManualResetEvent(false);
var error = new AsyncManualResetEvent(false);
var received = false;
Exception ex = null;
topologyOperator.OnIncomingMessage((message, context) =>
{
received = true;
completed.Set();
return(TaskEx.Completed);
});
topologyOperator.OnError(exception =>
{
ex = exception;
error.Set();
return(TaskEx.Completed);
});
// execute
topologyOperator.Start(topology.DetermineReceiveResources("sales"), 1);
// send message to queue
var senderFactory = (MessageSenderCreator)container.Resolve(typeof(MessageSenderCreator));
var sender = await senderFactory.Create("sales", null, "namespace");
await sender.Send(new BrokeredMessage());
await Task.WhenAny(completed.WaitAsync(cts.Token).IgnoreCancellation(), error.WaitAsync(cts.Token).IgnoreCancellation());
// validate
Assert.IsTrue(received);
Assert.IsNull(ex);
await topologyOperator.Stop();
}
public async Task Pushes_received_message_into_pipeline()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
await TestUtility.Delete("sales");
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", "sales");
new DefaultConfigurationValues().Apply(settings);
// setting up the environment
var container = new TransportPartsContainer();
var topology = await SetupEndpointOrientedTopology(container, "sales");
// setup the operator
var pump = new MessagePump(topology, container, settings);
var completed = new AsyncManualResetEvent(false);
//var error = new AsyncManualResetEvent(false);
var received = false;
Exception ex = null;
// Dummy CriticalError
var criticalError = new CriticalError(ctx => TaskEx.Completed);
await pump.Init(context =>
{
received = true;
completed.Set();
return(TaskEx.Completed);
}, null, criticalError, new PushSettings("sales", "error", false, TransportTransactionMode.ReceiveOnly));
// execute
pump.Start(new PushRuntimeSettings(1));
// send message to queue
var senderFactory = (MessageSenderCreator)container.Resolve(typeof(MessageSenderCreator));
var sender = await senderFactory.Create("sales", null, "namespaceName");
await sender.Send(new BrokeredMessage());
await completed.WaitAsync(cts.Token).IgnoreCancellation(); // Task.WhenAny(completed.WaitOne(), error.WaitOne());
// validate
Assert.IsTrue(received);
Assert.IsNull(ex);
// cleanup
await pump.Stop();
}
public void Should_set_a_single_topic_as_destination_for_events()
{
var container = new TransportPartsContainer();
var topology = SetupForwardingTopology(container, "sales");
var destination = topology.DeterminePublishDestination(typeof(SomeMessageType));
Assert.IsTrue(destination.Entities.Single().Type == EntityType.Topic);
Assert.IsTrue(destination.Entities.Single().Path.StartsWith("bundle"));
}
public void Determines_that_sends_go_to_a_single_topic_owned_by_the_endpoint()
{
var container = new TransportPartsContainer();
var topology = SetupEndpointOrientedTopology(container, "sales");
var destination = topology.DeterminePublishDestination(typeof(SomeMessageType));
Assert.IsTrue(destination.Entities.Single().Type == EntityType.Topic);
Assert.IsTrue(destination.Entities.Single().Path == "sales.events");
}
public void Returns_active_and_passive_namespaces_for_partitioned_sends()
{
var container = new TransportPartsContainer();
// setup using FailOverNamespacePartitioning to ensure we have active and passive namespaces for a failover
var topology = SetupEndpointOrientedTopologyWithFailoverNamespace(container, "sales");
var destination = topology.DetermineSendDestination("operations");
Assert.AreEqual(2, destination.Entities.Count(), "active and passive namespace should be returned");
}
public void Determines_that_sends_go_to_a_single_queue()
{
// setting up the environment
var container = new TransportPartsContainer();
var topology = SetupEndpointOrientedTopology(container, "sales");
var destination = topology.DetermineSendDestination("operations");
Assert.IsTrue(destination.Entities.Single().Type == EntityType.Queue);
Assert.IsTrue(destination.Entities.Single().Path == "operations");
}
public void Should_set_a_signle_queue_as_destination_for_command()
{
// setting up the environment
var container = new TransportPartsContainer();
var topology = SetupForwardingTopology(container, "sales");
var destination = topology.DetermineSendDestination("operations");
Assert.IsTrue(destination.Entities.Single().Type == EntityType.Queue);
Assert.IsTrue(destination.Entities.Single().Path == "operations");
}
#pragma warning disable 618
static TopologySection DetermineResourcesToCreate(SettingsHolder settings, TransportPartsContainer container)
{
var topology = new EndpointOrientedTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
var definition = sectionManager.DetermineResourcesToCreate(new QueueBindings());
return(definition);
}
public async Task Calls_on_error_when_error_during_processing()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
// cleanup
await TestUtility.Delete("sales");
// setting up the environment
var container = new TransportPartsContainer();
var topology = await SetupEndpointOrientedTopology(container, "sales");
// setup the operator
var topologyOperator = (IOperateTopology)container.Resolve(typeof(TopologyOperator));
var error = new AsyncManualResetEvent(false);
var received = false;
var errorOccurred = false;
topologyOperator.OnIncomingMessage(async(message, context) =>
{
received = true;
await Task.Delay(1).ConfigureAwait(false);
throw new Exception("Something went wrong");
});
topologyOperator.OnError(exception =>
{
errorOccurred = true;
error.Set();
return(TaskEx.Completed);
});
// execute
topologyOperator.Start(topology.DetermineReceiveResources("sales"), 1);
// send message to queue
var senderFactory = (MessageSenderCreator)container.Resolve(typeof(MessageSenderCreator));
var sender = await senderFactory.Create("sales", null, "namespace");
await sender.Send(new BrokeredMessage());
await error.WaitAsync(cts.Token);
// validate
Assert.IsTrue(received);
Assert.IsTrue(errorOccurred);
await topologyOperator.Stop();
}
async Task SetupAsync(TransportPartsContainer container, SettingsHolder settings)
{
await TestUtility.Delete(SourceQueueName, DestinationQueueName);
topology = await SetupEndpointOrientedTopology(container, SourceQueueName, settings);
// create the destination queue
var namespaceLifeCycle = (IManageNamespaceManagerLifeCycle)container.Resolve(typeof(IManageNamespaceManagerLifeCycle));
var creator = (ICreateAzureServiceBusQueues)container.Resolve(typeof(ICreateAzureServiceBusQueues));
namespaceManager = namespaceLifeCycle.Get("namespaceName");
await creator.Create(DestinationQueueName, namespaceManager);
}
public async Task Should_trigger_circuit_breaker()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
var container = new TransportPartsContainer();
var fakeTopologyOperator = new FakeTopologyOperator();
container.Register <IOperateTopology>(() => fakeTopologyOperator);
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", "sales");
new DefaultConfigurationValues().Apply(settings);
container.Register <ReadOnlySettings>(() => settings);
Exception exceptionReceivedByCircuitBreaker = null;
var criticalErrorWasRaised = false;
var tcs = new TaskCompletionSource <object>();
cts.Token.Register(() => tcs.TrySetCanceled());
// setup critical error action to capture exception thrown by message pump
var criticalError = new FakeCriticalError(ctx =>
{
criticalErrorWasRaised = true;
exceptionReceivedByCircuitBreaker = ctx.Exception;
tcs.TrySetResult(null);
return(TaskEx.Completed);
});
var pump = new MessagePump(new FakeTopology(), container, settings, TimeSpan.FromSeconds(1));
await pump.Init(context => TaskEx.Completed, null, criticalError, new PushSettings("sales", "error", false, TransportTransactionMode.ReceiveOnly));
pump.Start(new PushRuntimeSettings(1));
await fakeTopologyOperator.onIncomingMessage(new IncomingMessageDetails("id", new Dictionary <string, string>(), new byte[0]), new FakeReceiveContext());
var exceptionThrownByMessagePump = new Exception("kaboom");
await fakeTopologyOperator.onError(exceptionThrownByMessagePump);
await tcs.Task; // let circuit breaker kick in
// validate
Assert.IsTrue(criticalErrorWasRaised, "Expected critical error to be raised, but it wasn't");
Assert.AreEqual(exceptionThrownByMessagePump, exceptionReceivedByCircuitBreaker, "Exception circuit breaker got should be the same as the one raised by message pump");
}
#pragma warning disable 618
ITopologySectionManager SetupForwardingTopology(TransportPartsContainer container, string enpointname)
{
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname);
extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
return(container.Resolve <ITopologySectionManager>());
}
public void Determines_there_should_be_a_topic_with_same_name_as_endpointname_followed_by_dot_events()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
settings.Set <Conventions>(new Conventions());
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = DetermineResourcesToCreate(settings, container);
Assert.AreEqual(1, definition.Entities.Count(ei => ei.Path == "sales.events" && ei.Type == EntityType.Topic && ei.Namespace.ConnectionString == Connectionstring));
}
public void Should_throw()
{
var container = new TransportPartsContainer();
container.Register <TopologyOperator>();
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", "sales");
new DefaultConfigurationValues().Apply(settings);
container.Register <ReadOnlySettings>(() => settings);
var pump = new MessagePump(null, container, settings);
var criticalError = new CriticalError(ctx => TaskEx.Completed);
const bool purgeOnStartup = true;
Assert.ThrowsAsync <InvalidOperationException> (async() => await pump.Init(context => TaskEx.Completed, null, criticalError, new PushSettings("sales", "error", purgeOnStartup, TransportTransactionMode.SendsAtomicWithReceive)));
}
ITopologySectionManager SetupEndpointOrientedTopologyWithFailoverNamespace(TransportPartsContainer container, string enpointname)
{
var settings = new SettingsHolder();
settings.Set <Conventions>(new Conventions());
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname);
extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value);
extensions.NamespacePartitioning().AddNamespace("namespace2", AzureServiceBusConnectionString.Fallback);
extensions.NamespacePartitioning().UseStrategy <FailOverNamespacePartitioning>();
var topology = new EndpointOrientedTopology(container);
topology.Initialize(settings);
return(container.Resolve <ITopologySectionManager>());
}
public void Should_fail_sanitization_for_invalid_endpoint_name(string reasonToFail, string endpointName)
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", endpointName);
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
Assert.Throws <Exception>(() => sectionManager.DetermineResourcesToCreate(new QueueBindings()), "Was expected to fail: " + reasonToFail);
}
public void Determines_the_namespace_from_partitioning_strategy()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
settings.Set <Conventions>(new Conventions());
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = DetermineResourcesToCreate(settings, container);
// ReSharper disable once RedundantArgumentDefaultValue
var namespaceInfo = new RuntimeNamespaceInfo(Name, Connectionstring);
Assert.IsTrue(definition.Namespaces.Any(nsi => nsi == namespaceInfo));
}
public void Determines_there_should_be_a_queue_with_same_name_as_endpointname()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
var definition = sectionManager.DetermineResourcesToCreate(new QueueBindings());
Assert.AreEqual(1, definition.Entities.Count(ei => ei.Path == "sales" && ei.Type == EntityType.Queue && ei.Namespace.ConnectionString == Connectionstring));
}
public void SetUp()
{
tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(60));
completed = new AsyncManualResetEvent(false);
container = new TransportPartsContainer();
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", SourceQueueName);
criticalError = new CriticalError(ctx => TaskEx.Completed);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.SendViaReceiveQueue(true);
SetupAsync(container, settings).GetAwaiter().GetResult();
dispatcher = (IDispatchMessages)container.Resolve(typeof(IDispatchMessages));
timeToWaitBeforeTriggeringTheCircuitBreaker = TimeSpan.FromSeconds(5);
pump = new MessagePump(topology, container, settings, timeToWaitBeforeTriggeringTheCircuitBreaker);
}
async Task <ITopologySectionManager> SetupEndpointOrientedTopology(TransportPartsContainer container, string endpointName, SettingsHolder settings)
{
container.Register(typeof(SettingsHolder), () => settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", endpointName);
settings.Set <Conventions>(new Conventions());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.NamespacePartitioning().AddNamespace("namespaceName", AzureServiceBusConnectionString.Value);
var endpointOrientedTopology = new EndpointOrientedTopology(container);
endpointOrientedTopology.Initialize(settings);
// create the topologySectionManager
var topologyCreator = (ICreateTopology)container.Resolve(typeof(TopologyCreator));
var sectionManager = container.Resolve <ITopologySectionManager>();
await topologyCreator.Create(sectionManager.DetermineResourcesToCreate(new QueueBindings()));
container.RegisterSingleton <TopologyOperator>();
return(sectionManager);
}
public void Creates_subscription_path_matching_the_subscribing_endpoint_name()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.UseForwardingTopology().NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
sectionManager.DetermineResourcesToCreate(new QueueBindings());
var section = sectionManager.DetermineResourcesToSubscribeTo(typeof(SomeTestEvent));
Assert.IsTrue(section.Entities.All(e => e.Path == "sales"), "Subscription name should be matching subscribing endpoint name, but it wasn't.");
}
public void Should_creates_subscription_entities_marked_as_not_be_listened_to()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.UseForwardingTopology().NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
sectionManager.DetermineResourcesToCreate(new QueueBindings());
var section = sectionManager.DetermineResourcesToSubscribeTo(typeof(SomeTestEvent));
Assert.IsFalse(section.Entities.Any(x => x.ShouldBeListenedTo));
}
