MAGE-1218 Add mock scenario for repeated patch application attempts

cammonro · cammonro · commit 948e6cbcbd1e · 2025-04-01T04:34:46.000-04:00
diff --git a/Setup/Patch/Data/RebuildReplicasPatch.php b/Setup/Patch/Data/RebuildReplicasPatch.php
@@ -2,13 +2,16 @@
 
 namespace Algolia\AlgoliaSearch\Setup\Patch\Data;
 
+use Algolia\AlgoliaSearch\Exceptions\AlgoliaException;
+use Algolia\AlgoliaSearch\Exceptions\ExceededRetriesException;
 use Algolia\AlgoliaSearch\Helper\ConfigHelper;
 use Algolia\AlgoliaSearch\Helper\Entity\ProductHelper;
 use Algolia\AlgoliaSearch\Registry\ReplicaState;
 use Algolia\AlgoliaSearch\Service\Product\ReplicaManager;
 use Magento\Framework\App\Area;
 use Magento\Framework\App\State as AppState;
 use Magento\Framework\Exception\LocalizedException;
+use Magento\Framework\Exception\NoSuchEntityException;
 use Magento\Framework\Setup\ModuleDataSetupInterface;
 use Magento\Framework\Setup\Patch\DataPatchInterface;
 use Magento\Framework\Setup\Patch\PatchInterface;
@@ -66,17 +69,37 @@ public function apply(): PatchInterface
 
         $storeIds = array_keys($this->storeManager->getStores());
         // Delete all replicas before resyncing in case of incorrect replica assignments
-        foreach ($storeIds as $storeId) {
-            $this->replicaManager->deleteReplicasFromAlgolia($storeId);
-        }
 
-        foreach ($storeIds as $storeId) {
-            $this->replicaState->setChangeState(ReplicaState::REPLICA_STATE_CHANGED, $storeId); // avoids latency
-            $this->replicaManager->syncReplicasToAlgolia($storeId, $this->productHelper->getIndexSettings($storeId));
+        try {
+            foreach ($storeIds as $storeId) {
+                $this->retryDeleteReplica($storeId);
+            }
+
+            foreach ($storeIds as $storeId) {
+                $this->replicaState->setChangeState(ReplicaState::REPLICA_STATE_CHANGED, $storeId); // avoids latency
+                $this->replicaManager->syncReplicasToAlgolia($storeId, $this->productHelper->getIndexSettings($storeId));
+            }
+        }
+        catch (AlgoliaException $e) {
+            $this->logger->error("Could not rebuild replicas - a full reindex will be required.");
         }
 
         $this->moduleDataSetup->getConnection()->endSetup();
 
         return $this;
     }
+
+    protected function retryDeleteReplica(int $storeId, int $maxRetries = 3, int $interval = 5)
+    {
+        for ($tries = $maxRetries - 1; $tries >= 0; $tries--) {
+            try {
+                $this->replicaManager->deleteReplicasFromAlgolia($storeId);
+                return;
+            } catch (AlgoliaException $e) {
+                $this->logger->warning(__("Unable to delete replicas, %1 tries remaining: %2", $tries, $e->getMessage()));
+                sleep($interval);
+            }
+        }
+        throw new ExceededRetriesException('Unable to delete old replica indices after $maxRetries retries.');
+    }
 }
diff --git a/Test/Integration/Product/ReplicaIndexingTest.php b/Test/Integration/Product/ReplicaIndexingTest.php
@@ -13,11 +13,16 @@
 use Algolia\AlgoliaSearch\Model\IndicesConfigurator;
 use Algolia\AlgoliaSearch\Registry\ReplicaState;
 use Algolia\AlgoliaSearch\Service\IndexNameFetcher;
+use Algolia\AlgoliaSearch\Service\Product\ReplicaManager;
 use Algolia\AlgoliaSearch\Service\Product\SortingTransformer;
 use Algolia\AlgoliaSearch\Service\StoreNameFetcher;
 use Algolia\AlgoliaSearch\Test\Integration\TestCase;
 use Algolia\AlgoliaSearch\Validator\VirtualReplicaValidatorFactory;
+use Magento\Framework\App\State as AppState;
+use Magento\Framework\Setup\ModuleDataSetupInterface;
 use Magento\Store\Model\StoreManagerInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use Psr\Log\LoggerInterface;
 
 class ReplicaIndexingTest extends TestCase
 {
@@ -28,6 +33,8 @@ class ReplicaIndexingTest extends TestCase
 
     protected ?string $indexName = null;
 
+    protected ?int $patchRetries = 3;
+
     protected function setUp(): void
     {
         parent::setUp();
@@ -245,7 +252,7 @@ public function testReplicaDelete(): void
     }
 
     /**
-     * Test
+     * Test failure to clear index replica setting
      * @magentoConfigFixture current_store algoliasearch_instant/instant/is_instant_enabled 1
      */
     public function testReplicaDeleteUnreliable(): void
@@ -260,7 +267,7 @@ public function testReplicaDeleteUnreliable(): void
 
         $this->assertEquals(count($sorting), count($replicas));
 
-        $this->getCrippledReplicaManager()->deleteReplicasFromAlgolia(1);
+        $this->getMustPrevalidateMockReplicaManager()->deleteReplicasFromAlgolia(1);
 
         $newSettings = $this->algoliaHelper->getSettings($primaryIndexName);
         $this->assertArrayNotHasKey('replicas', $newSettings);
@@ -269,6 +276,33 @@ public function testReplicaDeleteUnreliable(): void
         }
     }
 
