public EndpointCustomizationConfiguration()
{
UserDefinedConfigSections = new Dictionary<Type, object>();
TypesToExclude = new List<Type>();
TypesToInclude = new List<Type>();
PublisherMetadata = new PublisherMetadata();
}
static async Task ConfigureTestExecution(TestDependencyType type, EndpointConfiguration config, RunSettings settings, string endpointName, PublisherMetadata publisherMetadata)
{
var dependencyTypeString = type.ToString();
var dependencyType = settings.Get<Type>(dependencyTypeString);
var typeName = "ConfigureEndpoint" + dependencyType.Name;
var configurerType = Type.GetType(typeName, false);
if (configurerType == null)
{
throw new InvalidOperationException($"Acceptance Test project must include a non-namespaced class named '{typeName}' implementing {typeof(IConfigureEndpointTestExecution).Name}. See {typeof(ConfigureEndpointMsmqTransport).FullName} for an example.");
}
var configurer = Activator.CreateInstance(configurerType) as IConfigureEndpointTestExecution;
if (configurer == null)
{
throw new InvalidOperationException($"{typeName} does not implement {typeof(IConfigureEndpointTestExecution).Name}.");
}
await configurer.Configure(endpointName, config, settings, publisherMetadata).ConfigureAwait(false);
ActiveTestExecutionConfigurer cleaners;
var cleanerKey = "ConfigureTestExecution." + endpointName;
if (!settings.TryGet(cleanerKey, out cleaners))
{
cleaners = new ActiveTestExecutionConfigurer();
settings.Set(cleanerKey, cleaners);
}
cleaners.Add(configurer);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get<QueueBindings>();
var connectionString = settings.Get<string>("Transport.ConnectionString");
var transportConfig = configuration.UseTransport<MsmqTransport>();
transportConfig.ConnectionString(connectionString);
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
return Task.FromResult(0);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
if (configuration.IsSendOnly())
{
return(Task.FromResult(0));
}
var tablePrefix = TableNameCleaner.Clean(endpointName);
endpointHelper = new ConfigureEndpointHelper(configuration, tablePrefix, MsSqlSystemDataClientConnectionBuilder.Build, BuildSqlDialect.MsSqlServer, FilterTableExists);
var persistence = configuration.UsePersistence <SqlPersistence>();
persistence.ConnectionBuilder(MsSqlSystemDataClientConnectionBuilder.Build);
persistence.SqlDialect <SqlDialect.MsSqlServer>();
var subscriptions = persistence.SubscriptionSettings();
subscriptions.DisableCache();
persistence.DisableInstaller();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
storageDir = Path.Combine(@"c:\temp", "att_tests"); //can't use bindir since that will be to long on the build agents
//we want the tests to be exposed to concurrency
configuration.LimitMessageProcessingConcurrencyTo(PushRuntimeSettings.Default.MaxConcurrency);
var transport = configuration.UseTransport <LearningTransport>();
#if (MySQL)
transport.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
#endif
transport.StorageDirectory(storageDir);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UsePersistence <InMemoryPersistence>();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get <QueueBindings>();
var connectionString = settings.Get <string>("Transport.ConnectionString");
var transportConfig = configuration.UseTransport <MsmqTransport>();
transportConfig.ConnectionString(connectionString);
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
PreventInconclusiveTestsFromRunning(endpointName);
var transportConfig = configuration.UseTransport <SqsTransport>();
transportConfig.ConfigureSqsTransport(SetupFixture.SqsQueueNamePrefix);
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
// TODO: remove when AWS SDK bug is resolved https://github.com/aws/aws-sdk-net/issues/796
// The bug causes messages to be marked as in flight, but not delivered to the client.
// Wait for tests longer than the invisibility time to make sure messages are received.
settings.TestExecutionTimeout = TimeSpan.FromSeconds(40);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var containerConnectionString = @"Data Source=localhost;Initial Catalog=nsb;Integrated Security=True";
var replacementConnectionString = Environment.GetEnvironmentVariable("NServiceBus_SagaContention");
if (!string.IsNullOrEmpty(replacementConnectionString))
{
containerConnectionString = replacementConnectionString;
}
var persistence = configuration.UsePersistence <SqlPersistence>();
persistence.SqlDialect <SqlDialect.MsSqlServer>();
persistence.ConnectionBuilder(
connectionBuilder: () => new SqlConnection(containerConnectionString));
var subscriptions = persistence.SubscriptionSettings();
subscriptions.DisableCache();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var settingsHolder = configuration.GetSettings();
queueBindings = settingsHolder.Get <QueueBindings>();
var transportConfig = configuration.UseTransport <MsmqTransport>();
transportConfig.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
transportConfig.DisableConnectionCachingForSends();
settingsHolder.Set("NServiceBus.Transport.Msmq.MessageEnumeratorTimeout", TimeSpan.FromMilliseconds(10));
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
return(Task.FromResult(0));
}
public abstract Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata);
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UseSerialization <NewtonsoftSerializer>();
var transportConfig = configuration.UseTransport <AzureServiceBusTransport>();
transportConfig.UseForwardingTopology();
transportConfig.ConnectionString(ConnectionString);
transportConfig.Sanitization().UseStrategy <ValidateAndHashIfNeeded>();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
if (configuration.GetSettings().Get <bool>("Endpoint.SendOnly"))
{
return(Task.FromResult(0));
}
var statefulService = (StatefulService)TestContext.CurrentContext.Test.Properties.Get("StatefulService");
var persistence = configuration.UsePersistence <ServiceFabricPersistence>();
persistence.StateManager(statefulService.StateManager);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings runSettings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get <QueueBindings>();
settings = configuration.GetSettings();
settings.Set("SqlServer.SubscriptionTableQuotedQualifiedNameSetter", (Action <string>)SetSubscriptionTableName);
doNotCleanNativeSubscriptions = runSettings.TryGet <bool>("DoNotCleanNativeSubscriptions", out _);
connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
throw new Exception("The 'SqlServerTransportConnectionString' environment variable is not set.");
}
var transportConfig = configuration.UseTransport <SqlServerTransport>();
transportConfig.ConnectionString(connectionString);
transportConfig.SubscriptionSettings().DisableSubscriptionCache();
#if !NETFRAMEWORK
transportConfig.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
#endif
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
if (configuration.GetSettings().Get <bool>("Endpoint.SendOnly"))
{
return(Task.FromResult(0));
}
var persistence = configuration.UsePersistence <CosmosPersistence>();
persistence.DisableContainerCreation();
persistence.CosmosClient(SetupFixture.CosmosDbClient);
persistence.DatabaseName(SetupFixture.DatabaseName);
if (!settings.TryGet <DoNotRegisterDefaultPartitionKeyProvider>(out _))
{
configuration.RegisterComponents(services => services.AddSingleton <IPartitionKeyFromMessageExtractor, PartitionKeyProvider>());
}
if (!settings.TryGet <DoNotRegisterDefaultContainerInformationProvider>(out _))
{
configuration.RegisterComponents(services => services.AddSingleton <IContainerInformationFromMessagesExtractor, ContainerInformationProvider>());
}
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var containerConnectionString = Environment.GetEnvironmentVariable("NServiceBusStorageMongoDB_ConnectionString");
client = string.IsNullOrWhiteSpace(containerConnectionString) ? new MongoClient() : new MongoClient(containerConnectionString);
configuration.UsePersistence <MongoPersistence>()
.MongoClient(client)
.DatabaseName(databaseName)
.UseTransactions(false);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var testRunId = TestContext.CurrentContext.Test.ID;
string tempDir;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
// Under Windows, Path.GetTempPath() could return a very long path, such as C:\Users\UserName\AppData\Local\Temp\.
// This would add up to the overall path length that could exceed the maximum path length and cause an exception to be thrown.
// LearningTransport will create the folder in case it doesn't exist.
tempDir = @"c:\temp";
}
else
{
tempDir = Path.GetTempPath();
}
storageDir = Path.Combine(tempDir, testRunId);
//we want the tests to be exposed to concurrency
configuration.LimitMessageProcessingConcurrencyTo(PushRuntimeSettings.Default.MaxConcurrency);
configuration.UseTransport <LearningTransport>()
.StorageDirectory(storageDir);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
connectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = ConnectionString
};
var transport = configuration.UseTransport <RabbitMQTransport>();
transport.UseConventionalRoutingTopology();
transport.ConnectionString(connectionStringBuilder.ConnectionString);
queueBindings = configuration.GetSettings().Get <QueueBindings>();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var testRunId = TestContext.CurrentContext.Test.ID;
string tempDir;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
//can't use bin dir since that will be too long on the build agents
tempDir = @"c:\temp";
}
else
{
tempDir = Path.GetTempPath();
}
storageDir = Path.Combine(tempDir, testRunId);
configuration.UsePersistence <LearningPersistence, StorageType.Sagas>()
.SagaStorageDirectory(storageDir);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UseSerialization <NewtonsoftSerializer>();
var transportConfig = configuration.UseTransport <SqsTransport>();
transportConfig.ClientFactory(CreateSQSClient);
transportConfig.ClientFactory(CreateSnsClient);
S3BucketName = Environment.GetEnvironmentVariable(S3BucketEnvironmentVariableName);
if (!string.IsNullOrEmpty(S3BucketName))
{
var s3Configuration = transportConfig.S3(S3BucketName, S3Prefix);
s3Configuration.ClientFactory(CreateS3Client);
}
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration config, RunSettings settings, PublisherMetadata publisherMetadata)
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{ "NServiceBus/Persistence/NHibernate/connection.driver_class", "NHibernate.Driver.OracleManagedDataClientDriver" },
{ "NServiceBus/Persistence/NHibernate/dialect", "NHibernate.Dialect.Oracle10gDialect" },
{ "NServiceBus/Persistence/NHibernate/show_sql", "true" }
};
config.UsePersistence <NHibernatePersistence>()
.ConnectionString(@"Data Source=(DESCRIPTION=(ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = 127.0.0.1)(PORT = 1521)))(CONNECT_DATA = (SERVER = DEDICATED)(SERVICE_NAME = XE)));User Id=particular; Password=Welcome1; Enlist=dynamic")
.SagaTableNamingConvention(type =>
{
var tablename = DefaultTableNameConvention(type);
if (tablename.Length > 30) //Oracle limit and it has to start with an Alpha character
{
return(Create(tablename));
}
return(tablename);
});
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get <QueueBindings>();
connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
throw new Exception("The 'SqlServerTransportConnectionString' environment variable is not set.");
}
var transportConfig = configuration.UseTransport <SqlServerTransport>();
transportConfig.ConnectionString(connectionString);
#if !NET452
transportConfig.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
#endif
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UseSerialization <NewtonsoftSerializer>();
var transportConfig = configuration.UseTransport <AzureServiceBusTransport>();
transportConfig.ConnectionString(ConnectionString);
var endpointOrientedTopology = transportConfig.UseEndpointOrientedTopology();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
endpointOrientedTopology.RegisterPublisher(eventType, publisher.PublisherName);
}
}
transportConfig.Sanitization().UseStrategy <ValidateAndHashIfNeeded>();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var transport = configuration.UseTransport <AzureServiceBusTransport>();
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
transport.ConnectionString(connectionString);
transport.SubscriptionNameShortener(name => Shorten(name));
transport.RuleNameShortener(name => Shorten(name));
configuration.RegisterComponents(c => c.ConfigureComponent <TestIndependenceMutator>(DependencyLifecycle.SingleInstance));
configuration.Pipeline.Register("TestIndependenceBehavior", typeof(TestIndependenceSkipBehavior), "Skips messages not created during the current test.");
// w/o retries ASB will move attempted messages to the error queue right away, which will cause false failure.
// ScenarioRunner.PerformScenarios() verifies by default no messages are moved into error queue. If it finds any, it fails the test.
configuration.Recoverability().Immediate(retriesSettings => retriesSettings.NumberOfRetries(3));
return(Task.CompletedTask);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var connectionString = Environment.GetEnvironmentVariable("RabbitMQTransport_ConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
throw new Exception("The 'RabbitMQTransport_ConnectionString' environment variable is not set.");
}
connectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = connectionString
};
var transport = configuration.UseTransport <RabbitMQTransport>();
transport.ConnectionString(connectionStringBuilder.ConnectionString);
transport.UseConventionalRoutingTopology();
queueBindings = configuration.GetSettings().Get <QueueBindings>();
return(TaskEx.CompletedTask);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
if (configuration.GetSettings().Get <bool>("Endpoint.SendOnly"))
{
return(Task.FromResult(0));
}
var persistence = configuration.UsePersistence <CosmosPersistence>();
persistence.DisableContainerCreation();
persistence.CosmosClient(SetupFixture.CosmosDbClient);
persistence.DatabaseName(SetupFixture.DatabaseName);
persistence.DefaultContainer(SetupFixture.ContainerName, SetupFixture.PartitionPathKey);
var sagasConfiguration = persistence.Sagas();
sagasConfiguration.UsePessimisticLocking();
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get <QueueBindings>();
var transportConfig = configuration.UseTransport <SqlServerTransport>();
transportConfig.ConnectionString(ConnectionString);
#if !NET452
transportConfig.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
#endif
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var testRunId = TestContext.CurrentContext.Test.ID;
string tempDir;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
//can't use bin dir since that will be too long on the build agents
tempDir = @"c:\temp";
}
else
{
tempDir = Path.GetTempPath();
}
storageDir = Path.Combine(tempDir, testRunId);
//we want the tests to be exposed to concurrency
configuration.LimitMessageProcessingConcurrencyTo(PushRuntimeSettings.Default.MaxConcurrency);
configuration.UseTransport <LearningTransport>()
.StorageDirectory(storageDir);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var documentStore = GetDocumentStore();
databaseName = documentStore.Database;
configuration.GetSettings().Set(DefaultDocumentStoreKey, documentStore);
var persistenceExtensions = configuration.UsePersistence <RavenDBPersistence>()
.DoNotCacheSubscriptions()
.SetDefaultDocumentStore(documentStore);
configuration.GetSettings().Set(DefaultPersistenceExtensionsKey, persistenceExtensions);
Console.WriteLine("Created '{0}' database", documentStore.Database);
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
PreventInconclusiveTestsFromRunning(endpointName);
configuration.UseSerialization <NewtonsoftSerializer>();
var connectionString = TestUtility.DefaultConnectionString;
var topology = EnvironmentHelper.GetEnvironmentVariable("AzureServiceBusTransport.Topology");
configuration.GetSettings().Set("AzureServiceBus.AcceptanceTests.UsedTopology", topology);
var transportConfig = configuration.UseTransport <AzureServiceBusTransport>();
transportConfig.ConnectionString(connectionString);
if (topology == "ForwardingTopology")
{
transportConfig.UseForwardingTopology();
}
else
{
var endpointOrientedTopology = transportConfig.UseEndpointOrientedTopology();
if (topology == "EndpointOrientedMigrationTopology")
{
endpointOrientedTopology.EnableMigrationToForwardingTopology();
}
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
endpointOrientedTopology.RegisterPublisher(eventType, publisher.PublisherName);
}
}
// ATTs that that require publishers to be explicitly registered for the EndpointOrientedTopology
endpointOrientedTopology.RegisterPublisher(typeof(When_multi_subscribing_to_a_polymorphic_event.MyEvent1), TestConventions.EndpointNamingConvention(typeof(When_multi_subscribing_to_a_polymorphic_event.Publisher1)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multi_subscribing_to_a_polymorphic_event.MyEvent2), TestConventions.EndpointNamingConvention(typeof(When_multi_subscribing_to_a_polymorphic_event.Publisher2)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_to_scaled_out_subscribers.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_to_scaled_out_subscribers.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_event.Event), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multiple_versions_of_a_message_is_published.V1Event), TestConventions.EndpointNamingConvention(typeof(When_multiple_versions_of_a_message_is_published.V2Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multiple_versions_of_a_message_is_published.V2Event), TestConventions.EndpointNamingConvention(typeof(When_multiple_versions_of_a_message_is_published.V2Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_replying_to_saga_event.DidSomething), TestConventions.EndpointNamingConvention(typeof(When_replying_to_saga_event.SagaEndpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_started_by_base_event_from_other_saga.BaseEvent), TestConventions.EndpointNamingConvention(typeof(When_started_by_base_event_from_other_saga.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_started_by_event_from_another_saga.SomethingHappenedEvent), TestConventions.EndpointNamingConvention(typeof(When_started_by_event_from_another_saga.SagaThatPublishesAnEvent)));
//When_two_sagas_subscribe_to_the_same_event
endpointOrientedTopology.RegisterPublisher(typeof(When_two_sagas_subscribe_to_the_same_event.GroupPendingEvent), TestConventions.EndpointNamingConvention(typeof(When_two_sagas_subscribe_to_the_same_event.Publisher)));
// TODO: investigate why these tests that are intended for the ForwradingTopology only fail w/o publisher registration on EndpointOrientedTopology execution on build server
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.BaseEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.DerivedEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.MyOtherEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_from_sendonly.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_from_sendonly.SendOnlyPublisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_a_base_event.IBaseEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_a_base_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_a_derived_event.SpecificEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_a_derived_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_with_overridden_local_address.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_with_overridden_local_address.Publisher)));
// Both publisher and subscriber are the same endpoint with overridden endpoint name. We can't detect both from the message type.
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_and_subscribing_to_self_with_overridden_address.MyEvent), "myinputqueue");
}
transportConfig.Sanitization()
.UseStrategy <ValidateAndHashIfNeeded>();
configuration.RegisterComponents(c => { c.ConfigureComponent <TestIndependenceMutator>(DependencyLifecycle.SingleInstance); });
configuration.Pipeline.Register("TestIndependenceBehavior", typeof(TestIndependenceSkipBehavior),
"Skips messages not created during the current test.");
// w/o retries ASB will move attempted messages to the error queue right away, which will cause false failure.
// ScenarioRunner.PerformScenarios() verifies by default no messages are moved into error queue. If it finds any, it fails the test.
configuration.Recoverability().Immediate(retriesSettings => retriesSettings.NumberOfRetries(3));
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
#pragma warning disable 0618
configuration.UsePersistence <InMemoryPersistence>()
.GatewayDeduplicationCacheSize(100);
#pragma warning restore 0618
return(Task.FromResult(0));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
if (configuration.IsSendOnly())
{
return(Task.FromResult(0));
}
var tablePrefix = TableNameCleaner.Clean(endpointName).Substring(0, Math.Min(endpointName.Length, 35));
endpointHelper = new ConfigureEndpointHelper(configuration, tablePrefix, MySqlConnectionBuilder.Build, BuildSqlDialect.MySql);
var persistence = configuration.UsePersistence <SqlPersistence>();
persistence.ConnectionBuilder(MySqlConnectionBuilder.Build);
persistence.SqlDialect <SqlDialect.MySql>();
persistence.TablePrefix($"{tablePrefix}_");
var subscriptions = persistence.SubscriptionSettings();
subscriptions.DisableCache();
persistence.DisableInstaller();
return(Task.FromResult(0));
}
static async Task ConfigureTestExecution(TestDependencyType type, EndpointConfiguration config, RunSettings settings, string endpointName, PublisherMetadata publisherMetadata)
{
var dependencyTypeString = type.ToString();
var dependencyType = settings.Get <Type>(dependencyTypeString);
var typeName = "ConfigureEndpoint" + dependencyType.Name;
var configurerType = Type.GetType(typeName, false);
if (configurerType == null)
{
throw new InvalidOperationException($"Acceptance Test project must include a non-namespaced class named '{typeName}' implementing {typeof(IConfigureEndpointTestExecution).Name}. See {typeof(ConfigureEndpointMsmqTransport).FullName} for an example.");
}
var configurer = Activator.CreateInstance(configurerType) as IConfigureEndpointTestExecution;
if (configurer == null)
{
throw new InvalidOperationException($"{typeName} does not implement {typeof(IConfigureEndpointTestExecution).Name}.");
}
await configurer.Configure(endpointName, config, settings, publisherMetadata).ConfigureAwait(false);
ActiveTestExecutionConfigurer cleaners;
var cleanerKey = "ConfigureTestExecution." + endpointName;
if (!settings.TryGet(cleanerKey, out cleaners))
{
cleaners = new ActiveTestExecutionConfigurer();
settings.Set(cleanerKey, cleaners);
}
cleaners.Add(configurer);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UsePersistence<InMemoryPersistence>();
return Task.FromResult(0);
}
