Adjust the AbortRunner so it asks the storage if there's something to abort

(cherry picked from commit 587b42b)

Author: lailabougria

src/TimeoutMigrationTool.Raven.IntegrationTests/RavenAbortsTheMigration.cs

@@ -77,6 +77,47 @@ public async Task WhenAbortingWithoutAToolStateToolWillStillCleanupBatches()
             Assert.That(hiddenTimeouts.Count, Is.EqualTo(0));
         }
 
+        [Test]
+        public async Task WhenCheckingIfThereIsSomethingToAbortAndThereIsNoToolStateButWeHaveBatches()
+        {
+            var cutOffTime = DateTime.Now.AddDays(-1);
+            await testSuite.InitTimeouts(nrOfTimeouts);
+
+            var storage = new RavenDBTimeoutStorage(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
+            await storage.Prepare(cutOffTime, testSuite.EndpointName, new Dictionary<string, string>());
+
+            await testSuite.RavenAdapter.DeleteDocument(RavenConstants.ToolStateId);
+
+            var sut = new RavenDBTimeoutStorage(testSuite.Logger,testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
+            var migrationIsInProgress = await sut.CheckIfAMigrationIsInProgress();
+
+            Assert.That(migrationIsInProgress, Is.True);
+        }
+
+        [Test]
+        public async Task WhenCheckingIfThereIsSomethingToAbortAndThereIsAToolState()
+        {
+            var cutOffTime = DateTime.Now.AddDays(-1);
+            await testSuite.InitTimeouts(nrOfTimeouts);
+
+            var storage = new RavenDBTimeoutStorage(testSuite.Logger, testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
+            await storage.Prepare(cutOffTime, testSuite.EndpointName, new Dictionary<string, string>());
+
+            var sut = new RavenDBTimeoutStorage(testSuite.Logger,testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
+            var migrationIsInProgress = await sut.CheckIfAMigrationIsInProgress();
+
+            Assert.That(migrationIsInProgress, Is.True);
+        }
+
+        [Test]
+        public async Task WhenCheckingIfThereIsSomethingToAbortInACleanSystem()
+        {
+            var sut = new RavenDBTimeoutStorage(testSuite.Logger,testSuite.ServerName, testSuite.DatabaseName, "TimeoutDatas", testSuite.RavenVersion, false);
+            var migrationIsInProgress = await sut.CheckIfAMigrationIsInProgress();
+
+            Assert.That(migrationIsInProgress, Is.False);
+        }
+
         [Test]
         public async Task WhenCleaningUpBatchesThenTimeoutsInIncompleteBatchesAreReset()
         {

src/TimeoutMigrationTool.Tests/AbortRunnerTests.cs

@@ -0,0 +1,71 @@
+namespace TimeoutMigrationTool.Tests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using NUnit.Framework;
+    using Particular.TimeoutMigrationTool;
+
+    [TestFixture]
+    public class AbortRunnerTests
+    {
+        [SetUp]
+        public void Setup()
+        {
+            timeoutStorage = new FakeTimeoutStorage();
+            logger = new ConsoleLogger(false);
+
+            runner = new AbortRunner(logger, timeoutStorage);
+
+            endpoints = new List<EndpointInfo>
+            {
+                new EndpointInfo
+                {
+                    EndpointName = "Sales",
+                    NrOfTimeouts = 500
+                }
+            };
+            testEndpoint = endpoints.First().EndpointName;
+            timeoutStorage.SetupEndpoints(endpoints);
+        }
+
+        [Test]
+        public void WhenAbortingAndTimeoutStorageFoundNothingToAbortThrowsException()
+        {
+            Assert.ThrowsAsync<Exception>(async () => { await runner.Run(); });
+        }
+
+        [Test]
+        public async Task WhenAbortingAndTimeoutStorageFoundToolStateItIsAborted()
+        {
+            var batches = GetBatches();
+            var toolState = new FakeToolState
+            {
+                EndpointName = testEndpoint,
+                Batches = batches,
+                RunParameters = new Dictionary<string, string>()
+            };
+            timeoutStorage.SetupToolStateToReturn(toolState);
+
+            await runner.Run();
+
+            Assert.That(timeoutStorage.ToolStateWasAborted, Is.True);
+        }
+
+        static List<BatchInfo> GetBatches()
+        {
+            var batches = new List<BatchInfo>
+            {
+                new BatchInfo(1, BatchState.Pending, 1)
+            };
+            return batches;
+        }
+
+        FakeTimeoutStorage timeoutStorage;
+        AbortRunner runner;
+        List<EndpointInfo> endpoints;
+        string testEndpoint;
+        Microsoft.Extensions.Logging.ILogger logger;
+    }
+}

src/TimeoutMigrationTool.Tests/FakeTimeoutStorage.cs

@@ -99,5 +99,10 @@ public Task Complete()
             ToolStateMovedToCompleted = true;
             return Task.CompletedTask;
         }
+
+        public Task<bool> CheckIfAMigrationIsInProgress()
+        {
+            return Task.FromResult(this.existingToolState != null);
+        }
     }
 }

src/TimeoutMigrationTool.Tests/MigrationRunnerTests.cs

@@ -2,7 +2,6 @@ namespace TimeoutMigrationTool.Tests
 {
     using System;
     using System.Collections.Generic;
-    using System.Dynamic;
     using System.Linq;
     using System.Threading.Tasks;
     using NUnit.Framework;

src/TimeoutMigrationTool/AbortRunner.cs

@@ -14,15 +14,25 @@ public AbortRunner(ILogger logger, ITimeoutStorage timeoutStorage)
 
         public async Task Run()
         {
-            var toolState = await timeoutStorage.TryLoadOngoingMigration();
-            if (toolState == null)
+            var shouldAbort = await timeoutStorage.CheckIfAMigrationIsInProgress();
+            if (!shouldAbort)
             {
                 throw new Exception("Could not find a previous migration to abort.");
             }
 
-            logger.LogInformation($"Aborting ongoing migration for {toolState.EndpointName}");
+            var toolState = await timeoutStorage.TryLoadOngoingMigration();
+            if (toolState != null)
+            {
+                logger.LogInformation($"Aborting ongoing migration for {toolState.EndpointName}");
+            }
+            else
+            {
+                logger.LogInformation("Cleaning up changes made in the previous interrupted migration");
+            }
 
             await timeoutStorage.Abort();
+
+            logger.LogInformation("Previous migration was successfully aborted. That means that the timeouts hidden away from the TimeoutManager, have been made available again");
         }
 
         readonly ILogger logger;

src/TimeoutMigrationTool/ITimeoutStorage.cs

@@ -14,5 +14,6 @@ public interface ITimeoutStorage
         Task Abort();
         Task<List<EndpointInfo>> ListEndpoints(DateTime cutOffTime);
         Task Complete();
+        Task<bool> CheckIfAMigrationIsInProgress();
     }
 }