+    /**
+     * @magentoConfigFixture current_store algoliasearch_instant/instant/is_instant_enabled 1
+     */
+    public function testReplicaRebuildPatch(): void
+    {
+        $primaryIndexName = $this->indexName;
+        $sorting = $this->populateReplicas(1);
+        $currentSettings = $this->algoliaHelper->getSettings($primaryIndexName);
+        $this->assertArrayHasKey('replicas', $currentSettings);
+        $replicas = $currentSettings['replicas'];
+
+        $this->assertTrue($this->configHelper->credentialsAreConfigured());
+
+        $patch = new \Algolia\AlgoliaSearch\Setup\Patch\Data\RebuildReplicasPatch(
+            $this->objectManager->get(ModuleDataSetupInterface::class),
+            $this->objectManager->get(StoreManagerInterface::class),
+            $this->getTroublesomePatchReplicaManager(),
+            $this->objectManager->get(ProductHelper::class),
+            $this->objectManager->get(AppState::class),
+            $this->objectManager->get(ReplicaState::class),
+            $this->configHelper,
+            $this->objectManager->get(LoggerInterface::class)
+        );
+
+        $patch->apply();
+    }
+
     protected function extractIndexFromReplicaSetting(string $setting): string {
         return preg_replace('/^virtual\((.*)\)$/', '$1', $setting);
     }
@@ -279,14 +313,56 @@ protected function extractIndexFromReplicaSetting(string $setting): string {
      * This aims to reproduce this potential scenario by not disassociating the replica
      *
      */
-    protected function getCrippledReplicaManager(): ReplicaManagerInterface
+    protected function getMustPrevalidateMockReplicaManager(): ReplicaManagerInterface
     {
-        $mockedClass = \Algolia\AlgoliaSearch\Service\Product\ReplicaManager::class;
         $mockedMethod = 'clearReplicasSettingInAlgolia';
+
+        $mock = $this->getMockReplicaManager([
+            $mockedMethod => function(...$params) {
+                //DO NOTHING
+                return;
+            }
+        ]);
+        $mock->expects($this->once())->method($mockedMethod);
+        return $mock;
+    }
+
+    /**
+     * This mock is to recreate the scenario where a patch tries to apply up to 3 times but the replicas
+     * are never detached which throws a replica delete error until the last attempt which should succeed
+     */
+    protected function getTroublesomePatchReplicaManager(): ReplicaManager
+    {
+        $mock = $this->getMockReplicaManager([
+            'clearReplicasSettingInAlgolia' => null,
+            'deleteReplicas' => null
+        ]);
+        $mock
+            ->expects($this->exactly($this->patchRetries))
+            ->method('clearReplicasSettingInAlgolia')
+            ->willReturnCallback(function(...$params) use ($mock) {
+                if (--$this->patchRetries) return;
+                $originalMethod = new \ReflectionMethod(ReplicaManager::class, 'clearReplicasSettingInAlgolia');
+                $originalMethod->invoke($mock, ...$params);
+            });
+        $mock
+            ->expects($this->any())
+            ->method('deleteReplicas')
+            ->willReturnCallback(function(array $replicasToDelete, ...$params) use ($mock) {
+                $originalMethod = new \ReflectionMethod(ReplicaManager::class, 'deleteReplicas');
+                $originalMethod->invoke($mock, $replicasToDelete, false, false);
+            });
+
+        return $mock;
+    }
+
+    protected function getMockReplicaManager($mockedMethods = array()): MockObject & ReplicaManager
+    {
+        $mockedClass = ReplicaManager::class;
         $mockedReplicaManager = $this->getMockBuilder($mockedClass)
             ->setConstructorArgs([
-                $this->objectManager->get(ConfigHelper::class),
-                $this->objectManager->get(AlgoliaHelper::class),
+                $this->configHelper,
+                $this->algoliaHelper,
                 $this->objectManager->get(ReplicaState::class),
                 $this->objectManager->get(VirtualReplicaValidatorFactory::class),
                 $this->objectManager->get(IndexNameFetcher::class),
@@ -295,23 +371,16 @@ protected function getCrippledReplicaManager(): ReplicaManagerInterface
                 $this->objectManager->get(StoreManagerInterface::class),
                 $this->objectManager->get(Logger::class)
             ])
-            ->onlyMethods([$mockedMethod])
+            ->onlyMethods(array_keys($mockedMethods))
             ->getMock();
-        $mockedReplicaManager
-            ->expects($this->once())
-            ->method($mockedMethod)
-            ->willReturnCallback(
-                function (...$params)
-                use ($mockedClass, $mockedMethod, $mockedReplicaManager)
-                {
-                    // DO NOTHING
-                    return;
-
-                    // If aiming to test a throttle on retry invoke after a specified number of failures
-                    //$originalMethod = new \ReflectionMethod($mockedClass, $mockedMethod);
-                    //return $originalMethod->invoke($mockedReplicaManager, ...$params);
-                }
-            );
+
+        foreach ($mockedMethods as $method => $callback) {
+            if (!$callback) continue;
+            $mockedReplicaManager
+                ->method($method)
+                ->willReturnCallback($callback);
+        }
+
         return $mockedReplicaManager;
     }
 
