public async Task TryLoadOngoingMigration_Should_Be_Null_When_No_Migration_Running()
{
// Arrange
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 10, DatabaseDialect);
// Act
var currentMigration = await timeoutsSource.TryLoadOngoingMigration();
// Assert
Assert.IsNull(currentMigration);
}
public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(NHibernateSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(SqlTTarget));
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.NHibernateToSqlTEndToEnd+DelayedMessage\"}",
State = Encoding.UTF8.GetBytes("{}"),
Time = DateTime.UtcNow.AddSeconds(15)
});
await testTx.CommitAsync();
}
}
var context = await Scenario.Define <TargetContext>()
.WithEndpoint <SqlTTarget>(b => b.CustomConfig(ec =>
{
ec.OverrideLocalAddress(sourceEndpoint);
var transportConfig = ec.UseTransport <SqlServerTransport>();
transportConfig.ConnectionString(connectionString);
ec.UseSerialization <NewtonsoftSerializer>();
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1024, DatabaseDialect);
var timeoutTarget = new SqlTTimeoutsTarget(logger, connectionString, "dbo");
var migrationRunner = new MigrationRunner(logger, timeoutsSource, timeoutTarget);
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 Can_Read_Batch_By_Batch_Number()
{
// Arrange
var endpointName = "Can_Read_Batch_By_Batch_Number";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
var expectedDestinations = new List <string>();
using (var testSession = CreateSessionFactory().OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 3; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName + x.ToString(),
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
expectedDestinations.Add(endpointName + x.ToString());
}
await testTx.CommitAsync();
}
}
await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Act
for (var x = 0; x < 3; x++)
{
var batch = await timeoutsSource.ReadBatch(x + 1);
expectedDestinations.Remove(batch.First().Destination);
}
// Assert
// If all the batches were loaded correctly, the destinations would have been removed from the list.
Assert.IsEmpty(expectedDestinations);
}
public async Task Aborting_Returns_StagedTimeouts_Back_To_TimeoutEntity_Table()
{
// Arrange
var endpointName = "Aborting_Returns_StagedTimeouts_Back_To_TimeoutEntity_Table";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using var sessionFactory = CreateSessionFactory();
using (var testSession = sessionFactory.OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 2; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName,
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Act
await timeoutsSource.Abort();
// Assert
using var validateSession = sessionFactory.OpenSession();
var timeouts = await validateSession.QueryOver <TimeoutEntity>().ListAsync();
Assert.AreEqual(2, timeouts.Count);
var currentAfterAborting = await timeoutsSource.TryLoadOngoingMigration();
Assert.IsNull(currentAfterAborting);
}
public async Task Complete_Sets_The_MigrationStatus_Correctly()
{
var endpointName = "Complete_Sets_The_MigrationStatus_Correctly";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using (var testSession = CreateSessionFactory().OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 2; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName,
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
var currentMigration = await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
for (var x = 0; x < currentMigration.NumberOfBatches; x++)
{
await timeoutsSource.MarkBatchAsCompleted(x + 1);
}
// Act
await timeoutsSource.Complete();
// Assert
var loadedMigrationAfterCompletion = await timeoutsSource.TryLoadOngoingMigration();
Assert.IsNull(loadedMigrationAfterCompletion);
}
public async Task GetNextBatch_When_Batches_Are_Migrated_Returns_Null()
{
// Arrange
var endpointName = "GetNextBatch_Returns_The_Next_Batch_Not_Migrated";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using (var testSession = CreateSessionFactory().OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 3; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName + x.ToString(),
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
var toolState = await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
for (var x = 0; x < 3; x++)
{
await timeoutsSource.MarkBatchAsCompleted(x + 1);
}
// Act
var firstBatch = await toolState.TryGetNextBatch();
// Assert
Assert.IsNull(firstBatch);
}
public async Task Preparing_Creates_A_MigrationsEntity_And_Returns_It()
{
// Arrange
var endpointName = "Preparing_Creates_A_MigrationsEntity_And_Returns_It";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 10, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
// Act
var currentMigration = await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Assert
Assert.IsNotNull(currentMigration);
Assert.AreEqual(endpointName, currentMigration.EndpointName);
Assert.AreEqual(runParameters, currentMigration.RunParameters);
Assert.AreEqual(0, currentMigration.NumberOfBatches);
}
public async Task ListEndpoints_Loads_All_Endpoints_With_Timeouts()
{
// Arrange
var endpointName = "ListEndpoints_Loads_All_Endpoints_With_Timeouts";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using var sessionFactory = CreateSessionFactory();
using (var testSession = sessionFactory.OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 2; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName + x.ToString(),
Destination = endpointName + "_Destination" + x.ToString(),
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Act
var endpoints = await timeoutsSource.ListEndpoints(DateTime.UtcNow.AddDays(-100));
// Assert
Assert.AreEqual(2, endpoints.Count);
Assert.AreEqual(new[] { $"{endpointName}0", $"{endpointName}1" }, endpoints.Select(endpoint => endpoint.EndpointName).ToArray());
}
public async Task Preparing_Sets_The_Number_Of_Batches_Correctly()
{
// Arrange
var endpointName = "Preparing_Sets_The_Number_Of_Batches_Correctly";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using (var testSession = CreateSessionFactory().OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 2; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName,
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
// Act
var currentMigration = await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Assert
Assert.IsNotNull(currentMigration);
Assert.AreEqual(endpointName, currentMigration.EndpointName);
Assert.AreEqual(runParameters, currentMigration.RunParameters);
Assert.AreEqual(2, currentMigration.NumberOfBatches);
}
public async Task Marking_A_Batch_As_Complete_Updates_The_Status_Correctly(BatchState batchState)
{
// Arrange
var endpointName = "Marking_A_Batch_As_Complete_Updates_The_Status_Correctly";
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 1, DatabaseDialect);
var runParameters = new Dictionary <string, string> {
{ "Test", "TestValue" }
};
var cutOffDate = DateTime.UtcNow;
using var sessionFactory = CreateSessionFactory();
using (var testSession = sessionFactory.OpenSession())
{ // Explicit using scope to ensure dispose before SUT connects
using (var testTx = testSession.BeginTransaction())
{
for (var x = 0; x < 2; x++)
{
await testSession.SaveAsync(new TimeoutEntity
{
Endpoint = endpointName,
Destination = endpointName,
SagaId = Guid.NewGuid(),
State = null,
Time = cutOffDate.AddDays(1)
});
}
await testTx.CommitAsync();
}
}
await timeoutsSource.Prepare(cutOffDate, endpointName, runParameters);
// Act
switch (batchState)
{
case BatchState.Staged:
await timeoutsSource.MarkBatchAsStaged(1);
break;
case BatchState.Completed:
await timeoutsSource.MarkBatchAsCompleted(1);
break;
case BatchState.Pending:
default:
return;
}
// Assert
using var dbQuerySession = sessionFactory.OpenStatelessSession();
var timeouts = await dbQuerySession.QueryOver <StagedTimeoutEntity>()
.Where(timeout => timeout.BatchNumber == 1)
.ListAsync();
Assert.True(timeouts.All(t => t.BatchState == batchState), $"Expected all StagedTimeoutEntity rows to have the batch state set to {batchState}");
}
public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(NHibernateSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget));
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.NHibernateToAsqEndToEnd+DelayedMessage\"}",
State = Encoding.UTF8.GetBytes("{}"),
Time = DateTime.UtcNow.AddSeconds(15)
});
await testTx.CommitAsync();
}
}
var context = await Scenario.Define <TargetContext>()
// Create the legacy endpoint to forward the delayed message to the reporting endpoint
// This is needed as ASQ stores the delayed messages at the sending endpoint until
// delivery is needed
.WithEndpoint <NHibernateSource>(b => b.CustomConfig(ec =>
{
var transportConfig = ec.UseTransport <AzureStorageQueueTransport>();
transportConfig.ConnectionString(asqConnectionString);
transportConfig.DisablePublishing();
transportConfig.DelayedDelivery().DisableTimeoutManager();
ec.UseSerialization <NewtonsoftSerializer>();
}))
.WithEndpoint <AsqTarget>(b => b.CustomConfig(ec =>
{
var transportConfig = ec.UseTransport <AzureStorageQueueTransport>();
transportConfig.ConnectionString(asqConnectionString);
transportConfig.DisablePublishing();
transportConfig.DelayedDelivery().DisableTimeoutManager();
ec.UseSerialization <NewtonsoftSerializer>();
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutsSource = new NHibernateTimeoutsSource(connectionString, 512, DatabaseDialect);
var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider());
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);
}
