public void Prepare()
{
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
PrepareAsync().GetAwaiter().GetResult();
}
public async Task SetUp()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await ResetQueue(addressParser, sqlConnectionFactory);
queue = new TableBasedQueue(addressParser.Parse(QueueTableName).QualifiedTableName, QueueTableName, false);
}
public async Task Should_recover(Type contextProviderType, DispatchConsistency dispatchConsistency)
{
// Setup
var token = CancellationToken.None;
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var purger = new QueuePurger(sqlConnectionFactory);
await RemoveQueueIfPresent(QueueName, token);
await RemoveQueueIfPresent($"{QueueName}.Delayed", token);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory);
var tableCache = new TableBasedQueueCache(addressParser, true);
var queue = tableCache.Get(QueueName);
dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
// Run normally
int messagesSent = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSent);
// Remove Recoverable column
await DropRecoverableColumn(token);
var exception = Assert.ThrowsAsync <Exception>(() => RunTest(contextProviderType, dispatchConsistency, queue, purger, token));
Assert.True(exception.Message.Contains("change in the existence of the Recoverable column"));
// Try again, should work
int messagesSentAttempt2 = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSentAttempt2);
// Put the Recoverable column back
await AddRecoverableColumn(token);
var exception2 = Assert.ThrowsAsync <Exception>(() => RunTest(contextProviderType, dispatchConsistency, queue, purger, token));
Assert.True(exception2.Message.Contains("change in the existence of the Recoverable column"));
// Try again, should work
int messagesSentAttempt3 = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSentAttempt3);
}
public async Task Should_stop_receiving_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueueAddress = parser.Parse("input").Address;
var inputQueue = new FakeTableBasedQueue(inputQueueAddress, queueSize, successfulReceives);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
var transport = new SqlServerTransport(SqlConnectionFactory.Default(connectionString).OpenNewConnection)
{
TransportTransactionMode = TransportTransactionMode.None,
TimeToWaitBeforeTriggeringCircuitBreaker = TimeSpan.MaxValue,
};
transport.Testing.QueueFactoryOverride = qa =>
qa == inputQueueAddress ? inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa, true);
var receiveSettings = new ReceiveSettings("receiver", inputQueueAddress, true, false, "error");
var hostSettings = new HostSettings("IntegrationTests", string.Empty, new StartupDiagnosticEntries(),
(_, __, ___) => { },
true);
var infrastructure = await transport.Initialize(hostSettings, new[] { receiveSettings }, new string[0]);
var receiver = infrastructure.Receivers.First().Value;
await receiver.Initialize(
new PushRuntimeSettings(1),
(_, __) => Task.CompletedTask,
(_, __) => Task.FromResult(ErrorHandleResult.Handled));
await receiver.StartReceive();
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await receiver.StopReceive();
await infrastructure.Shutdown();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Receiver should stop receives after first unsuccessful attempt.");
}
async Task PrepareAsync(CancellationToken cancellationToken = default)
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogOptions());
var tableCache = new TableBasedQueueCache(addressParser, true);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory, cancellationToken);
await PurgeOutputQueue(addressParser, cancellationToken);
dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
}
async Task PrepareAsync()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogSettings());
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory);
await PurgeOutputQueue(addressParser);
dispatcher = new MessageDispatcher(new TableBasedQueueDispatcher(sqlConnectionFactory, new TableBasedQueueOperationsReader(addressParser)), addressParser);
}
public async Task Should_stop_pumping_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueue = new FakeTableBasedQueue(parser.Parse("input").QualifiedTableName, queueSize, successfulReceives);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
var sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
var pump = new MessagePump(
m => new ProcessWithNoTransaction(sqlConnectionFactory, null),
qa => qa == "input" ? (TableBasedQueue)inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa, true),
new QueuePurger(sqlConnectionFactory),
new NoOpExpiredMessagesPurger(),
new QueuePeeker(sqlConnectionFactory, new QueuePeekerOptions()),
new QueuePeekerOptions(),
new SchemaInspector(_ => sqlConnectionFactory.OpenNewConnection(), false),
TimeSpan.MaxValue);
await pump.Init(
_ => Task.FromResult(0),
_ => Task.FromResult(ErrorHandleResult.Handled),
new CriticalError(_ => Task.FromResult(0)),
new PushSettings("input", "error", false, TransportTransactionMode.None));
pump.Start(new PushRuntimeSettings(1));
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await pump.Stop();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Pump should stop receives after first unsuccessful attempt.");
}
