public async Task Should_throw_exception_for_a_message_that_exceeds_maximum_size()
{
// default settings
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(new TopologySettings());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceLifecycleManager = new NamespaceManagerLifeCycleManagerInternal(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceLifecycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new OutgoingBatchRouter(new BatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
var namespaceManager = namespaceLifecycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Enumerable.Range(0, settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes) * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
Assert.That(async() => await router.RouteBatch(batch, null, DispatchConsistency.Default), Throws.Exception.TypeOf <MessageTooLargeException>());
}
public async Task Determines_the_namespace_from_partitioning_strategy()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(new Conventions());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
settings.SetDefault("NServiceBus.SharedQueue", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = await DetermineResourcesToCreate(settings);
var namespaceInfo = new RuntimeNamespaceInfo(Name, Connectionstring);
Assert.IsTrue(definition.Namespaces.Any(nsi => nsi == namespaceInfo));
}
public async Task Determines_the_namespace_from_partitioning_strategy()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
settings.SetDefault("NServiceBus.SharedQueue", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTransportInfrastructure(settings);
await topology.Start();
var sectionManager = topology.topologyManager;
var definition = sectionManager.DetermineQueuesToCreate(new QueueBindings(), "sales");
var namespaceInfo = new RuntimeNamespaceInfo(Name, Connectionstring);
Assert.IsTrue(definition.Namespaces.Any(nsi => nsi == namespaceInfo));
}
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 IList <BatchInternal> ToBatches(TransportOperations operations)
{
// we don't care about incoming operations as we'll fake batcher and return pre-canned batches
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Encoding.UTF8.GetBytes("Whatever");
var batch1 = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-2", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
}
};
var batch2 = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue2",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-3", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-4", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
}
};
return(new List <BatchInternal>
{
batch1,
batch2
});
}
public async Task Can_route_an_outgoing_batch_of_messages()
{
// default settings
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set <TopologySettings>(new TopologySettings());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceLifecycleManager = new NamespaceManagerLifeCycleManagerInternal(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceLifecycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new OutgoingBatchRouter(new BatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
var namespaceManager = namespaceLifecycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Encoding.UTF8.GetBytes("Whatever");
var batch = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-2", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
await router.RouteBatch(batch, null, DispatchConsistency.Default);
//validate
var queue = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(queue.MessageCount == 2);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Should_invoke_non_throwing_oversized_brokered_message_handler_for_a_message_that_exceeds_maximum_size_only_once_even_if_fallback_namespace_is_set()
{
// default settings
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set <TopologySettings>(new TopologySettings());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("primary", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
namespacesDefinition.Add("fallback", AzureServiceBusConnectionString.Fallback, NamespacePurpose.Partitioning);
var oversizedHandler = new MyOversizedBrokeredMessageHandler();
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceLifecycleManager = new NamespaceManagerLifeCycleManagerInternal(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceLifecycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new OutgoingBatchRouter(new BatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, oversizedHandler);
// create the queue & fallback queue
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
var namespaceManager = namespaceLifecycleManager.Get("primary");
await creator.Create("myqueue", namespaceManager);
var fallbackNamespaceManager = namespaceLifecycleManager.Get("fallback");
await creator.Create("myqueue", fallbackNamespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("primary", AzureServiceBusConnectionString.Value);
var @fallback = new RuntimeNamespaceInfo("fallback", AzureServiceBusConnectionString.Value, mode: NamespaceMode.Passive);
var bytes = Enumerable.Range(0, settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes) * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "myqueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace,
@fallback
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
await router.RouteBatch(batch, null, DispatchConsistency.Default);
// validate
Assert.True(oversizedHandler.InvocationCount == 1);
//cleanup
await fallbackNamespaceManager.DeleteQueue("myqueue");
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Should_route_via_active_namespace_first()
{
// default settings
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set <TopologySettings>(new TopologySettings());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("primary", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
namespacesDefinition.Add("fallback", AzureServiceBusConnectionString.Fallback, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceLifecycleManager = new NamespaceManagerLifeCycleManagerInternal(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceLifecycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new OutgoingBatchRouter(new BatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the fallback queue (but not the queue in the primary to emulate that it is down)
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
var primaryNamespaceManager = namespaceLifecycleManager.Get("primary");
var fallbackNamespaceManager = namespaceLifecycleManager.Get("fallback");
await creator.Create("myqueue", primaryNamespaceManager);
await creator.Create("myqueue", fallbackNamespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("primary", AzureServiceBusConnectionString.Value);
var fallback = new RuntimeNamespaceInfo("fallback", AzureServiceBusConnectionString.Fallback, mode: NamespaceMode.Passive);
var bytes = Encoding.UTF8.GetBytes("Whatever");
var batch = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
},
new EntityInfoInternal
{
Namespace = fallback,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace,
fallback
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("SomeId", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
}
};
// perform the test
await router.RouteBatch(batch, null, DispatchConsistency.Default);
//validate
var queueOnPrimaryNamespace = await primaryNamespaceManager.GetQueue("myqueue");
Assert.IsTrue(queueOnPrimaryNamespace.MessageCount > 0, "expected to have messages in the primary queue, but there were no messages");
var queueOnSecondaryNamespace = await fallbackNamespaceManager.GetQueue("myqueue");
Assert.IsTrue(queueOnSecondaryNamespace.MessageCount == 0, "expected NOT to have messages in the secondary queue, but there were no messages");
//cleanup
await primaryNamespaceManager.DeleteQueue("myqueue");
await fallbackNamespaceManager.DeleteQueue("myqueue");
}
public async Task Should_throw_exception_for_a_message_that_exceeds_maximum_size_and_not_handle_fallback_on_message_too_large_Exception()
{
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("primary", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
namespacesDefinition.Add("fallback", AzureServiceBusConnectionString.Fallback, NamespacePurpose.Partitioning);
var oversizedHandler = new MyThrowingOversizedBrokeredMessageHandler();
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new DefaultOutgoingBatchRouter(new DefaultBatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, oversizedHandler);
// create the queue
var creator = new AzureServiceBusQueueCreator(settings);
var namespaceManager = namespaceManagerLifeCycleManager.Get("primary");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("primary", AzureServiceBusConnectionString.Value);
var fallback = new RuntimeNamespaceInfo("fallback", AzureServiceBusConnectionString.Value, mode: NamespaceMode.Passive);
var bytes = Enumerable.Range(0, settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes) * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new Batch
{
Destinations = new TopologySection
{
Entities = new List <EntityInfo>
{
new EntityInfo
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace,
fallback
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperation>
{
new BatchedOperation
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
Assert.That(async() => await router.RouteBatch(batch, null, DispatchConsistency.Default), Throws.Exception.TypeOf <MessageTooLargeException>());
Assert.True(oversizedHandler.InvocationCount == 1);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Can_route_a_batch_of_large_messages_that_total_size_exceeds_256KB()
{
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new DefaultOutgoingBatchRouter(new DefaultBatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings);
var namespaceManager = namespaceManagerLifeCycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Enumerable.Range(0, 220 * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new Batch
{
Destinations = new TopologySection
{
Entities = new List <EntityInfo>
{
new EntityInfo
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperation>
{
new BatchedOperation
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
new BatchedOperation
{
Message = new OutgoingMessage("Id-2", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
await router.RouteBatch(batch, null, DispatchConsistency.Default);
//validate
var queue = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(queue.MessageCount == 2);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
