private Task<Bus> BuildMeABus()
{
return Task.Run(() =>
{
// Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
// deleting queues and topics is slow.
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {GetType().Namespace});
var messageBroker = new DefaultMessageHandlerFactory(typeProvider);
var logger = new ConsoleLogger();
var bus = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(CommonResources.ConnectionString)
.WithTypesFrom(typeProvider)
.WithCommandHandlerFactory(messageBroker)
.WithRequestHandlerFactory(messageBroker)
.WithMulticastEventHandlerFactory(messageBroker)
.WithCompetingEventHandlerFactory(messageBroker)
.WithMulticastRequestHandlerFactory(messageBroker)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.Build();
bus.ShouldNotBe(null);
bus.Start();
return bus;
});
}
public async Task<Bus> CreateAndStart()
{
var logger = new ConsoleLogger();
//var logger = new NullLogger();
// Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
// deleting queues and topics is slow.
var typeProvider = new TestHarnessTypeProvider(new[] {_testFixtureType.Assembly}, new[] {_testFixtureType.Namespace});
var bus = new BusBuilder().Configure()
.WithNames("MyTestSuite", Environment.MachineName)
.WithConnectionString(CommonResources.ServiceBusConnectionString)
.WithTypesFrom(typeProvider)
.WithGlobalInboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IInboundInterceptor).IsAssignableFrom(t)).ToArray())
.WithGlobalOutboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IOutboundInterceptor).IsAssignableFrom(t)).ToArray())
.WithDependencyResolver(new DependencyResolver(typeProvider))
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.WithDebugOptions(
dc =>
dc.RemoveAllExistingNamespaceElementsOnStartup(
"I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
.Build();
await bus.Start(MessagePumpTypes.All);
return bus;
}
private async Task ClearMeABus()
{
// Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
// deleting queues and topics is slow.
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {"Some.Namespace.That.Does.Not.Exist"});
var logger = TestHarnessLoggerFactory.Create();
var busBuilder = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(CommonResources.ServiceBusConnectionString)
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.WithDebugOptions(
dc =>
dc.RemoveAllExistingNamespaceElementsOnStartup(
"I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
;
using (var bus = busBuilder.Build())
{
await bus.Start();
}
}
private void ClearMeABus()
{
// Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
// deleting queues and topics is slow.
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {"Some.Namespace.That.Does.Not.Exist"});
var messageBroker = new DefaultMessageBroker(typeProvider);
var logger = new ConsoleLogger();
var bus = new BusBuilder().Configure()
.WithNames("MyTestSuite", Environment.MachineName)
.WithConnectionString(CommonResources.ConnectionString)
.WithTypesFrom(typeProvider)
.WithCommandBroker(messageBroker)
.WithRequestBroker(messageBroker)
.WithMulticastEventBroker(messageBroker)
.WithCompetingEventBroker(messageBroker)
.WithMulticastRequestBroker(messageBroker)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.WithDebugOptions(
dc =>
dc.RemoveAllExistingNamespaceElementsOnStartup(
"I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
.Build();
}
protected async Task<BrokeredMessageFactory> Given()
{
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {GetType().Namespace});
return new BrokeredMessageFactory(
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting {Value = 64*1024},
new SystemClock(),
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
new DataContractSerializer(typeProvider),
typeProvider);
}
public static IEnumerable<IDependencyResolver> GetAllDependencyResolvers(TestHarnessTypeProvider typeProvider)
{
var dependencyResolvers = AssembliesToScan
.SelectMany(a => a.GetExportedTypes())
.Where(t => typeof (IDependencyResolverFactory).IsAssignableFrom(t))
.Where(t => t.IsInstantiable())
.Select(Activator.CreateInstance)
.Cast<IDependencyResolverFactory>()
.Select(factory => factory.Create(typeProvider))
.ToArray();
return dependencyResolvers;
}
protected async Task<BrokeredMessageFactory> Given()
{
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {GetType().Namespace});
return new BrokeredMessageFactory(new DefaultMessageTimeToLiveSetting(),
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting {Value = 64*1024},
new ReplyQueueNameSetting(new ApplicationNameSetting {Value = "SomeApp"}, new InstanceNameSetting {Value = "SomeInstance"}),
new SystemClock(),
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
new DataContractSerializer(typeProvider),
typeProvider);
}
public async Task ItShouldGoBangQuickly()
{
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {GetType().Namespace});
var logger = TestHarnessLoggerFactory.Create();
var bus = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(@"Endpoint=sb://shouldnotexist.example.com/;SharedAccessKeyName=IntegrationTestHarness;SharedAccessKey=borkborkbork=")
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.Build();
await bus.Start();
}
protected async Task <BrokeredMessageFactory> Given()
{
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
return(new BrokeredMessageFactory(
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting {
Value = 64 * 1024
},
new SystemClock(),
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
new DataContractSerializer(typeProvider),
typeProvider));
}
public async Task ItShouldGoBangQuickly()
{
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var logger = TestHarnessLoggerFactory.Create();
var bus = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(@"Endpoint=sb://shouldnotexist.example.com/;SharedAccessKeyName=IntegrationTestHarness;SharedAccessKey=borkborkbork=")
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.Build();
await bus.Start();
}
public BusBuilderScenario(TestHarnessTypeProvider typeProvider,
ILogger logger,
IConfigurationScenario <TransportConfiguration> transport,
IConfigurationScenario <IRouter> router,
IConfigurationScenario <ISerializer> serializer,
IConfigurationScenario <ICompressor> compressor,
IConfigurationScenario <ContainerConfiguration> iocContainer,
IConfigurationScenario <SyncContextConfiguration> syncContext) : base(transport, router, serializer, compressor, iocContainer, syncContext)
{
_typeProvider = typeProvider;
_logger = logger;
_transport = transport;
_router = router;
_serializer = serializer;
_compressor = compressor;
_iocContainer = iocContainer;
_syncContext = syncContext;
}
public IEnumerator <IConfigurationScenario <BusBuilderConfiguration> > GetEnumerator()
{
var typeProvider = new TestHarnessTypeProvider(new[] { _testFixtureType.Assembly }, new[] { _testFixtureType.Namespace });
var logger = TestHarnessLoggerFactory.Create(Guid.NewGuid(), GetType().FullName);
foreach (var syncContext in new SynchronizationContextConfigurationSources())
{
// in-process transport with all other combinations
foreach (var transport in new TransportConfigurationSources().Take(1))
{
foreach (var router in new RouterConfigurationSources())
{
foreach (var serializer in new SerializerConfigurationSources(typeProvider))
{
foreach (var iocContainer in new IoCContainerConfigurationSources())
{
foreach (var compressor in new CompressorScenariosSource())
{
yield return(new BusBuilderScenario(typeProvider, logger, transport, router, serializer, compressor, iocContainer, syncContext));
}
}
}
}
}
// all transports with defaults for everything else
foreach (var transport in new TransportConfigurationSources().Skip(1))
{
foreach (var router in new RouterConfigurationSources().Take(1))
{
foreach (var serializer in new SerializerConfigurationSources(typeProvider).Take(1))
{
foreach (var iocContainer in new IoCContainerConfigurationSources().Take(1))
{
foreach (var compressor in new CompressorScenariosSource().Take(1))
{
yield return(new BusBuilderScenario(typeProvider, logger, transport, router, serializer, compressor, iocContainer, syncContext));
}
}
}
}
}
}
}
protected override Task <BusCommandSender> Given()
{
_nimbusMessageSender = Substitute.For <INimbusMessageSender>();
var messagingFactory = Substitute.For <INimbusMessagingFactory>();
messagingFactory.GetQueueSender(Arg.Any <string>()).Returns(ci => _nimbusMessageSender);
var clock = new SystemClock();
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var serializer = new DataContractSerializer(typeProvider);
var replyQueueNameSetting = new ReplyQueueNameSetting(
new ApplicationNameSetting {
Value = "TestApplication"
},
new InstanceNameSetting {
Value = "TestInstance"
});
var brokeredMessageFactory = new BrokeredMessageFactory(new DefaultMessageTimeToLiveSetting(),
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting(),
replyQueueNameSetting,
clock,
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
serializer,
typeProvider);
var logger = Substitute.For <ILogger>();
var knownMessageTypeVerifier = Substitute.For <IKnownMessageTypeVerifier>();
var router = new DestinationPerMessageTypeRouter();
var dependencyResolver = new NullDependencyResolver();
var outboundInterceptorFactory = new NullOutboundInterceptorFactory();
var busCommandSender = new BusCommandSender(brokeredMessageFactory,
dependencyResolver,
knownMessageTypeVerifier,
logger,
messagingFactory,
outboundInterceptorFactory,
router);
return(Task.FromResult(busCommandSender));
}
private IEnumerable <TestCaseData> Generate()
{
var typeProvider = new TestHarnessTypeProvider(new[] { Assembly.GetExecutingAssembly() }, new[] { GetType().Namespace });
var dependencyResolvers = TestHarnessDependencyResolversFactory.GetAllDependencyResolvers(typeProvider);
var typesToResolve = typeProvider.AllResolvableTypes();
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var dependencyResolver in dependencyResolvers)
{
foreach (var componentType in typesToResolve)
{
yield return(new TestCaseData(dependencyResolver, componentType)
.SetName(dependencyResolver.GetType().Name + "." + componentType.Name));
}
}
// ReSharper restore LoopCanBeConvertedToQuery
}
private BrokeredMessageFactory BuildBrokeredMessageFactory(ICompressor compressor)
{
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var serializer = new DataContractSerializer(typeProvider);
return(new BrokeredMessageFactory(new DefaultMessageTimeToLiveSetting(),
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting(),
new ReplyQueueNameSetting(new ApplicationNameSetting {
Value = "App"
}, new InstanceNameSetting {
Value = "Instance"
}),
Substitute.For <IClock>(),
compressor,
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
serializer,
typeProvider));
}
protected MessageDispatcherTestBase()
{
var clock = Substitute.For <IClock>();
var replyQueueNameSetting = new ReplyQueueNameSetting(
new ApplicationNameSetting {
Value = "TestApplication"
},
new InstanceNameSetting {
Value = "TestInstance"
});
TypeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var serializer = new DataContractSerializer(TypeProvider);
HandlerMapper = new HandlerMapper(TypeProvider);
NimbusMessageFactory = new NimbusMessageFactory(new DefaultMessageTimeToLiveSetting(),
replyQueueNameSetting,
clock,
new DispatchContextManager());
}
protected async Task <BrokeredMessageFactory> Given()
{
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
return(new BrokeredMessageFactory(new DefaultMessageTimeToLiveSetting(),
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting {
Value = 64 * 1024
},
new ReplyQueueNameSetting(new ApplicationNameSetting {
Value = "SomeApp"
}, new InstanceNameSetting {
Value = "SomeInstance"
}),
new SystemClock(),
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
new DataContractSerializer(typeProvider),
typeProvider));
}
private Task <Bus> BuildMeABus()
{
return(Task.Run(async() =>
{
// Filter types we care about to only our own test's namespace. It's a performance optimisation because creating and
// deleting queues and topics is slow.
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var logger = TestHarnessLoggerFactory.Create();
var bus = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(CommonResources.ServiceBusConnectionString)
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.Build();
bus.ShouldNotBe(null);
await bus.Start();
return bus;
}));
}
public async Task ItShouldGoBangQuickly()
{
var typeProvider = new TestHarnessTypeProvider(new[] {GetType().Assembly}, new[] {GetType().Namespace});
var messageBroker = new DefaultMessageHandlerFactory(typeProvider);
var logger = new ConsoleLogger();
var bus = new BusBuilder().Configure()
.WithNames("IntegrationTestHarness", Environment.MachineName)
.WithConnectionString(@"Endpoint=sb://shouldnotexist.example.com/;SharedAccessKeyName=IntegrationTestHarness;SharedAccessKey=borkborkbork=")
.WithTypesFrom(typeProvider)
.WithCommandHandlerFactory(messageBroker)
.WithRequestHandlerFactory(messageBroker)
.WithMulticastEventHandlerFactory(messageBroker)
.WithCompetingEventHandlerFactory(messageBroker)
.WithMulticastRequestHandlerFactory(messageBroker)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.Build();
Should.Throw<BusException>(bus.Start);
}
protected override async Task <CommandMessageDispatcher> Given()
{
var clock = new SystemClock();
var logger = new ConsoleLogger();
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var serializer = new DataContractSerializer(typeProvider);
var replyQueueNameSetting = new ReplyQueueNameSetting(
new ApplicationNameSetting {
Value = "TestApplication"
},
new InstanceNameSetting {
Value = "TestInstance"
});
var handlerMap = new HandlerMapper(typeProvider).GetFullHandlerMap(typeof(IHandleCommand <>));
_brokeredMessageFactory = new BrokeredMessageFactory(new DefaultMessageTimeToLiveSetting(),
new MaxLargeMessageSizeSetting(),
new MaxSmallMessageSizeSetting(),
replyQueueNameSetting,
clock,
new NullCompressor(),
new DispatchContextManager(),
new UnsupportedLargeMessageBodyStore(),
serializer,
typeProvider);
return(new CommandMessageDispatcher(_brokeredMessageFactory,
new SystemClock(),
new DependencyResolver(typeProvider),
new NullInboundInterceptorFactory(),
new NullLogger(),
handlerMap,
new DefaultMessageLockDurationSetting(),
new NimbusTaskFactory(new MaximumThreadPoolThreadsSetting(), new MinimumThreadPoolThreadsSetting(), logger),
Substitute.For <IPropertyInjector>()));
}
protected override async Task <Bus> Given()
{
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var logger = TestHarnessLoggerFactory.Create();
var largeMessageBodyStorage = new BlobStorageBuilder().Configure()
.UsingStorageAccountConnectionString(CommonResources.BlobStorageConnectionString)
.WithLogger(logger)
.Build();
var bus = new BusBuilder().Configure()
.WithNames("MyTestSuite", Environment.MachineName)
.WithConnectionString(CommonResources.ServiceBusConnectionString)
.WithTypesFrom(typeProvider)
.WithDefaultTimeout(TimeSpan.FromSeconds(10))
.WithLogger(logger)
.WithLargeMessageStorage(c => c.WithLargeMessageBodyStore(largeMessageBodyStorage)
.WithMaxSmallMessageSize(64 * 1024)
.WithMaxLargeMessageSize(10 * 1048576))
.WithDebugOptions(dc => dc.RemoveAllExistingNamespaceElementsOnStartup(
"I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
.Build();
await bus.Start();
return(bus);
}
protected override async Task <Bus> Given()
{
_logger = TestHarnessLoggerFactory.Create();
var typeProvider = new TestHarnessTypeProvider(new[] { GetType().Assembly }, new[] { GetType().Namespace });
var bus = new BusBuilder().Configure()
.WithTransport(new InProcessTransportConfiguration())
.WithNames("MyTestSuite", Environment.MachineName)
.WithTypesFrom(typeProvider)
.WithGlobalInboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IInboundInterceptor).IsAssignableFrom(t)).ToArray())
.WithGlobalOutboundInterceptorTypes(typeProvider.InterceptorTypes.Where(t => typeof(IOutboundInterceptor).IsAssignableFrom(t)).ToArray())
.WithDependencyResolver(new DependencyResolver(typeProvider))
.WithDefaultTimeout(TimeSpan.FromSeconds(TimeoutSeconds))
.WithLogger(_logger)
.WithDebugOptions(
dc =>
dc.RemoveAllExistingNamespaceElementsOnStartup(
"I understand this will delete EVERYTHING in my namespace. I promise to only use this for test suites."))
.Build();
await bus.Start();
return(bus);
}
