RavenDB-22036 Added tests and throwing exception on side-by-side reset of replacement index

src/Raven.Server/Documents/Indexes/IndexStore.cs

@@ -1522,6 +1522,9 @@ private Index ResetIndexInternal(Index index, bool start = true)
 
         private Index ResetIndexSideBySideInternal(Index index)
         {
+            if (index.Name.StartsWith(Constants.Documents.Indexing.SideBySideIndexNamePrefix))
+                throw new InvalidOperationException($"Index {index.Name} is already a side-by-side running index.");
+
             try
             {
                 var definitionClone = new IndexDefinition();

test/SlowTests/Issues/RavenDB-22036.cs

@@ -1,7 +1,9 @@
+using System;
 using FastTests;
 using Raven.Client;
 using Raven.Client.Documents.Indexes;
 using Raven.Client.Documents.Operations.Indexes;
+using Raven.Client.Exceptions;
 using Raven.Server.Config;
 using Tests.Infrastructure;
 using Tests.Infrastructure.Extensions;
@@ -242,4 +244,158 @@ public void TestResetIndexOperationWithConfigurationOption(Options options)
             });
         }
     }
+
+    [RavenTheory(RavenTestCategory.Indexes)]
+    [RavenData(DatabaseMode = RavenDatabaseMode.All)]
+    public void TestInPlaceResetOnIndexWithRunningSideBySide(Options options)
+    {
+        using (var store = GetDocumentStore(options))
+        {
+            const string indexName = "Users/ByName";
+
+            store.Maintenance.Send(new PutIndexesOperation(new IndexDefinition
+            {
+                Maps = { "from user in docs.Users select new { user.FirstName }" }, 
+                Type = IndexType.Map, 
+                Name = indexName
+            }));
+
+            store.Maintenance.ForTesting(() => new StopIndexingOperation()).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new ResetIndexOperation(indexName, IndexResetMode.SideBySide)).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.NotNull(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(2, stats.Length);
+            });
+
+            store.Maintenance.ForTesting(() => new ResetIndexOperation(indexName)).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.NotNull(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(2, stats.Length);
+            });
+
+            store.Maintenance.ForTesting(() => new StartIndexingOperation()).ExecuteOnAll();
+
+            Indexes.WaitForIndexing(store);
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.Null(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(1, stats.Length);
+            });
+        }
+    }
+
+    [RavenTheory(RavenTestCategory.Indexes)]
+    [RavenData(DatabaseMode = RavenDatabaseMode.All)]
+    public void TestInPlaceResetOfRunningSideBySideIndex(Options options)
+    {
+        using (var store = GetDocumentStore(options))
+        {
+            const string indexName = "Users/ByName";
+
+            store.Maintenance.Send(new PutIndexesOperation(new IndexDefinition
+            {
+                Maps = { "from user in docs.Users select new { user.FirstName }" }, 
+                Type = IndexType.Map, 
+                Name = indexName
+            }));
+
+            store.Maintenance.ForTesting(() => new StopIndexingOperation()).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new ResetIndexOperation(indexName, IndexResetMode.SideBySide)).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.NotNull(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(2, stats.Length);
+            });
+
+            store.Maintenance.ForTesting(() => new ResetIndexOperation(Constants.Documents.Indexing.SideBySideIndexNamePrefix + indexName)).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.NotNull(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(2, stats.Length);
+            });
+
+            store.Maintenance.ForTesting(() => new StartIndexingOperation()).ExecuteOnAll();
+
+            Indexes.WaitForIndexing(store);
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation($"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}")).AssertAll((key, stats) =>
+            {
+                Assert.Null(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(1, stats.Length);
+            });
+        }
+    }
+
+    [RavenTheory(RavenTestCategory.Indexes)]
+    [RavenData(DatabaseMode = RavenDatabaseMode.All)]
+    public void TestSideBySideResetOfRunningSideBySideIndex(Options options)
+    {
+        using (var store = GetDocumentStore(options))
+        {
+            const string indexName = "Users/ByName";
+            const string replacementIndexName = $"{Constants.Documents.Indexing.SideBySideIndexNamePrefix}{indexName}";
+
+            store.Maintenance.Send(new PutIndexesOperation(new IndexDefinition
+            {
+                Maps = { "from user in docs.Users select new { user.FirstName }" }, 
+                Type = IndexType.Map, 
+                Name = indexName
+            }));
+
+            store.Maintenance.ForTesting(() => new StopIndexingOperation()).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new ResetIndexOperation(indexName, IndexResetMode.SideBySide)).ExecuteOnAll();
+
+            store.Maintenance.ForTesting(() => new GetIndexOperation(replacementIndexName)).AssertAll((key, stats) =>
+            {
+                Assert.NotNull(stats);
+            });
+
+            store.Maintenance.ForTesting(() => new GetIndexNamesOperation(0, int.MaxValue)).AssertAll((key, stats) =>
+            {
+                Assert.Equal(2, stats.Length);
+            });
+
+            var ex = Assert.Throws<RavenException>(() =>
+                store.Maintenance.ForTesting(() => new ResetIndexOperation(replacementIndexName, IndexResetMode.SideBySide)).ExecuteOnAll()
+            );
+
+            Assert.IsType<InvalidOperationException>(ex.InnerException);
+
+            Assert.Contains($"Index {replacementIndexName} is already a side-by-side running index.", ex.InnerException.Message);
+        }
+    }
 }