public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlPSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RabbitMqTarget));
await Scenario.Define <SourceContext>()
.WithEndpoint <SqlPSource>(b => b.CustomConfig(ec =>
{
var persistence = ec.UsePersistence <SqlPersistence>();
persistence.SqlDialect <NServiceBus.SqlDialect.MsSqlServer>();
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(connectionString));
});
})
.When(async(session, c) =>
{
var delayedMessage = new DelayedMessage();
var options = new SendOptions();
options.DelayDeliveryWith(TimeSpan.FromSeconds(15));
options.SetDestination(targetEndpoint);
await session.Send(delayedMessage, options);
await WaitUntilTheTimeoutIsSavedInSql(sourceEndpoint);
c.TimeoutSet = true;
}))
.Done(c => c.TimeoutSet)
.Run(TimeSpan.FromSeconds(30));
var context = await Scenario.Define <TargetContext>()
.WithEndpoint <RabbitMqTarget>(b => b.CustomConfig(ec =>
{
ec.UseTransport <RabbitMQTransport>()
.ConnectionString(rabbitUrl);
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutStorage = new SqlTimeoutsSource(connectionString, new MsSqlServer(), 1024);
var transportAdapter = new RabbitMqTimeoutTarget(logger, rabbitUrl);
var migrationRunner = new MigrationRunner(logger, timeoutStorage, transportAdapter);
await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>());
}))
.Done(c => c.GotTheDelayedMessage)
.Run(TimeSpan.FromSeconds(30));
Assert.True(context.GotTheDelayedMessage);
}
public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RavenDBSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RabbitMqEndpoint));
var ravenTimeoutPrefix = "TimeoutDatas";
var ravenVersion = RavenDbVersion.Four;
var ravenAdapter = new Raven4Adapter(serverUrl, databaseName);
await Scenario.Define <SourceContext>()
.WithEndpoint <RavenDBSource>(b => b.CustomConfig(ec =>
{
ec.UsePersistence <RavenDBPersistence>()
.SetDefaultDocumentStore(GetDocumentStore(serverUrl, databaseName));
})
.When(async(session, c) =>
{
var delayedMessage = new DelayedMessage();
var options = new SendOptions();
options.DelayDeliveryWith(TimeSpan.FromSeconds(20));
options.SetDestination(targetEndpoint);
await session.Send(delayedMessage, options);
await WaitUntilTheTimeoutIsSavedInRaven(ravenAdapter, sourceEndpoint);
c.TimeoutSet = true;
}))
.Done(c => c.TimeoutSet)
.Run(TimeSpan.FromSeconds(15));
var context = await Scenario.Define <TargetContext>()
.WithEndpoint <RabbitMqEndpoint>(b => b.CustomConfig(ec =>
{
ec.UseTransport <RabbitMQTransport>()
.ConnectionString(rabbitUrl);
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutsSource = new RavenDbTimeoutsSource(logger, serverUrl, databaseName, ravenTimeoutPrefix, ravenVersion, false);
var timeoutsTarget = new RabbitMqTimeoutTarget(logger, rabbitUrl);
var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget);
await migrationRunner.Run(DateTime.Now.AddDays(-1), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>());
}))
.Done(c => c.GotTheDelayedMessage)
.Run(TimeSpan.FromSeconds(30));
Assert.True(context.GotTheDelayedMessage);
}
public async Task Should_delete_staging_queue_when_completing()
{
var sut = new RabbitMqTimeoutTarget(new TestLoggingAdapter(), rabbitUrl);
var endpointName = "FakeEndpoint";
await using var endpointTarget = await sut.PrepareTargetEndpointBatchMigrator(endpointName);
await sut.Complete(endpointName);
using var connection = factory.CreateConnection(rabbitUrl);
using var model = connection.CreateModel();
Assert.Throws <RabbitMQ.Client.Exceptions.OperationInterruptedException>(() => model.QueueDeclarePassive(QueueCreator.StagingQueueName));
}
public async Task AbleToMigrate_TimeoutHigherThan9Years_ReturnsProblems()
{
var sut = new RabbitMqTimeoutTarget(new TestLoggingAdapter(), rabbitUrl);
var info = new EndpointInfo
{
EndpointName = ExistingEndpointNameUsingConventional,
ShortestTimeout = DateTime.UtcNow.AddDays(3),
LongestTimeout = DateTime.UtcNow.AddYears(9),
Destinations = new List <string> {
ExistingEndpointNameUsingConventional
}
};
var result = await sut.AbleToMigrate(info);
Assert.IsFalse(result.CanMigrate);
}
public async Task Should_handle_negative_delays()
{
const int BatchNumber = 33;
var sut = new RabbitMqTimeoutTarget(new TestLoggingAdapter(), rabbitUrl);
var info = new EndpointInfo
{
EndpointName = ExistingEndpointNameUsingConventional,
ShortestTimeout = DateTime.UtcNow.AddDays(3),
LongestTimeout = DateTime.UtcNow.AddDays(5),
Destinations = new List <string> {
ExistingEndpointNameUsingConventional
}
};
var migrateResult = await sut.AbleToMigrate(info);
Assert.IsTrue(migrateResult.CanMigrate);
await using var endpointTarget = await sut.PrepareTargetEndpointBatchMigrator(ExistingEndpointNameUsingConventional);
await endpointTarget.StageBatch(new List <TimeoutData>
{
new TimeoutData
{
Id = "SomeID",
Headers = new Dictionary <string, string>(),
Destination = ExistingEndpointNameUsingConventional,
State = new byte[2],
Time = DateTime.Now - TimeSpan.FromDays(1)
}
}, BatchNumber);
var numPumped = await sut.CompleteBatch(BatchNumber);
Assert.AreEqual(1, numPumped);
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
var result = channel.BasicGet(ExistingEndpointNameUsingConventional, true);
Assert.NotNull(result);
Assert.AreEqual(0, result.MessageCount);
}
public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(NHibernateSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RabbitMqTarget));
using (var testSession = CreateSessionFactory().OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = sourceEndpoint,
Destination = targetEndpoint,
SagaId = Guid.NewGuid(),
Headers = "{\"NServiceBus.EnclosedMessageTypes\": \"TimeoutMigrationTool.NHibernate.AcceptanceTests.NHibernateToRabbitMqEndToEnd+DelayedMessage\"}",
State = Encoding.UTF8.GetBytes("{}"),
Time = DateTime.UtcNow.AddSeconds(15)
});
await testTx.CommitAsync();
}
}
var context = await Scenario.Define <TargetContext>()
.WithEndpoint <RabbitMqTarget>(b => b.CustomConfig(ec =>
{
ec.UseTransport <RabbitMQTransport>()
.ConnectionString(rabbitUrl);
ec.UseSerialization <NewtonsoftSerializer>();
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 512, DatabaseDialect);
var timeoutsTarget = new RabbitMqTimeoutTarget(logger, rabbitUrl);
var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutsTarget);
await migrationRunner.Run(DateTime.Now.AddDays(-10), EndpointFilter.SpecificEndpoint(sourceEndpoint), new Dictionary <string, string>());
}))
.Done(c => c.GotTheDelayedMessage)
.Run(TimeSpan.FromSeconds(90));
Assert.True(context.GotTheDelayedMessage);
}
public async Task AbleToMigrate_DelayedDeliveryDoesNotExist_ReturnsProblems()
{
var sut = new RabbitMqTimeoutTarget(new TestLoggingAdapter(), rabbitUrl);
DeleteDelayDelivery();
var info = new EndpointInfo
{
EndpointName = ExistingEndpointNameUsingConventional,
ShortestTimeout = DateTime.UtcNow.AddDays(3),
LongestTimeout = DateTime.UtcNow.AddDays(5),
Destinations = new List <string>
{
ExistingEndpointNameUsingConventional, ExistingEndpointNameUsingDirect
}
};
var result = await sut.AbleToMigrate(info);
Assert.IsFalse(result.CanMigrate);
}