src/TimeoutMigrationTool/RavenDB/RavenDBTimeoutStorage.cs

@@ -282,6 +282,14 @@ public async Task Complete()
             await ravenAdapter.ArchiveDocument(GetArchivedToolStateId(ravenToolState.Endpoint), ravenToolState);
         }
 
+        public async Task<bool> CheckIfAMigrationIsInProgress()
+        {
+            var ravenToolState = await ravenAdapter.GetDocument<RavenToolStateDto>(RavenConstants.ToolStateId, (doc, id) => { });
+            var anyBatches = await ravenAdapter.GetDocuments<RavenBatch>(batch => batch.State == BatchState.Pending, RavenConstants.BatchPrefix, (batch, id) => { });
+
+            return ravenToolState != null || anyBatches.Any();
+        }
+
         internal async Task CleanupExistingBatchesAndResetTimeouts(List<RavenBatch> batchesToRemove, List<RavenBatch> batchesForWhichToResetTimeouts)
         {
             foreach (var batch in batchesToRemove)

src/TimeoutMigrationTool/SqlP/SqlTimeoutStorage.cs

@@ -147,6 +147,12 @@ public async Task Complete()
             await command.ExecuteNonQueryAsync();
         }
 
+        public async Task<bool> CheckIfAMigrationIsInProgress()
+        {
+            var toolState = await TryLoadOngoingMigration();
+            return toolState != null;
+        }
+
         public async Task Abort()
         {
             var toolState = await TryLoadOngoingMigration();