public static void DefineBuilder(this EndpointConfiguration config, RunSettings settings)
{
Type builderType;
if (!settings.TryGet("Builder", out builderType))
{
var builderDescriptor = Builders.Default;
if (builderDescriptor == null)
{
return; //go with the default builder
}
settings.Merge(builderDescriptor.Settings);
}
builderType = settings.Get<Type>("Builder");
var typeName = "Configure" + builderType.Name;
var configurerType = Type.GetType(typeName, false);
if (configurerType != null)
{
var configurer = Activator.CreateInstance(configurerType);
dynamic dc = configurer;
dc.Configure(config);
}
config.UseContainer(builderType);
}
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 static Task DefineTransport(this EndpointConfiguration config, RunSettings settings, EndpointCustomizationConfiguration endpointCustomizationConfiguration)
{
Type transportType;
if (!settings.TryGet("Transport", out transportType))
{
settings.Merge(Transports.Default.Settings);
}
return ConfigureTestExecution(TestDependencyType.Transport, config, settings, endpointCustomizationConfiguration.EndpointName, endpointCustomizationConfiguration.PublisherMetadata);
}
public static Task DefinePersistence(this EndpointConfiguration config, RunSettings settings, EndpointCustomizationConfiguration endpointCustomizationConfiguration)
{
Type persistenceType;
if (!settings.TryGet("Persistence", out persistenceType))
{
settings.Merge(Persistence.Default.Settings);
}
return ConfigureTestExecution(TestDependencyType.Persistence, config, settings, endpointCustomizationConfiguration.EndpointName, endpointCustomizationConfiguration.PublisherMetadata);
}
public static Task DefineTransport(this EndpointConfiguration config, RunSettings settings, string endpointName)
{
Type transportType;
if (!settings.TryGet("Transport", out transportType))
{
settings.Merge(Transports.Default.Settings);
}
return ConfigureTestExecution(TestDependencyType.Transport, config, settings, endpointName);
}
public static Task DefinePersistence(this EndpointConfiguration config, RunSettings settings, string endpointName)
{
Type persistenceType;
if (!settings.TryGet("Persistence", out persistenceType))
{
settings.Merge(Persistence.Default.Settings);
}
return ConfigureTestExecution(TestDependencyType.Persistence, config, settings, endpointName);
}
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));
}
/// <summary>
/// The main entry point for the application. This instantiates and runs our game (within XAGE.Engine.Core.dll)
/// </summary>
static void Main(string[] args)
{
// Must do this before anything else
DllMap.Initialise();
// Create Script Delegates that get injected into the engine
RunSettings runSettings = new RunSettings(
Release,
AllowDebugging,
LogLevel,
LogAsync,
OnNotImplemented,
LastnFurious.CSharpScript.Load,
LastnFurious.CSharpScript.Serialize,
LastnFurious.CSharpScript.Deserialize,
typeof(LastnFurious.CSharpScript));
// Run the game - any unhandled exceptions will be caught in Release mode only
// In Debug mode it will stop in place, which is generally more useful for debugging
try
{
using (XNAGame game = new XNAGame(runSettings))
{
game.Run();
}
}
catch (Exception exc) when(CatchFatalExceptions)
{
Logger.Fatal("Unhandled exception: " + exc.Message);
Logger.Fatal("StackTrace: " + exc.StackTrace);
}
finally
{
Logger.Reset();
}
}
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
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 void InitializeShouldEnableMultipleCollectorsWhenCalledMoreThanOnce()
{
var runsettingsString = string.Format(DefaultRunSettings, string.Empty);
var runsettings = new RunSettings();
runsettings.LoadSettingsXml(runsettingsString);
this.settingsProvider.SetActiveRunSettings(runsettings);
this.executor.Initialize("MyDataCollector");
this.executor.Initialize("MyDataCollector1");
Assert.AreEqual(string.Join(Environment.NewLine,
"<?xml version=\"1.0\" encoding=\"utf-16\"?>",
"<RunSettings>",
" <RunConfiguration>",
" <TestAdaptersPaths>c:\\AdapterFolderPath</TestAdaptersPaths>",
" </RunConfiguration>",
" <DataCollectionRunSettings>",
" <DataCollectors>",
" <DataCollector friendlyName=\"MyDataCollector\" enabled=\"True\" />",
" <DataCollector friendlyName=\"MyDataCollector1\" enabled=\"True\" />",
" </DataCollectors>",
" </DataCollectionRunSettings>",
"</RunSettings>"), this.settingsProvider.ActiveRunSettings.SettingsXml);
}
public void InitializeShouldCreateEntryForDataCollectorInRunSettingsIfNotAlreadyPresent()
{
var runsettingsString = string.Format(DefaultRunSettings, "");
var runsettings = new RunSettings();
runsettings.LoadSettingsXml(runsettingsString);
this.settingsProvider.SetActiveRunSettings(runsettings);
this.executor.Initialize("MyDataCollector");
Assert.IsNotNull(this.settingsProvider.ActiveRunSettings);
Assert.AreEqual(string.Join(Environment.NewLine,
"<?xml version=\"1.0\" encoding=\"utf-16\"?>",
"<RunSettings>",
" <RunConfiguration>",
" <TestAdaptersPaths>c:\\AdapterFolderPath</TestAdaptersPaths>",
" </RunConfiguration>",
" <DataCollectionRunSettings>",
" <DataCollectors>",
" <DataCollector friendlyName=\"MyDataCollector\" enabled=\"True\" />",
" </DataCollectors>",
" </DataCollectionRunSettings>",
"</RunSettings>"), this.settingsProvider.ActiveRunSettings.SettingsXml);
}
/// <summary>
/// Main app run point
/// Due to depency with static Console this proved to be untestable
/// To be fixed
/// </summary>
public void Run(RunSettings runSettings)
{
Console.WriteLine($"Starting in {runSettings.Mode} mode...");
echoApp = echoAppFactory.GetEchoApp(runSettings.Mode);
Console.WriteLine("Attempting to connect...");
echoApp.MessageHandler = Console.WriteLine;
echoApp.Start(runSettings);
while (true)
{
Console.WriteLine("Enter a message to send and press enter or enter exit to stop the the program");
var input = Console.ReadLine();
if (input == "exit")
{
echoApp.Stop();
Console.WriteLine("Press any key to exit");
break;
}
var messageSentSuccessfully = echoApp.SendMessage(input);
if (!messageSentSuccessfully)
{
Console.WriteLine($"Could not send message {input}");
}
}
}
public void DiscoverTests(IEnumerable <string> executables, IDiscoveryContext discoveryContext,
IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
ILogger loggerAdapter = new VsTestFrameworkLogger(logger);
if (TestEnvironment == null || TestEnvironment.Options.GetType() == typeof(Options)) // check whether we have a mock
{
var settingsProvider = discoveryContext.RunSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
RunSettings ourRunSettings = settingsProvider != null ? settingsProvider.Settings : new RunSettings();
TestEnvironment = new TestEnvironment(new Options(ourRunSettings, loggerAdapter), loggerAdapter);
Discoverer = new GoogleTestDiscoverer(TestEnvironment);
}
try
{
VsTestFrameworkReporter reporter = new VsTestFrameworkReporter(discoverySink);
Discoverer.DiscoverTests(executables, reporter);
}
catch (Exception e)
{
TestEnvironment.LogError("Exception while discovering tests: " + e);
}
}
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 RunDescriptor(string key)
{
Key = key;
Settings = new RunSettings();
}
public RunDescriptor(RunDescriptor template)
{
Settings = new RunSettings();
Settings.Merge(template.Settings);
Key = template.Key;
}
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 void InitializeSettingsProvidersShouldThrowOnNullSettings()
{
var runSettings = new RunSettings();
Assert.ThrowsException <ArgumentNullException>(() => runSettings.InitializeSettingsProviders(null));
}
public void GetSettingsShouldThrowIfSettingsNameIsEmpty()
{
var runSettings = new RunSettings();
Assert.ThrowsException <ArgumentException>(() => runSettings.GetSettings(" "));
}
public IEnumerable <TestResult> Run(RunSettings settings)
{
return(new CelerRunner(_logger, _reflectionProviderFactory, _channel).Run(settings));
}
public IEnumerable<TestResult> Run(RunSettings settings)
{
var results = SimpleRunner.RunAllInAssembly(settings.Assembly.Assembly);
return results.Select(
x =>
new TestResult(identifier, settings.Assembly.Assembly, x.SpecificationName, 0, x.FoundOnMemberInfo.Name, "",
x.Passed == true ? TestState.Passed : TestState.Failed, x.Message)).ToArray();
}
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 IEnumerable <TestResult> Run(Plugin plugin, RunSettings settings)
{
return(plugin.New().Run(settings));
}
public static void ClassInitialize(TestContext context)
{
RunSettings.Initialize(context);
RunSettings.ValidateGameDataDir();
}
public IEnumerable <TestResult> Run(RunSettings settings)
{
var runner = new XUnitRunner();
return(runner.Run(settings, _channel));
}
public Task <GatewayDeduplicationConfiguration> ConfigureDeduplicationStorage(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
return(Task.FromResult <GatewayDeduplicationConfiguration>(new NonDurableDeduplicationConfiguration()));
}
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 NUnitOptionsParser(RunSettings settings)
{
_runnerSettings = settings;
}
public static void ClassInitialize(TestContext context)
{
RunSettings.Initialize(context);
}
public IEnumerable<TestResult> Run(RunSettings settings)
{
return new StfuRunner(_logger, _reflectionProviderFactory, _channel).Run(settings);
}
public void TestInit()
{
currentActiveSetting = RunSettingsManager.Instance.ActiveRunSettings;
}
public TestDiscoveryContext(ITestDiscoveryMonitor monitor, RunSettings runSettings = null)
{
_monitor = monitor;
RunSettings = runSettings ?? new RunSettings();
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
var documentStore = ConfigureEndpointRavenDBPersistence.GetDocumentStore();
databaseName = documentStore.Database;
configuration.UsePersistence <RavenDBPersistence, StorageType.GatewayDeduplication>()
.DoNotSetupDatabasePermissions()
.SetDefaultDocumentStore(documentStore);
return(Task.FromResult(0));
}
public async Task Should_not_lose_any_events()
{
var subscriptionStorage = new TestingInMemorySubscriptionStorage();
//Before migration begins
var beforeMigration = await Scenario.Define <Context>()
.WithEndpoint <Publisher>(b =>
{
b.CustomConfig(c =>
{
c.UsePersistence <TestingInMemoryPersistence, StorageType.Subscriptions>().UseStorage(subscriptionStorage);
c.GetSettings().Set("SqlServer.DisableNativePubSub", true);
});
b.When(c => c.SubscribedMessageDriven, (session, ctx) => session.Publish(new MyEvent()));
})
.WithEndpoint <Subscriber>(b =>
{
b.CustomConfig(c =>
{
c.GetSettings().Set("SqlServer.DisableNativePubSub", true);
c.GetSettings().GetOrCreate <Publishers>().AddOrReplacePublishers("LegacyConfig", new List <PublisherTableEntry>
{
new PublisherTableEntry(typeof(MyEvent), PublisherAddress.CreateFromEndpointName(PublisherEndpoint))
});
});
b.When(async(session, ctx) =>
{
await session.Subscribe <MyEvent>();
});
})
.Done(c => c.GotTheEvent)
.Run(TimeSpan.FromSeconds(30));
Assert.True(beforeMigration.GotTheEvent);
//Publisher migrated and in compatibility mode
var publisherMigrated = await Scenario.Define <Context>()
.WithEndpoint <Publisher>(b =>
{
b.CustomConfig(c =>
{
c.UsePersistence <TestingInMemoryPersistence, StorageType.Subscriptions>().UseStorage(subscriptionStorage);
c.GetSettings().Set("NServiceBus.Subscriptions.EnableMigrationMode", true);
});
b.When(c => c.EndpointsStarted, (session, ctx) => session.Publish(new MyEvent()));
})
.WithEndpoint <Subscriber>(b =>
{
b.CustomConfig(c =>
{
c.GetSettings().Set("SqlServer.DisableNativePubSub", true);
c.GetSettings().GetOrCreate <Publishers>().AddOrReplacePublishers("LegacyConfig", new List <PublisherTableEntry>
{
new PublisherTableEntry(typeof(MyEvent), PublisherAddress.CreateFromEndpointName(PublisherEndpoint))
});
});
b.When(async(session, ctx) =>
{
await session.Subscribe <MyEvent>();
});
})
.Done(c => c.GotTheEvent)
.Run(TimeSpan.FromSeconds(30));
Assert.True(publisherMigrated.GotTheEvent);
//Subscriber migrated and in compatibility mode
var subscriberMigratedRunSettings = new RunSettings
{
TestExecutionTimeout = TimeSpan.FromSeconds(30)
};
subscriberMigratedRunSettings.Set("DoNotCleanNativeSubscriptions", true);
var subscriberMigrated = await Scenario.Define <Context>()
.WithEndpoint <Publisher>(b =>
{
b.CustomConfig(c =>
{
c.UsePersistence <TestingInMemoryPersistence, StorageType.Subscriptions>().UseStorage(subscriptionStorage);
c.GetSettings().Set("NServiceBus.Subscriptions.EnableMigrationMode", true);
});
b.When(c => c.SubscribedMessageDriven && c.SubscribedNative, (session, ctx) => session.Publish(new MyEvent()));
})
.WithEndpoint <Subscriber>(b =>
{
b.CustomConfig(c =>
{
c.GetSettings().Set("NServiceBus.Subscriptions.EnableMigrationMode", true);
var compatModeSettings = new SubscriptionMigrationModeSettings(c.GetSettings());
compatModeSettings.RegisterPublisher(typeof(MyEvent), PublisherEndpoint);
});
b.When(async(session, ctx) =>
{
//Subscribes both using native feature and message-driven
await session.Subscribe <MyEvent>();
ctx.SubscribedNative = true;
});
})
.Done(c => c.GotTheEvent)
.Run(subscriberMigratedRunSettings);
Assert.True(subscriberMigrated.GotTheEvent);
//Compatibility mode disabled in both publisher and subscriber
var compatModeDisabled = await Scenario.Define <Context>()
.WithEndpoint <Publisher>(b =>
{
b.When(c => c.EndpointsStarted, (session, ctx) => session.Publish(new MyEvent()));
})
.WithEndpoint <Subscriber>()
.Done(c => c.GotTheEvent)
.Run(TimeSpan.FromSeconds(30));
Assert.True(compatModeDisabled.GotTheEvent);
}
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 void LoadSettingsXmlShouldThrowOnEmptySettings()
{
var runSettings = new RunSettings();
Assert.ThrowsException <ArgumentException>(() => runSettings.LoadSettingsXml(" "));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
configuration.UsePersistence <InMemoryPersistence>();
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 static Process Run([NotNull] string execName, [NotNull] RunSettings settings)
{
return(Run(execName, null, settings));
}
