Replace FailPointObserver with different logic

Author: alcaeus

tests/UnifiedSpecTests/Context.php

@@ -5,6 +5,7 @@
 use LogicException;
 use MongoDB\Client;
 use MongoDB\Driver\ClientEncryption;
+use MongoDB\Driver\Server;
 use MongoDB\Driver\ServerApi;
 use MongoDB\Model\BSONArray;
 use MongoDB\Tests\FunctionalTestCase;
@@ -60,6 +61,9 @@ final class Context
 
     private ?object $advanceClusterTime = null;
 
+    /** @var list<array{failPoint: stdClass, server: Server}> */
+    private array $failPoints = [];
+
     public function __construct(Client $internalClient, string $uri)
     {
         $this->entityMap = new EntityMap();
@@ -232,6 +236,20 @@ public function stopEventCollectors(): void
         }
     }
 
+    public function registerFailPoint(stdClass $failPoint, Server $server): void
+    {
+        $this->failPoints[] = [
+            'failPoint' => $failPoint,
+            'server' => $server,
+        ];
+    }
+
+    /** @return list<array{failPoint: stdClass, server: Server}> */
+    public function getFailPoints(): array
+    {
+        return $this->failPoints;
+    }
+
     /** @param string|array $readPreferenceTags */
     private function convertReadPreferenceTags($readPreferenceTags): array
     {

tests/UnifiedSpecTests/FailPointObserver.php

@@ -909,16 +909,16 @@ private function executeForTestRunner()
                 assertArrayHasKey('failPoint', $args);
                 assertInstanceOf(Client::class, $args['client']);
                 assertInstanceOf(stdClass::class, $args['failPoint']);
-                $args['client']->selectDatabase('admin')->command($args['failPoint']);
+                $server = $args['client']->selectServer();
+                $this->createFailPoint($args['failPoint'], $server);
                 break;
             case 'targetedFailPoint':
                 assertArrayHasKey('session', $args);
                 assertArrayHasKey('failPoint', $args);
                 assertInstanceOf(Session::class, $args['session']);
                 assertInstanceOf(stdClass::class, $args['failPoint']);
                 assertNotNull($args['session']->getServer(), 'Session is pinned');
-                $operation = new DatabaseCommand('admin', $args['failPoint']);
-                $operation->execute($args['session']->getServer());
+                $this->createFailPoint($args['failPoint'], $args['session']->getServer());
                 break;
             case 'loop':
                 assertArrayHasKey('operations', $args);
@@ -937,6 +937,14 @@ private function executeForTestRunner()
         }
     }
 
+    private function createFailPoint(stdClass $failPoint, Server $server): void
+    {
+        $operation = new DatabaseCommand('admin', $failPoint);
+        $operation->execute($server);
+
+        $this->context->registerFailPoint($failPoint, $server);
+    }
+
     private function getIndexNames(string $databaseName, string $collectionName): array
     {
         return array_map(

tests/UnifiedSpecTests/Operation.php

@@ -77,8 +77,6 @@ final class UnifiedTestRunner
     /** @var callable(EntityMap):void */
     private $entityMapObserver;
 
-    private ?FailPointObserver $failPointObserver = null;
-
     private ServerParameterHelper $serverParameterHelper;
 
     public function __construct(string $internalClientUri)
@@ -150,9 +148,6 @@ private function doSetUp(): void
          * after transient error within a transaction" pinning test causes the
          * subsequent transaction test to block. */
         $this->killAllSessions();
-
-        $this->failPointObserver = new FailPointObserver();
-        $this->failPointObserver->start();
     }
 
     private function doTearDown(bool $hasFailed): void
@@ -163,9 +158,6 @@ private function doTearDown(bool $hasFailed): void
             $this->killAllSessions();
         }
 
-        $this->failPointObserver->stop();
-        $this->failPointObserver->disableFailPoints();
-
         /* Manually invoking garbage collection since each test is prone to
          * create cycles (perhaps due to EntityMap), which can leak and prevent
          * sessions from being released back into the pool. */
@@ -216,13 +208,17 @@ private function doTestCase(stdClass $test, string $schemaVersion, ?array $runOn
         $context->startEventObservers();
         $context->startEventCollectors();
 
-        foreach ($test->operations as $o) {
-            $operation = new Operation($o, $context);
-            $operation->assert();
-        }
+        try {
+            foreach ($test->operations as $o) {
+                $operation = new Operation($o, $context);
+                $operation->assert();
+            }
 
-        $context->stopEventObservers();
-        $context->stopEventCollectors();
+            $context->stopEventObservers();
+            $context->stopEventCollectors();
+        } finally {
+            $this->disableFailPoints($context->getFailPoints());
+        }
 
         if (isset($test->expectEvents)) {
             assertIsArray($test->expectEvents);
@@ -235,6 +231,15 @@ private function doTestCase(stdClass $test, string $schemaVersion, ?array $runOn
         }
     }
 
+    /** @param list<array{failPoint: stdClass, server: Server}> $failPoints */
+    private function disableFailPoints(array $failPoints): void
+    {
+        foreach ($failPoints as ['failPoint' => $failPoint, 'server' => $server]) {
+            $operation = new DatabaseCommand('admin', ['configureFailPoint' => $failPoint, 'mode' => 'off']);
+            $operation->execute($server);
+        }
+    }
+
     /**
      * Checks server version and topology requirements.
      *