Support cancellation for RetryExecutor

Author: clue

src/Query/RetryExecutor.php

@@ -17,35 +17,28 @@ public function __construct(ExecutorInterface $executor, $retries = 2)
 
     public function query($nameserver, Query $query)
     {
-        $deferred = new Deferred();
-
-        $this->tryQuery($nameserver, $query, $this->retries, $deferred);
-
-        return $deferred->promise();
+        return $this->tryQuery($nameserver, $query, $this->retries);
     }
 
-    public function tryQuery($nameserver, Query $query, $retries, $deferred)
+    public function tryQuery($nameserver, Query $query, $retries)
     {
         $that = $this;
-        $errorback = function ($error) use ($nameserver, $query, $retries, $deferred, $that) {
+        $errorback = function ($error) use ($nameserver, $query, $retries, $that) {
             if (!$error instanceof TimeoutException) {
-                $deferred->reject($error);
-                return;
+                throw $error;
             }
             if (0 >= $retries) {
-                $error = new \RuntimeException(
+                throw new \RuntimeException(
                     sprintf("DNS query for %s failed: too many retries", $query->name),
                     0,
                     $error
                 );
-                $deferred->reject($error);
-                return;
             }
-            $that->tryQuery($nameserver, $query, $retries-1, $deferred);
+            return $that->tryQuery($nameserver, $query, $retries-1);
         };
 
-        $this->executor
+        return $this->executor
             ->query($nameserver, $query)
-            ->then(array($deferred, 'resolve'), $errorback);
+            ->then(null, $errorback);
     }
 }

tests/Query/RetryExecutorTest.php

@@ -9,6 +9,8 @@
 use React\Dns\Query\TimeoutException;
 use React\Dns\Model\Record;
 use React\Promise;
+use React\Promise\Deferred;
+use React\Dns\Query\CancellationException;
 
 class RetryExecutorTest extends TestCase
 {
@@ -125,6 +127,45 @@ public function queryShouldForwardNonTimeoutErrors()
         $retryExecutor->query('8.8.8.8', $query)->then($callback, $errorback);
     }
 
+    /**
+     * @covers React\Dns\Query\RetryExecutor
+     * @test
+     */
+    public function queryShouldCancelQueryOnCancel()
+    {
+        if (!interface_exists('React\Promise\CancellablePromiseInterface')) {
+            $this->markTestSkipped('Skipped missing CancellablePromiseInterface');
+        }
+
+        $cancelled = 0;
+
+        $executor = $this->createExecutorMock();
+        $executor
+            ->expects($this->once())
+            ->method('query')
+            ->with('8.8.8.8', $this->isInstanceOf('React\Dns\Query\Query'))
+            ->will($this->returnCallback(function ($domain, $query) use (&$cancelled) {
+                $deferred = new Deferred(function ($resolve, $reject) use (&$cancelled) {
+                    ++$cancelled;
+                    $reject(new CancellationException('Cancelled'));
+                });
+
+                return $deferred->promise();
+            })
+        );
+
+        $retryExecutor = new RetryExecutor($executor, 2);
+
+        $query = new Query('igor.io', Message::TYPE_A, Message::CLASS_IN, 1345656451);
+        $promise = $retryExecutor->query('8.8.8.8', $query);
+
+        $promise->then($this->expectCallableNever(), $this->expectCallableOnce());
+
+        $this->assertEquals(0, $cancelled);
+        $promise->cancel();
+        $this->assertEquals(1, $cancelled);
+    }
+
     protected function expectCallableOnce()
     {
         $mock = $this->createCallableMock();