public async Task WhenTheStorageHasNotBeenPreparedWeWantToInitBatchesWhenMoreEndpointsAreAvailable(bool useIndex)
{
await testSuite.InitTimeouts(2000, testSuite.EndpointName, 0);
await testSuite.InitTimeouts(1000, "SomeOtherEndpoint", 2000);
await testSuite.CreateLegacyTimeoutManagerIndex(useIndex);
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var toolState = await timeoutStorage.Prepare(DateTime.Now.AddDays(-1), testSuite.EndpointName, new Dictionary <string, string>());
var batch = await toolState.TryGetNextBatch();
var timeoutsInBatches = new List <string>();
while (batch != null)
{
var batchData = await timeoutStorage.ReadBatch(batch.Number);
timeoutsInBatches.AddRange(batchData.Select(x => x.Id));
batch.State = BatchState.Completed;
await timeoutStorage.MarkBatchAsCompleted(batch.Number);
batch = await toolState.TryGetNextBatch();
}
Assert.That(timeoutsInBatches.Distinct().Count(), Is.EqualTo(2000));
}
public async Task WhenCompletingMigrationToolStateIsArchived()
{
var toolState = testSuite.SetupToolState(DateTime.Now);
await testSuite.SaveToolState(toolState);
var timeStarted = DateTime.UtcNow;
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.Complete();
var updatedToolState = await testSuite.RavenAdapter.GetDocument <RavenToolStateDto>(RavenConstants.ToolStateId);
Assert.IsNull(updatedToolState);
var batches = await testSuite.RavenAdapter.GetDocuments <RavenBatch>(info => true, RavenConstants.BatchPrefix);
Assert.That(batches.Count, Is.EqualTo(0));
var archivedToolStates = await testSuite.RavenAdapter.GetDocuments <RavenToolStateDto>(_ => true, RavenConstants.ArchivedToolStateIdPrefix);
Assert.That(archivedToolStates.Count, Is.EqualTo(1));
var archivedToolState = archivedToolStates.Single();
Assert.That(archivedToolState.Status, Is.EqualTo(MigrationStatus.Completed));
Assert.That(archivedToolState.CompletedAt, Is.GreaterThan(timeStarted));
}
public async Task WhenPrepareDiesHalfWayThroughWeCanStillSuccessfullyPrepare(bool useIndex)
{
nrOfTimeouts = 10;
await testSuite.InitTimeouts(nrOfTimeouts, testSuite.EndpointName, 0);
await testSuite.CreateLegacyTimeoutManagerIndex(useIndex);
var cutoffTime = DateTime.Now.AddDays(-1);
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
await timeoutStorage.Prepare(cutoffTime, testSuite.EndpointName, new Dictionary <string, string>());
var toolStateDto = await testSuite.RavenAdapter.GetDocument <RavenToolStateDto>(RavenConstants.ToolStateId);
toolStateDto.Status = MigrationStatus.Preparing;
await testSuite.RavenAdapter.UpdateDocument(RavenConstants.ToolStateId, toolStateDto);
var secondBatchNrOfTimeouts = 5;
await testSuite.InitTimeouts(secondBatchNrOfTimeouts, testSuite.EndpointName, nrOfTimeouts);
await testSuite.EnsureIndexIsNotStale();
var toolState = await timeoutStorage.Prepare(cutoffTime, testSuite.EndpointName, new Dictionary <string, string>());
Assert.That(toolState.NumberOfBatches, Is.EqualTo(2));
var firstBatch = await timeoutStorage.ReadBatch(1);
var secondBatch = await timeoutStorage.ReadBatch(2);
Assert.That(firstBatch.Count(), Is.EqualTo(10));
Assert.That(secondBatch.Count(), Is.EqualTo(secondBatchNrOfTimeouts));
Assert.That(secondBatch.All(t => Convert.ToInt32(t.Id.Replace("TimeoutDatas/", "")) >= 10));
Assert.That(firstBatch.All(t => Convert.ToInt32(t.Id.Replace("TimeoutDatas/", "")) < 10));
}
public async Task <List <RavenBatch> > SetupExistingBatchInfoInDatabase()
{
var timeoutStorage = new RavenDbTimeoutsSource(Logger, serverName, DatabaseName, "TimeoutDatas", RavenDbVersion.ThreeDotFive, false);
var batches = await timeoutStorage.PrepareBatchesAndTimeouts(DateTime.Now, EndpointName);
return(batches);
}
public async Task WhenThereTimeoutsListEndpointsReturnsEndpointsList(bool useIndex)
{
var endpointATimes = await testSuite.InitTimeouts(nrOfTimeouts, "EndpointA", 0);
var endpointBTimes = await testSuite.InitTimeouts(500, "EndpointB", nrOfTimeouts);
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var endpoints = await sut.ListEndpoints(DateTime.Now);
Assert.IsNotNull(endpoints);
Assert.That(endpoints.Count, Is.EqualTo(2));
var endpointA = endpoints.FirstOrDefault(x => x.EndpointName == "EndpointA");
Assert.IsNotNull(endpointA);
Assert.That(endpointA.NrOfTimeouts, Is.EqualTo(nrOfTimeouts));
Assert.That(endpointA.ShortestTimeout, Is.EqualTo(endpointATimes.ShortestTimeout));
Assert.That(endpointA.LongestTimeout, Is.EqualTo(endpointATimes.LongestTimeout));
var endpointB = endpoints.FirstOrDefault(x => x.EndpointName == "EndpointB");
Assert.IsNotNull(endpointB);
Assert.That(endpointB.NrOfTimeouts, Is.EqualTo(500));
Assert.That(endpointB.ShortestTimeout, Is.EqualTo(endpointBTimes.ShortestTimeout));
Assert.That(endpointB.LongestTimeout, Is.EqualTo(endpointBTimes.LongestTimeout));
}
public async Task WhenPrepareDiesHalfWayThroughWhenRunWithDifferentParametersThrowsException()
{
nrOfTimeouts = 10;
testSuite.EndpointName = "EndpointA";
await testSuite.InitTimeouts(nrOfTimeouts, "EndpointA", 0);
var cutoffTime = DateTime.Now.AddDays(-1);
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await timeoutStorage.Prepare(cutoffTime, testSuite.EndpointName, new Dictionary <string, string>());
var toolState = await testSuite.RavenAdapter.GetDocument <RavenToolStateDto>(RavenConstants.ToolStateId);
toolState.Status = MigrationStatus.Preparing;
await testSuite.RavenAdapter.UpdateDocument(RavenConstants.ToolStateId, toolState);
var secondBatchNrOfTimeouts = 5;
await testSuite.InitTimeouts(secondBatchNrOfTimeouts, "EndpointA", nrOfTimeouts);
Assert.ThrowsAsync <Exception>(async() => { await timeoutStorage.Prepare(cutoffTime, "someOtherEndpoint", new Dictionary <string, string>()); });
var timeoutsFromSecondBatch = await testSuite.RavenAdapter.GetDocuments <TimeoutData>(data => Convert.ToInt32(data.Id.Replace("TimeoutDatas/", "")) >= nrOfTimeouts, "TimeoutDatas", (doc, id) => doc.Id = id);
Assert.That(timeoutsFromSecondBatch.Count(), Is.EqualTo(secondBatchNrOfTimeouts));
Assert.That(timeoutsFromSecondBatch.All(x => !x.OwningTimeoutManager.StartsWith(RavenConstants.MigrationOngoingPrefix)), Is.True);
}
public async Task WhenCheckingIfThereIsSomethingToAbortInACleanSystem()
{
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var migrationIsInProgress = await sut.CheckIfAMigrationIsInProgress();
Assert.That(migrationIsInProgress, Is.False);
}
public async Task WhenTheStorageHasNotBeenPreparedWeWantToInitBatches(bool useIndex)
{
nrOfTimeouts = RavenConstants.DefaultPagingSize + 5;
await testSuite.InitTimeouts(nrOfTimeouts);
await testSuite.CreateLegacyTimeoutManagerIndex(useIndex);
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var startTime = DateTime.UtcNow;
var toolState = await timeoutStorage.Prepare(DateTime.Now.AddDays(-1), testSuite.EndpointName, new Dictionary <string, string>());
Assert.That(toolState.NumberOfBatches, Is.EqualTo(2));
var storedToolState = await testSuite.RavenAdapter.GetDocument <RavenToolStateDto>(RavenConstants.ToolStateId);
Assert.That(storedToolState.NumberOfTimeouts, Is.EqualTo(nrOfTimeouts));
Assert.That(storedToolState.NumberOfBatches, Is.EqualTo(2));
Assert.That(storedToolState.Status, Is.EqualTo(MigrationStatus.StoragePrepared));
Assert.That(storedToolState.StartedAt, Is.GreaterThan(startTime));
var firstBatch = await toolState.TryGetNextBatch();
var batchData = await timeoutStorage.ReadBatch(firstBatch.Number);
Assert.That(batchData.Count(), Is.EqualTo(RavenConstants.DefaultPagingSize));
firstBatch.State = BatchState.Completed;
await timeoutStorage.MarkBatchAsCompleted(firstBatch.Number);
var nextBatch = await toolState.TryGetNextBatch();
var nextBatchData = await timeoutStorage.ReadBatch(nextBatch.Number);
Assert.That(nextBatchData.Count(), Is.EqualTo(nrOfTimeouts - RavenConstants.DefaultPagingSize));
}
public async Task WhenThereAreNoTimeoutsListEndpointsReturnsAnEmptyList(bool useIndex)
{
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var endpoints = await sut.ListEndpoints(DateTime.Now);
Assert.IsNotNull(endpoints);
Assert.IsEmpty(endpoints);
}
public async Task WhenGettingTimeoutStateAndNoneIsFoundNullIsReturned()
{
await testSuite.InitTimeouts(nrOfTimeouts);
var timeoutStorage = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var toolState = await timeoutStorage.TryLoadOngoingMigration();
Assert.That(toolState, Is.Null);
}
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 WhenLoadingAnOngoingMigrationAndWeFoundOneWeReturnIt()
{
await testSuite.InitTimeouts(nrOfTimeouts);
await testSuite.SaveToolState(testSuite.SetupToolState(DateTime.Now.AddDays(-1)));
var timeoutStorage = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var retrievedToolState = await timeoutStorage.TryLoadOngoingMigration();
Assert.That(retrievedToolState, Is.Not.Null);
Assert.That(retrievedToolState.NumberOfBatches, Is.GreaterThan(0));
}
public async Task WhenThereAreTimeoutsListEndpointsRespectsTheCutoffDate(bool useIndex)
{
await testSuite.InitTimeouts(nrOfTimeouts, "EndpointA", 0);
await testSuite.InitTimeouts(50, "EndpointB", nrOfTimeouts);
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var endpoints = await sut.ListEndpoints(DateTime.Now);
Assert.IsNotNull(endpoints);
Assert.That(endpoints.Count, Is.EqualTo(2));
}
public async Task WhenThereIsStateAbortShouldDeleteState()
{
var toolState = testSuite.SetupToolState(DateTime.Now);
await testSuite.SaveToolState(toolState);
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.Abort();
var storedSate = await testSuite.GetToolState();
Assert.That(storedSate, Is.Null);
}
public async Task WhenCheckingIfThereIsSomethingToAbortAndThereIsAToolState()
{
var cutOffTime = DateTime.Now.AddDays(-1);
await testSuite.InitTimeouts(nrOfTimeouts);
var storage = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await storage.Prepare(cutOffTime, testSuite.EndpointName, new Dictionary <string, string>());
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var migrationIsInProgress = await sut.CheckIfAMigrationIsInProgress();
Assert.That(migrationIsInProgress, Is.True);
}
public async Task WhenAbortingOnPreparedStorageStateShouldBeCleanedUp()
{
var cutOffTime = DateTime.Now.AddDays(-1);
var storage = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await storage.Prepare(cutOffTime, testSuite.EndpointName, new Dictionary <string, string>());
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.Abort();
var storedSate = await testSuite.GetToolState();
Assert.That(storedSate, Is.Null);
}
public async Task WhenReadingABatchAllTimeoutsInBatchAreReturned()
{
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var batches = await timeoutStorage.PrepareBatchesAndTimeouts(DateTime.Now.AddDays(-1), testSuite.EndpointName);
var batchToVerify = batches.First();
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var timeoutDatasInBatch = await sut.ReadBatch(batchToVerify.Number);
Assert.That(batchToVerify.TimeoutIds.Length, Is.EqualTo(timeoutDatasInBatch.Count));
}
public async Task WhenStoringTheToolStateTheToolStateIsUpdated()
{
await testSuite.InitTimeouts(nrOfTimeouts);
var toolState = testSuite.SetupToolState(DateTime.Now);
await testSuite.SaveToolState(toolState);
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var updatedToolState = await timeoutStorage.TryLoadOngoingMigration();
Assert.That(updatedToolState.EndpointName, Is.EqualTo(testSuite.EndpointName));
}
public async Task WhenThereAreCompletedTimeoutsTheseAreIgnoredWhenListingEndpoints(bool useIndex)
{
await testSuite.InitTimeouts(50);
var timeout = await testSuite.RavenAdapter.GetDocument <TimeoutData>("TimeoutDatas/0", (data, id) => data.Id = id);
timeout.OwningTimeoutManager = $"{RavenConstants.MigrationDonePrefix}{timeout.OwningTimeoutManager}";
await testSuite.RavenAdapter.UpdateDocument(timeout.Id, timeout);
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, useIndex);
var endpoints = await sut.ListEndpoints(DateTime.Now);
Assert.IsNotNull(endpoints);
Assert.That(endpoints.Count, Is.EqualTo(1));
Assert.That(endpoints.First().NrOfTimeouts, Is.EqualTo(49));
}
public async Task WhenMarkingBatchAsStagedThenBatchStatusIsUpdated()
{
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var batches = await timeoutStorage.PrepareBatchesAndTimeouts(DateTime.Now.AddDays(-1), testSuite.EndpointName);
var batchToVerify = batches.First();
Assert.That(batchToVerify.State, Is.EqualTo(BatchState.Pending));
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.MarkBatchAsStaged(batchToVerify.Number);
var updatedBatch = await testSuite.RavenAdapter.GetDocument <RavenBatch>($"{RavenConstants.BatchPrefix}/{batchToVerify.Number}");
Assert.That(updatedBatch.State, Is.EqualTo(BatchState.Staged));
}
public async Task WhenAbortingWithAToolStateInStoragePreparedToolWillStillCleanupBatches()
{
var cutOffTime = DateTime.Now.AddDays(-1);
await testSuite.InitTimeouts(nrOfTimeouts);
var storage = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await storage.Prepare(cutOffTime, testSuite.EndpointName, new Dictionary <string, string>());
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.Abort();
var batchesInStore = await testSuite.RavenAdapter.GetDocuments <RavenBatch>(batch => true, RavenConstants.BatchPrefix);
var hiddenTimeouts = await testSuite.RavenAdapter.GetDocuments <TimeoutData>(timeout => timeout.OwningTimeoutManager.StartsWith(RavenConstants.MigrationOngoingPrefix), RavenConstants.DefaultTimeoutPrefix, (timeout, id) => { timeout.Id = id; });
Assert.That(batchesInStore.Count, Is.EqualTo(0));
Assert.That(hiddenTimeouts.Count, Is.EqualTo(0));
}
public async Task WhenCompletingABatchTimeoutsAreMarkedDone()
{
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var toolState = await timeoutStorage.Prepare(DateTime.Now.AddDays(-1), testSuite.EndpointName, new Dictionary <string, string>());
var batchToVerify = await toolState.TryGetNextBatch();
var timeoutIdToVerify = ((RavenToolState)toolState).Batches.First().TimeoutIds.First();
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.MarkBatchAsCompleted(batchToVerify.Number);
var updatedTimeout = await testSuite.RavenAdapter.GetDocument <TimeoutData>(
timeoutIdToVerify,
(timeoutData, id) => { timeoutData.Id = id; });
Assert.That(updatedTimeout.OwningTimeoutManager.StartsWith(RavenConstants.MigrationDonePrefix), Is.True);
}
public async Task WhenCleaningUpBatchesThenTimeoutsInCompleteBatchesAreNotReset()
{
await testSuite.InitTimeouts(nrOfTimeouts);
testSuite.SetupToolState(DateTime.Now.AddDays(-1));
var preparedBatches = await testSuite.SetupExistingBatchInfoInDatabase();
var incompleteBatches = preparedBatches.Skip(1).Take(1).ToList();
var completeBatch = preparedBatches.First();
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.CleanupExistingBatchesAndResetTimeouts(preparedBatches, incompleteBatches);
var completeBatchFromStorage = await testSuite.RavenAdapter.GetDocument <RavenBatch>($"{RavenConstants.BatchPrefix}/{completeBatch.Number}", (doc, id) => { });
var resetTimeouts = await testSuite.RavenAdapter.GetDocuments <TimeoutData>(x => completeBatch.TimeoutIds.Contains(x.Id), "TimeoutDatas", (doc, id) => doc.Id = id);
Assert.That(completeBatchFromStorage, Is.Null);
Assert.That(resetTimeouts.Select(t => t.OwningTimeoutManager), Is.All.Matches <string>(x => x.StartsWith(RavenConstants.MigrationOngoingPrefix)));
}
public async Task WhenCompletingABatchCurrentBatchShouldBeMovedUp()
{
var timeoutStorage =
new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
var toolState = await timeoutStorage.Prepare(DateTime.Now.AddDays(-1), testSuite.EndpointName, new Dictionary <string, string>());
var batchToVerify = await toolState.TryGetNextBatch();
var sut = new RavenDbTimeoutsSource(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
await sut.MarkBatchAsCompleted(batchToVerify.Number);
var updatedBatch = await testSuite.RavenAdapter.GetDocument <RavenBatch>($"{RavenConstants.BatchPrefix}/{batchToVerify.Number}");
toolState = await sut.TryLoadOngoingMigration();
var currentBatch = await toolState.TryGetNextBatch();
Assert.That(updatedBatch.State, Is.EqualTo(BatchState.Completed));
Assert.That(currentBatch, Is.Not.Null);
Assert.That(currentBatch.Number, Is.EqualTo(batchToVerify.Number + 1));
}
public async Task Can_migrate_timeouts()
{
var sourceEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(RavenDBSource));
var targetEndpoint = NServiceBus.AcceptanceTesting.Customization.Conventions.EndpointNamingConvention(typeof(AsqTarget));
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));
ec.UseSerialization <NewtonsoftSerializer>();
})
.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>()
// Create the legacy endpoint to forward the delayed message to the native delayed delivery endpoint
// This is needed as ASQ stores the delayed messages at the sending endpoint until delivery is needed
.WithEndpoint <RavenDBSource>(b => b.CustomConfig(ec =>
{
var transport = ec.UseTransport <AzureStorageQueueTransport>().ConnectionString(asqConnectionString);
transport.DisablePublishing();
transport.DelayedDelivery().DisableTimeoutManager();
ec.UseSerialization <NewtonsoftSerializer>();
}))
.WithEndpoint <AsqTarget>(b => b.CustomConfig(ec =>
{
var transport = ec.UseTransport <AzureStorageQueueTransport>().ConnectionString(asqConnectionString);
transport.DisablePublishing();
transport.DelayedDelivery().DisableTimeoutManager();
ec.UseSerialization <NewtonsoftSerializer>();
})
.When(async(_, c) =>
{
var logger = new TestLoggingAdapter(c);
var timeoutsSource = new RavenDbTimeoutsSource(logger, serverUrl, databaseName, ravenTimeoutPrefix, ravenVersion, false);
var timeoutsTarget = new ASQTarget(asqConnectionString, new DelayedDeliveryTableNameProvider());
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);
}
