feat: allows to use test calls on before each calls

src/Concerns/Testable.php

@@ -181,7 +181,7 @@ trait Testable
 
         parent::setUp();
 
-        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename);
+        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
         if ($this->__beforeEach instanceof Closure) {
             $beforeEach = ChainableClosure::from($this->__beforeEach, $beforeEach);

src/Functions.php

@@ -43,7 +43,7 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
-     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|mixed
+     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|TestCase|mixed
      */
     function beforeEach(Closure $closure = null): BeforeEachCall
     {

src/PendingCalls/BeforeEachCall.php

@@ -19,12 +19,17 @@ final class BeforeEachCall
     /**
      * Holds the before each closure.
      */
-    private readonly \Closure $closure;
+    private readonly Closure $closure;
 
     /**
-     * The calls that should be proxied.
+     * The test call proxies.
      */
-    private readonly HigherOrderMessageCollection $proxies;
+    private readonly HigherOrderMessageCollection $testCallProxies;
+
+    /**
+     * The test case proxies.
+     */
+    private readonly HigherOrderMessageCollection $testCaseProxies;
 
     /**
      * Creates a new Pending Call.
@@ -36,7 +41,8 @@ final class BeforeEachCall
     ) {
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 
-        $this->proxies = new HigherOrderMessageCollection();
+        $this->testCallProxies = new HigherOrderMessageCollection();
+        $this->testCaseProxies = new HigherOrderMessageCollection();
     }
 
     /**
@@ -44,13 +50,16 @@ final class BeforeEachCall
      */
     public function __destruct()
     {
-        $proxies = $this->proxies;
+        $testCaseProxies = $this->testCaseProxies;
 
         $this->testSuite->beforeEach->set(
             $this->filename,
-            ChainableClosure::from(function () use ($proxies): void {
-                $proxies->chain($this);
-            }, $this->closure)
+            function (TestCall $testCall): void {
+                $this->testCallProxies->chain($testCall);
+            },
+            ChainableClosure::from(function () use ($testCaseProxies): void {
+                $testCaseProxies->chain($this);
+            }, $this->closure),
         );
     }
 
@@ -61,7 +70,13 @@ final class BeforeEachCall
      */
     public function __call(string $name, array $arguments): self
     {
-        $this->proxies
+        if (method_exists(TestCall::class, $name)) {
+            $this->testCallProxies->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
+
+            return $this;
+        }
+
+        $this->testCaseProxies
             ->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
 
         return $this;

src/PendingCalls/TestCall.php

@@ -40,12 +40,15 @@ final class TestCall
      */
     public function __construct(
         private readonly TestSuite $testSuite,
-        string $filename,
+        private readonly string $filename,
         string $description = null,
         Closure $closure = null
     ) {
         $this->testCaseMethod = new TestCaseMethodFactory($filename, $description, $closure);
+
         $this->descriptionLess = $description === null;
+
+        $this->testSuite->beforeEach->get($filename)[0]($this);
     }
 
     /**
@@ -167,7 +170,7 @@ final class TestCall
 
         $this->testCaseMethod
             ->chains
-            ->addWhen($condition, Backtrace::file(), Backtrace::line(), 'markTestSkipped', [$message]);
+            ->addWhen($condition, $this->filename, Backtrace::line(), 'markTestSkipped', [$message]);
 
         return $this;
     }

src/Repositories/BeforeEachRepository.php

@@ -14,27 +14,34 @@ use Pest\Support\NullClosure;
 final class BeforeEachRepository
 {
     /**
-     * @var array<string, Closure>
+     * @var array<string, array{0: Closure, 1: Closure}>
      */
     private array $state = [];
 
     /**
      * Sets a before each closure.
      */
-    public function set(string $filename, Closure $closure): void
+    public function set(string $filename, Closure $beforeEachTestCall, Closure $beforeEachTestCase): void
     {
         if (array_key_exists($filename, $this->state)) {
             throw new BeforeEachAlreadyExist($filename);
         }
 
-        $this->state[$filename] = $closure;
+        $this->state[$filename] = [$beforeEachTestCall, $beforeEachTestCase];
     }
 
     /**
      * Gets a before each closure by the given filename.
+     *
+     * @return array{0: Closure, 1: Closure}
      */
-    public function get(string $filename): Closure
+    public function get(string $filename): array
     {
-        return $this->state[$filename] ?? NullClosure::create();
+        $closures = $this->state[$filename] ?? [];
+
+        return [
+            $closures[0] ?? NullClosure::create(),
+            $closures[1] ?? NullClosure::create(),
+        ];
     }
 }

src/Support/Backtrace.php

@@ -104,8 +104,6 @@ final class Backtrace
     {
         $trace = debug_backtrace(self::BACKTRACE_OPTIONS)[1];
 
-        assert(array_key_exists('line', $trace));
-
-        return $trace['line'];
+        return $trace['line'] ?? 0;
     }
 }