public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.EnableInstallers();
configuration.DisableFeature <TimeoutManager>();
configuration.Pipeline.Register(new StampDispatchBehavior(runDescriptor.ScenarioContext), "Stamps outgoing messages with session ID");
configuration.Pipeline.Register(new DiscardMessagesBehavior(runDescriptor.ScenarioContext), "Discards messages based on session ID");
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
await configuration.DefineTransport(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
await configuration.DefinePersistence(runDescriptor, endpointConfiguration).ConfigureAwait(false);
typeof(ScenarioContext).GetProperty("CurrentEndpoint", BindingFlags.Static | BindingFlags.NonPublic).SetValue(runDescriptor.ScenarioContext, endpointConfiguration.EndpointName);
configurationBuilderCustomization(configuration);
return(configuration);
}
public Task <ComponentRunner> CreateRunner(RunDescriptor run)
{
var config = configCallback(run.ScenarioContext);
config.Settings.Set <ScenarioContext>(run.ScenarioContext);
config.AutoCreateQueues();
var newFactories = new List <Func <Interface> >();
foreach (var factory in config.InterfaceFactories)
{
Interface NewFactory()
{
var port = factory();
return(port);
}
newFactories.Add(NewFactory);
}
config.InterfaceFactories = newFactories;
var @switch = Router.Create(config);
return(Task.FromResult <ComponentRunner>(new Runner(@switch, "Router")));
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource)
{
var settings = runDescriptor.Settings;
SetupLogging(endpointConfiguration);
var types = GetTypesToUse(endpointConfiguration);
var transportToUse = settings.GetOrNull("Transport");
Configure.Features.Enable<Features.Sagas>();
SettingsHolder.SetDefault("ScaleOut.UseSingleBrokerQueue", true);
var config = Configure.With(types)
.DefineEndpointName(endpointConfiguration.EndpointName)
.CustomConfigurationSource(configSource)
.DefineBuilder(settings.GetOrNull("Builder"))
.DefineSerializer(settings.GetOrNull("Serializer"))
.DefineTransport(settings)
.DefineSagaPersister(settings.GetOrNull("SagaPersister"));
if (transportToUse == null ||
transportToUse.Contains("Msmq") ||
transportToUse.Contains("SqlServer") ||
transportToUse.Contains("RabbitMq"))
config.UseInMemoryTimeoutPersister();
if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer"))
config.DefineSubscriptionStorage(settings.GetOrNull("SubscriptionStorage"));
return config.UnicastBus();
}
public override Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
return(base.GetConfiguration(runDescriptor, endpointCustomizationConfiguration, endpointConfiguration =>
{
configurationBuilderCustomization(endpointConfiguration);
}));
}
public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var endpointConfiguration = new EndpointConfiguration(endpointCustomizationConfiguration.EndpointName);
endpointConfiguration.TypesToIncludeInScan(endpointCustomizationConfiguration.GetTypesScopedByTestClass());
endpointConfiguration.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
var storageDir = Path.Combine(NServiceBusAcceptanceTest.StorageRootDir, TestContext.CurrentContext.Test.ID);
endpointConfiguration.UseTransport <LearningTransport>()
.StorageDirectory(storageDir);
if (ConfigureStorage)
{
endpointConfiguration.UsePersistence <InMemoryPersistence, StorageType.GatewayDeduplication>();
}
endpointConfiguration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configurationBuilderCustomization(endpointConfiguration);
return(Task.FromResult(endpointConfiguration));
}
public async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization)
{
var settings = runDescriptor.Settings;
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DisableFeature<TimeoutManager>();
builder.Recoverability().Delayed(cfg => cfg.NumberOfRetries(0));
builder.Recoverability().Immediate(cfg => cfg.NumberOfRetries(0));
await builder.DefineTransport(settings, endpointConfiguration.EndpointName).ConfigureAwait(false);
builder.DefineBuilder(settings);
builder.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
Type serializerType;
if (settings.TryGet("Serializer", out serializerType))
{
builder.UseSerialization((SerializationDefinition) Activator.CreateInstance(serializerType));
}
await builder.DefinePersistence(settings, endpointConfiguration.EndpointName).ConfigureAwait(false);
builder.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configurationBuilderCustomization(builder);
return builder;
}
public async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization)
{
var settings = runDescriptor.Settings;
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.CustomConfigurationSource(configSource);
configuration.EnableInstallers();
configuration.DisableFeature<TimeoutManager>();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
await configuration.DefineTransport(settings, endpointConfiguration.EndpointName).ConfigureAwait(false);
configuration.DefineBuilder(settings);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configuration.UseSerialization<WireSerializer>();
await configuration.DefinePersistence(settings, endpointConfiguration.EndpointName).ConfigureAwait(false);
configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configurationBuilderCustomization(configuration);
return configuration;
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
Configure.ScaleOut(_ => _.UseSingleBrokerQueue());
new Bootstrapper();
//We need this hack here because by default we include all assemblies minus Plugins but for these tests we need to exclude other tests!
for (var index = 0; index < Configure.TypesToScan.Count;)
{
var type = Configure.TypesToScan[index];
if (type.Assembly != Assembly.GetExecutingAssembly())
{
index++;
continue;
}
if (!(type.DeclaringType == endpointConfiguration.BuilderType.DeclaringType ||
type.DeclaringType == endpointConfiguration.BuilderType))
{
Configure.TypesToScan.RemoveAt(index);
}
else
{
index++;
}
}
LogManager.Configuration = SetupLogging(endpointConfiguration);
return(Configure.Instance);
}
#pragma warning disable PS0018 // A task-returning method should have a CancellationToken parameter unless it has a parameter implementing ICancellableContext
#pragma warning disable PS0013 // A Func used as a method parameter with a Task, ValueTask, or ValueTask<T> return type argument should have at least one CancellationToken parameter type argument unless it has a parameter type argument implementing ICancellableContext
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Func <EndpointConfiguration, Task> configurationBuilderCustomization)
#pragma warning restore PS0013 // A Func used as a method parameter with a Task, ValueTask, or ValueTask<T> return type argument should have at least one CancellationToken parameter type argument unless it has a parameter type argument implementing ICancellableContext
#pragma warning restore PS0018 // A task-returning method should have a CancellationToken parameter unless it has a parameter implementing ICancellableContext
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.EnableInstallers();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
await configuration.DefineTransport(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
await configuration.DefinePersistence(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
await configurationBuilderCustomization(configuration);
return(configuration);
}
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.EnableInstallers();
configuration.DisableFeature <TimeoutManager>();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
await configuration.DefineTransport(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
await configuration.DefinePersistence(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configurationBuilderCustomization(configuration);
return(configuration);
}
public async Task <ComponentRunner> CreateRunner(RunDescriptor run)
{
runner = new ServiceControlComponentRunner(instanceNames, transportIntegration, setSettings, setInstanceSettings, customConfiguration, customInstanceConfiguration);
await runner.Initialize(run).ConfigureAwait(false);
return(runner);
}
public BusConfiguration GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource, Action<BusConfiguration> configurationBuilderCustomization)
{
var settings = runDescriptor.Settings;
LogManager.UseFactory(new ContextAppender(runDescriptor.ScenarioContext, endpointConfiguration.EndpointName));
var types = GetTypesScopedByTestClass(endpointConfiguration);
typesToInclude.AddRange(types);
var builder = new BusConfiguration();
builder.EndpointName(endpointConfiguration.EndpointName);
builder.TypesToScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DefineTransport(settings, endpointConfiguration.BuilderType);
builder.DefineTransactions(settings);
builder.DefineBuilder(settings);
builder.RegisterComponents(r =>
{
r.RegisterSingleton(runDescriptor.ScenarioContext.GetType(), runDescriptor.ScenarioContext);
r.RegisterSingleton(typeof(ScenarioContext), runDescriptor.ScenarioContext);
});
SetSerializer(settings, builder);
builder.DefinePersistence(settings);
builder.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configurationBuilderCustomization(builder);
return builder;
}
protected override Task <EndpointConfiguration> OnGetConfiguration(RunDescriptor runDescriptor,
EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var factory = new ConfigurationFactory();
return(Task.FromResult(factory.CreateConfiguration()));
}
public Task <EndpointConfiguration> GetConfiguration(
RunDescriptor runDescriptor,
EndpointCustomizationConfiguration endpointConfiguration,
Action <EndpointConfiguration> configurationBuilderCustomization)
{
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(endpointConfiguration.GetTypesScopedByTestClass());
configuration.EnableInstallers();
configuration.DisableFeature <TimeoutManager>();
configuration.RegisterComponents(c => c
.RegisterSingleton(runDescriptor.ScenarioContext.GetType(), runDescriptor.ScenarioContext));
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
var transport = configuration.UseTransport <AzureStorageQueueTransport>();
transport.ConnectionString(Environment.GetEnvironmentVariable(StorageQueueTriggeredEndpointConfiguration.DefaultStorageConnectionString));
configuration.UseSerialization <NewtonsoftSerializer>();
configurationBuilderCustomization(configuration);
return(Task.FromResult(configuration));
}
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var endpointConfiguration = new EndpointConfiguration(endpointCustomizationConfiguration.EndpointName);
endpointConfiguration.TypesToIncludeInScan(endpointCustomizationConfiguration.GetTypesScopedByTestClass());
endpointConfiguration.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
var storageDir = Path.Combine(NServiceBusAcceptanceTest.StorageRootDir, TestContext.CurrentContext.Test.ID);
endpointConfiguration.EnableInstallers();
endpointConfiguration.UseTransport <LearningTransport>()
.StorageDirectory(storageDir);
if (ConfigureStorage)
{
var persistenceConfiguration = GatewayTestSuiteConstraints.Current.CreatePersistenceConfiguration();
await persistenceConfiguration.Configure(endpointCustomizationConfiguration.EndpointName, endpointConfiguration, runDescriptor.Settings).ConfigureAwait(false);
runDescriptor.OnTestCompleted(_ => persistenceConfiguration.Cleanup());
}
endpointConfiguration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configurationBuilderCustomization(endpointConfiguration);
return(endpointConfiguration);
}
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(types);
configuration.EnableInstallers();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
var transportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(useNativePubSub, true);
await transportConfiguration.Configure(endpointConfiguration.EndpointName, configuration, runDescriptor.Settings, endpointConfiguration.PublisherMetadata);
runDescriptor.OnTestCompleted(_ => transportConfiguration.Cleanup());
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
var persistenceConfiguration = new ConfigureEndpointAcceptanceTestingPersistence();
await persistenceConfiguration.Configure(endpointConfiguration.EndpointName, configuration, runDescriptor.Settings, endpointConfiguration.PublisherMetadata);
runDescriptor.OnTestCompleted(_ => persistenceConfiguration.Cleanup());
configurationBuilderCustomization(configuration);
return(configuration);
}
public async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization)
{
var settings = runDescriptor.Settings;
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DisableFeature<TimeoutManager>();
builder.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
await builder.DefineTransport(settings, endpointConfiguration.EndpointName).ConfigureAwait(false);
builder.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configurationBuilderCustomization(builder);
return builder;
}
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Func <EndpointConfiguration, Task> configurationBuilderCustomization)
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.EnableInstallers();
configuration.UsePersistence <AcceptanceTestingPersistence>();
var storageDir = Path.Combine(NServiceBusAcceptanceTest.StorageRootDir, NUnit.Framework.TestContext.CurrentContext.Test.ID);
configuration.UseTransport(new LearningTransport {
StorageDirectory = storageDir
});
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
await configurationBuilderCustomization(configuration);
return(configuration);
}
public static async Task DefineTransport(this EndpointConfiguration config, RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration)
{
var transportConfiguration = new ConfigureEndpointLearningTransport();
await transportConfiguration.Configure(endpointCustomizationConfiguration.EndpointName, config, runDescriptor.Settings, endpointCustomizationConfiguration.PublisherMetadata);
runDescriptor.OnTestCompleted(_ => transportConfiguration.Cleanup());
}
static IEnumerable<RunDescriptor> GetAllAvailable()
{
var foundTransportDefinitions = TypeScanner.GetAllTypesAssignableTo<TransportDefinition>();
foreach (var transportDefinitionType in foundTransportDefinitions)
{
var key = transportDefinitionType.Name;
var runDescriptor = new RunDescriptor
{
Key = key,
Settings =
new Dictionary<string, string>
{
{"Transport", transportDefinitionType.AssemblyQualifiedName}
}
};
var connectionString = Environment.GetEnvironmentVariable(key + ".ConnectionString");
if (string.IsNullOrEmpty(connectionString) && DefaultConnectionStrings.ContainsKey(key))
connectionString = DefaultConnectionStrings[key];
if (!string.IsNullOrEmpty(connectionString))
{
runDescriptor.Settings.Add("Transport.ConnectionString", connectionString);
yield return runDescriptor;
}
}
}
public async Task <ComponentRunner> CreateRunner(RunDescriptor run)
{
runner = new ServiceControlComponentRunner(transportIntegration, customEndpointConfiguration, customAuditEndpointConfiguration, customServiceControlSettings, customServiceControlAuditSettings);
await runner.Initialize(run).ConfigureAwait(false);
return(runner);
}
public static async Task DefineTransport(this EndpointConfiguration config, RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration)
{
var transportConfiguration = TestSuiteConstraints.Current.CreateTransportConfiguration();
await transportConfiguration.Configure(endpointCustomizationConfiguration.EndpointName, config, runDescriptor.Settings, endpointCustomizationConfiguration.PublisherMetadata);
runDescriptor.OnTestCompleted(_ => transportConfiguration.Cleanup());
}
public Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization)
{
var types = GetTypesScopedByTestClass(endpointConfiguration);
typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DisableFeature<TimeoutManager>();
builder.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
builder.UsePersistence<InMemoryPersistence>();
configurationBuilderCustomization(builder);
return Task.FromResult(builder);
}
public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
var types = GetTypesScopedByTestClass(endpointConfiguration);
builder.TypesToIncludeInScan(types);
var transportIntegration = NServiceBusAcceptanceTest.TransportIntegration;
transportIntegration.Configure(endpointConfiguration.EndpointName, builder);
builder.Recoverability().Delayed(delayedRetries => delayedRetries.NumberOfRetries(0));
builder.Recoverability().Immediate(immediateRetries => immediateRetries.NumberOfRetries(0));
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
builder.UseSerialization <NewtonsoftSerializer>();
builder.SendFailedMessagesTo("error");
builder.UsePersistence <InMemoryPersistence>();
builder.EnableInstallers();
configurationBuilderCustomization(builder);
runDescriptor.OnTestCompleted(_ => transportIntegration.Cleanup());
return(Task.FromResult(builder));
}
public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = GetTypesScopedByTestClass(endpointConfiguration);
typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DisableFeature <TimeoutManager>();
builder.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
builder.UsePersistence <InMemoryPersistence>();
configurationBuilderCustomization(builder);
return(Task.FromResult(builder));
}
public async Task <TContext> Run(RunSettings settings)
{
var scenarioContext = new TContext();
contextInitializer(scenarioContext);
var runDescriptor = new RunDescriptor(scenarioContext);
runDescriptor.Settings.Merge(settings);
ScenarioContext.Current = scenarioContext;
LogManager.UseFactory(Scenario.GetLoggerFactory(scenarioContext));
var sw = new Stopwatch();
sw.Start();
var runSummary = await ScenarioRunner.Run(runDescriptor, behaviors, done).ConfigureAwait(false);
sw.Stop();
await runDescriptor.RaiseOnTestCompleted(runSummary);
DisplayRunResult(runSummary);
TestContext.WriteLine("Total time for testrun: {0}", sw.Elapsed);
if (runSummary.Result.Failed)
{
PrintLog(scenarioContext);
runSummary.Result.Exception.Throw();
}
return((TContext)runDescriptor.ScenarioContext);
}
#pragma warning disable CS0618
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action <EndpointConfiguration> configurationBuilderCustomization)
#pragma warning restore CS0618
{
var settings = runDescriptor.Settings;
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(typesToInclude);
builder.CustomConfigurationSource(configSource);
builder.EnableInstallers();
builder.DisableFeature <TimeoutManager>();
builder.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
builder.SendFailedMessagesTo("error");
await builder.DefineTransport(settings, endpointConfiguration).ConfigureAwait(false);
builder.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configurationBuilderCustomization(builder);
return(builder);
}
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.EnableInstallers();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
await configuration.DefineTransport(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
await configuration.DefinePersistence(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configurationBuilderCustomization(configuration);
return(configuration);
}
public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
var types = GetTypesScopedByTestClass(endpointConfiguration);
builder.TypesToIncludeInScan(types);
var transport = builder.UseTransport <Transports.AmazonSQS.ServiceControlSqsTransport>()
.ConnectionString(ConnectionString);
var routingConfig = transport.Routing();
foreach (var publisher in endpointConfiguration.PublisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
builder.EnableInstallers();
builder.UsePersistence <InMemoryPersistence>();
builder.Recoverability().Delayed(delayedRetries => delayedRetries.NumberOfRetries(0));
builder.Recoverability().Immediate(immediateRetries => immediateRetries.NumberOfRetries(0));
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
configurationBuilderCustomization(builder);
return(Task.FromResult(builder));
}
public static Task DefineTransport(this EndpointConfiguration config, RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration)
{
//var transportConfiguration = new ConfigureEndpointMsmqTransport();
//await transportConfiguration.Configure(endpointCustomizationConfiguration.EndpointName, config, runDescriptor.Settings, endpointCustomizationConfiguration.PublisherMetadata);
//runDescriptor.OnTestCompleted(_ => transportConfiguration.Cleanup());
return(Task.CompletedTask);
}
public async Task <TContext> Run(RunSettings settings)
{
var scenarioContext = new TContext();
contextInitializer(scenarioContext);
var runDescriptor = new RunDescriptor
{
ScenarioContext = scenarioContext
};
runDescriptor.Settings.Merge(settings);
LogManager.UseFactory(new ContextAppenderFactory());
var sw = new Stopwatch();
sw.Start();
await ScenarioRunner.Run(runDescriptor, behaviors, done).ConfigureAwait(false);
sw.Stop();
Console.WriteLine("Total time for testrun: {0}", sw.Elapsed);
return((TContext)runDescriptor.ScenarioContext);
}
static IEnumerable <RunDescriptor> GetAllAvailable()
{
var foundTransportDefinitions = TypeScanner.GetAllTypesAssignableTo <TransportDefinition>();
foreach (var transportDefinitionType in foundTransportDefinitions)
{
var key = transportDefinitionType.Name;
var runDescriptor = new RunDescriptor
{
Key = key,
Settings =
new Dictionary <string, string>
{
{ "Transport", transportDefinitionType.AssemblyQualifiedName }
}
};
var connectionString = Environment.GetEnvironmentVariable(key + ".ConnectionString");
if (string.IsNullOrEmpty(connectionString) && DefaultConnectionStrings.ContainsKey(key))
{
connectionString = DefaultConnectionStrings[key];
}
if (!string.IsNullOrEmpty(connectionString))
{
runDescriptor.Settings.Add("Transport.ConnectionString", connectionString);
yield return(runDescriptor);
}
}
}
public Task <ComponentRunner> CreateRunner(RunDescriptor run)
{
config.AutoCreateQueues();
var bridge = config.Create();
return(Task.FromResult <ComponentRunner>(new Runner(bridge, $"{config.LeftName}<->{config.RightName}")));
}
public virtual Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var endpointConfiguration = new EndpointConfiguration(endpointCustomizationConfiguration.EndpointName);
endpointConfiguration.TypesToIncludeInScan(endpointCustomizationConfiguration.GetTypesScopedByTestClass());
endpointConfiguration.Recoverability()
.Delayed(delayed => delayed.NumberOfRetries(0))
.Immediate(immediate => immediate.NumberOfRetries(0));
var storageDir = Path.Combine(RavenDBAcceptanceTest.StorageRootDir, TestContext.CurrentContext.Test.ID);
endpointConfiguration.EnableInstallers();
var transport = endpointConfiguration.UseTransport <AcceptanceTestingTransport>();
transport.StorageDirectory(storageDir);
transport.UseNativeDelayedDelivery(false);
endpointConfiguration.EnableFeature <TimeoutManager>();
endpointConfiguration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configurationBuilderCustomization(endpointConfiguration);
return(Task.FromResult(endpointConfiguration));
}
#pragma warning disable CS0618
public async Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action <EndpointConfiguration> configurationBuilderCustomization)
#pragma warning restore CS0618
{
var types = endpointConfiguration.GetTypesScopedByTestClass();
typesToInclude.AddRange(types);
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(typesToInclude);
configuration.CustomConfigurationSource(configSource);
configuration.EnableInstallers();
configuration.DisableFeature <TimeoutManager>();
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
await configuration.DefineTransport(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.RegisterComponentsAndInheritanceHierarchy(runDescriptor);
configuration.UseSerialization <MessagePackSerializer>();
await configuration.DefinePersistence(runDescriptor, endpointConfiguration).ConfigureAwait(false);
configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configurationBuilderCustomization(configuration);
return(configuration);
}
public Task <EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var types = GetTypesScopedByTestClass(endpointConfiguration);
_typesToInclude.AddRange(types);
var builder = new EndpointConfiguration(endpointConfiguration.EndpointName);
builder.TypesToIncludeInScan(_typesToInclude);
builder.EnableInstallers();
builder.UseTransport <LearningTransport>();
builder.DisableFeature <TimeoutManager>();
builder.UsePersistence <InMemoryPersistence>();
if (_services != null)
{
builder.UseContainer <ServicesBuilder>(c => c.ExistingServices(_services));
}
else
{
builder.UseContainer <ServicesBuilder>();
}
builder.Recoverability().Immediate(immediateRetries => immediateRetries.NumberOfRetries(0));
builder.Recoverability().Delayed(delayedRetires => delayedRetires.NumberOfRetries(0));
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
configurationBuilderCustomization(builder);
return(Task.FromResult(builder));
}
protected override Task <EndpointConfiguration> OnGetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Action <EndpointConfiguration> configurationBuilderCustomization)
{
var config = MyOtherServiceConfigurationBuilder.Build(
"MyOtherService",
"host=localhost;username=guest;password=guest");
return(Task.FromResult(config));
}
static void RegisterInheritanceHierarchyOfContextOnContainer(RunDescriptor runDescriptor, IConfigureComponents r)
{
var type = runDescriptor.ScenarioContext.GetType();
while (type != typeof(object))
{
r.RegisterSingleton(type, runDescriptor.ScenarioContext);
type = type.BaseType;
}
}
static IEnumerable<RunDescriptor> GetAllAvailable()
{
foreach (var builder in foundDefinitions.Value)
{
var descriptor = new RunDescriptor(builder.Name);
descriptor.Settings.Set("Builder", builder);
yield return descriptor;
}
}
static IEnumerable<RunDescriptor> GetAllAvailable()
{
var foundDefinitions = TypeScanner.GetAllTypesAssignableTo<PersistenceDefinition>();
foreach (var definition in foundDefinitions)
{
var key = definition.Name;
var runDescriptor = new RunDescriptor
{
Key = key,
Settings =
new Dictionary<string, string>
{
{"Persistence", definition.AssemblyQualifiedName}
}
};
yield return runDescriptor;
}
}
public static void RegisterComponentsAndInheritanceHierarchy(this EndpointConfiguration builder, RunDescriptor runDescriptor)
{
builder.RegisterComponents(r => { RegisterInheritanceHierarchyOfContextOnContainer(runDescriptor, r); });
}
public Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, IConfigurationSource configSource, Action<EndpointConfiguration> configurationBuilderCustomization)
{
return new DefaultServer().GetConfiguration(runDescriptor, endpointConfiguration, configSource, configurationBuilderCustomization);
}
public void Merge(RunDescriptor descriptorToAdd)
{
Key += "." + descriptorToAdd.Key;
Settings.Merge(descriptorToAdd.Settings);
}
protected bool Equals(RunDescriptor other)
{
return string.Equals(Key, other.Key);
}
public RunDescriptor(RunDescriptor template)
{
Settings = new RunSettings();
Settings.Merge(template.Settings);
Key = template.Key;
}
