Handle failures ourselves, handle exceptions you already have

Author: aarondfrancis

.gitignore

@@ -10,4 +10,5 @@ vendor
 node_modules
 
 docs/*.blade.php
-docs/**/*.blade.php
+docs/**/*.blade.php
+.phpunit.cache/test-results

src/Arbiter.php

@@ -19,7 +19,7 @@ class Arbiter
 
     public $totalFailuresAllowed = INF;
 
-    public $throw = true;
+    public $handleFailuresWith;
 
     protected $key;
 
@@ -41,10 +41,19 @@ public function __construct($id)
         $this->totalFailures = Arr::get($stats, 'total', 0);
         $this->consecutiveFailures = Arr::get($stats, 'consecutive', 0);
         $this->deadline = Arr::get($stats, 'deadline');
+
+        $this->handleFailuresWith = function ($e) {
+            throw $e;
+        };
     }
 
-    public function handle($exception)
+    public function handle($exception, $bypassProtections = false)
     {
+        if ($bypassProtections) {
+            $this->callHandler($exception);
+            return;
+        }
+
         $this->deadline = $this->deadline ?? $this->freshDeadline();
 
         if ($exception) {
@@ -55,10 +64,15 @@ public function handle($exception)
         $this->updateCachedStats($exception);
 
         if ($this->outOfBounds() && !is_null($exception)) {
-            $this->throw ? throw $exception : report($exception);
+            $this->callHandler($exception);
         }
     }
 
+    public function handleFailures($callback)
+    {
+        $this->handleFailuresWith = $callback;
+    }
+
     public function outOfBounds()
     {
         return $this->tooManyConsecutiveFailures() || $this->tooManyTotalFailures() || $this->beyondDeadline();
@@ -79,6 +93,11 @@ public function beyondDeadline()
         return now()->timestamp > $this->deadline;
     }
 
+    protected function callHandler($exception)
+    {
+        call_user_func($this->handleFailuresWith, $exception);
+    }
+
     protected function freshDeadline()
     {
         return now()->addSeconds($this->failuresAllowedForSeconds)->timestamp;

src/Flaky.php

@@ -45,26 +45,38 @@ public function __construct($id)
 
     public function run(callable $callable)
     {
-        $failed = false;
         $exception = null;
         $value = null;
 
         try {
             $value = retry($this->retry['times'], $callable, $this->retry['sleep'], $this->retry['when']);
         } catch (Throwable $e) {
-            $failed = true;
             $exception = $e;
         }
 
-        if ($this->protectionsBypassed() && $failed) {
-            throw $exception;
-        }
-
-        $this->arbiter->handle($exception);
+        $this->arbiter->handle($exception, $this->protectionsBypassed());
 
         return new Result($value, $exception);
     }
 
+    public function handle(Throwable $exception = null)
+    {
+        return $this->run(function () use ($exception) {
+            if (!is_null($exception)) {
+                throw $exception;
+            }
+        });
+    }
+
+    public function disableLocally()
+    {
+        if (app()->environment('local')) {
+            $this->disableFlakyProtection();
+        }
+
+        return $this;
+    }
+
     public function disableFlakyProtection($disabled = true)
     {
         $this->flakyProtectionDisabled = $disabled;
@@ -84,18 +96,25 @@ public function retry($times = 0, $sleepMilliseconds = 0, $when = null)
         return $this;
     }
 
-    public function reportFailures()
+    public function handleFailures($callback)
     {
-        $this->arbiter->throw = false;
+        $this->arbiter->handleFailures($callback);
 
         return $this;
     }
 
-    public function throwFailures()
+    public function reportFailures()
     {
-        $this->arbiter->throw = true;
+        return $this->handleFailures(function ($e) {
+            report($e);
+        });
+    }
 
-        return $this;
+    public function throwFailures()
+    {
+        return $this->handleFailures(function ($e) {
+            throw $e;
+        });
     }
 
     public function allowFailuresFor($seconds = 0, $minutes = 0, $hours = 0, $days = 0)

tests/Unit/BasicTest.php

@@ -93,8 +93,7 @@ public function too_many_total_throw()
     /** @test */
     public function reported_instead_of_thrown()
     {
-        $handler = new class
-        {
+        $handler = new class {
             public $reported;
 
             public function report(Throwable $e)
@@ -117,4 +116,74 @@ public function report(Throwable $e)
         $this->assertNotNull($handler->reported);
         $this->assertInstanceOf(Exception::class, $handler->reported);
     }
+
+    /** @test */
+    public function can_disable()
+    {
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Oops');
+
+        Flaky::make(__FUNCTION__)
+            ->allowFailuresForADay()
+            ->disableFlakyProtection()
+            ->run(function () {
+                throw new Exception('Oops');
+            });
+
+        config(['app.env' => 'production']);
+
+    }
+
+    /** @test */
+    public function can_disable_locally()
+    {
+        Flaky::make(__FUNCTION__)
+            ->allowFailuresForADay()
+            ->run(function () {
+                throw new Exception('Oops');
+            });
+
+        $this->app->detectEnvironment(function () {
+            return 'local';
+        });
+
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Oops');
+
+        Flaky::make(__FUNCTION__)
+            ->allowFailuresForADay()
+            ->disableLocally()
+            ->run(function () {
+                throw new Exception('Oops');
+            });
+    }
+
+    /** @test */
+    public function can_handle_failures_ourselves()
+    {
+        $caught = null;
+        $handled = false;
+
+        Flaky::make(__FUNCTION__)
+            ->allowConsecutiveFailures(0)
+            ->handleFailures(function ($e) use (&$caught, &$handled) {
+                $caught = $e;
+                $handled = true;
+            })
+            ->run(function () {
+                throw new Exception('Oops');
+            });
+
+        $this->assertTrue($handled);
+        $this->assertInstanceOf(Exception::class, $caught);
+    }
+
+    /** @test */
+    public function can_pass_in_our_own_exception()
+    {
+        $result = Flaky::make(__FUNCTION__)->handle(new Exception('Oops'));
+
+        $this->assertInstanceOf(Result::class, $result);
+    }
+
 }