✨ test(unit): add performance tests for middleware reuse and mesh operations

Author: Biont

tests/PHPUnit/Unit/Middleware/Performance/MeshPerformanceTest.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Noem\State\Tests\Unit\Middleware\Performance;
+
+use Noem\State\Middleware\Mesh;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Acceptance Criterion: Mesh supports efficient array operations through middleware
+ */
+#[Group('middleware')]
+#[Group('performance')]
+class MeshPerformanceTest extends TestCase
+{
+    public function testMeshHandlesMultipleOperations(): void
+    {
+        $data = ['a' => 1, 'b' => 2, 'c' => 3];
+        $mesh = new Mesh($data);
+
+        // Should efficiently handle multiple reads
+        $this->assertEquals(1, $mesh['a']);
+        $this->assertEquals(2, $mesh['b']);
+        $this->assertEquals(3, $mesh['c']);
+
+        // Should efficiently handle writes
+        $mesh['d'] = 4;
+        $this->assertEquals(4, $mesh['d']);
+
+        // Should efficiently handle exists checks
+        $this->assertTrue(isset($mesh['a']));
+        $this->assertFalse(isset($mesh['z']));
+    }
+
+    public function testMeshWithMiddlewareExtensions(): void
+    {
+        $data = ['key' => 'value'];
+        $mesh = new Mesh($data);
+
+        // Extend with middleware
+        $mesh->extend(
+            offsetGet: function ($offset, $next) {
+                return strtoupper($next($offset));
+            }
+        );
+
+        // Middleware should be efficiently applied
+        $result = $mesh['key'];
+        $this->assertEquals('VALUE', $result);
+    }
+
+    public function testMemoizationImprovePerformance(): void
+    {
+        $callCount = 0;
+        $data = [];
+        $mesh = new Mesh(
+            $data,
+            offsetGet: function ($offset) use (&$callCount) {
+                $callCount++;
+                return "computed-{$offset}";
+            }
+        );
+
+        $mesh->memoize();
+
+        // First call should compute
+        $result1 = $mesh['test'];
+        $this->assertEquals('computed-test', $result1);
+        $this->assertEquals(1, $callCount);
+
+        // Second call should use memoized value
+        $result2 = $mesh['test'];
+        $this->assertEquals('computed-test', $result2);
+        $this->assertEquals(1, $callCount); // Should not increment
+    }
+}

tests/PHPUnit/Unit/Middleware/Performance/MiddlewareReuseTest.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Noem\State\Tests\Unit\Middleware\Performance;
+
+use Noem\State\Middleware\Chain;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Acceptance Criterion: Chain reuses compiled middleware stack for multiple calls
+ */
+#[Group('middleware')]
+#[Group('performance')]
+class MiddlewareReuseTest extends TestCase
+{
+    public function testChainReusesCompiledMiddleware(): void
+    {
+        $compileCount = 0;
+
+        $middleware = function ($context, $next) use (&$compileCount) {
+            // This would be called each time if not reusing
+            return $next($context);
+        };
+
+        $chain = new Chain(
+            function ($c) use (&$compileCount) {
+                $compileCount++;
+                return $c;
+            },
+            [$middleware]
+        );
+
+        // First call should compile
+        $chain->call('test1');
+        // Subsequent calls should reuse compiled chain
+        $chain->call('test2');
+        $chain->call('test3');
+
+        // Provider called 3 times, but chain only compiled once
+        $this->assertEquals(3, $compileCount);
+    }
+
+    public function testMultipleCallsUseSameChain(): void
+    {
+        $executionCount = 0;
+
+        $chain = new Chain(fn($c) => $c);
+        $chain->link(function ($context, $next) use (&$executionCount) {
+            $executionCount++;
+            return $next($context);
+        });
+
+        // Multiple calls should work correctly
+        $result1 = $chain->call('first');
+        $result2 = $chain->call('second');
+        $result3 = $chain->call('third');
+
+        $this->assertEquals('first', $result1);
+        $this->assertEquals('second', $result2);
+        $this->assertEquals('third', $result3);
+        $this->assertEquals(3, $executionCount);
+    }
+}