Raise MSI to 100%

Author: WyriHaximus

infection.json.dist

@@ -11,8 +11,13 @@
         "json": "./var/infection.json",
         "perMutator": "./var/infection-per-mutator.md"
     },
+    "minMsi": 100,
+    "minCoveredMsi": 100,
+    "ignoreMsiWithNoMutations": true,
     "mutators": {
-        "@default": true
+        "@default": true,
+        "GreaterThan": false,
+        "GreaterThanOrEqualTo": false
     },
     "phpUnit": {
         "configDir": "./etc/qa/"

src/WithRandomHeadersMiddleware.php

@@ -8,7 +8,6 @@
 use Psr\Http\Message\ServerRequestInterface;
 use React\Promise\PromiseInterface;
 
-use function array_values;
 use function count;
 use function random_int;
 use function React\Promise\resolve;
@@ -27,7 +26,7 @@ final class WithRandomHeadersMiddleware
 
     public function __construct(Header ...$headers)
     {
-        $this->headers = array_values($headers);
+        $this->headers = $headers;
     }
 
     public function withMinimum(int $minimum): self
@@ -57,12 +56,11 @@ public function __invoke(ServerRequestInterface $request, callable $next): Promi
             shuffle($headers);
             $i = 0;
             do {
-                $header = $headers[$i];
-                if (! ($header instanceof Header)) {
-                    continue;
-                }
-
-                $response = $response->withHeader($header->header, $header->contents);
+                /**
+                 * @psalm-suppress MixedPropertyFetch
+                 * @psalm-suppress MixedArgument
+                 */
+                $response = $response->withHeader($headers[$i]->header, $headers[$i]->contents);
             } while (++$i < $count);
 
             return $response;

tests/WithRandomHeadersMiddlewareTest.php

@@ -8,36 +8,52 @@
 use Psr\Http\Message\ServerRequestInterface;
 use React\Http\Message\Response;
 use React\Http\Message\ServerRequest;
+use ReflectionProperty;
 use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
 use WyriHaximus\React\Http\Middleware\Header;
 use WyriHaximus\React\Http\Middleware\WithRandomHeadersMiddleware;
 
+use function array_key_exists;
+use function array_map;
+use function array_values;
+use function count;
 use function React\Async\await;
+use function strlen;
+use function strtoupper;
 
 final class WithRandomHeadersMiddlewareTest extends AsyncTestCase
 {
-    public function testWithRandomHeaders(): void
+    /** @test */
+    public function withRandomHeaders(): void
     {
-        $headers            = [
-            new Header('X-Hamsterred-By', 'ReactPHP 7'),
-            new Header('X-Foo', 'Bar'),
-            new Header('X-Bar', 'Foo'),
-        ];
-        $middleware         = new WithRandomHeadersMiddleware(...$headers);
+        $headers = [];
+        for ($char = 'a'; strlen($char) === 1; $char++) {
+            $headers['X-' . strtoupper($char)] = new Header('X-' . strtoupper($char), $char);
+        }
+
+        $middleware         = (new WithRandomHeadersMiddleware(...$headers))->withMinimum(count($headers));
         $request            = new ServerRequest('GET', 'https://example.com/');
         $requestWithHeaders = await($middleware($request, static fn (ServerRequestInterface $request): ResponseInterface => new Response()));
 
-        $count = 0;
-
-        foreach ($headers as $header) {
-            if (! $requestWithHeaders->hasHeader($header->header)) {
+        $requestHeaders = [];
+        foreach ($requestWithHeaders->getHeaders() as $headerName => $value) {
+            if (! array_key_exists($headerName, $headers)) {
                 continue;
             }
 
-            $count++;
+            $requestHeaders[] = $headerName;
         }
 
-        self::assertSame(2, $count);
+        self::assertCount(count($headers), $requestHeaders);
+        self::assertNotSame(
+            [
+                ...array_map(
+                    static fn (Header $header): string => $header->header,
+                    array_values($headers),
+                ),
+            ],
+            $requestHeaders,
+        );
     }
 
     /** @test */
@@ -51,14 +67,43 @@ public function immutability(): void
         self::assertNotSame($b, $middleware);
     }
 
-    /** @test */
-    public function minMaxMath(): void
+    /**
+     * @test
+     * @dataProvider minMaxMAthDataProvider
+     */
+    public function minMaxMath(int $min, int $max, int $expectedMin, int $expectedMax): void
     {
-        $a          = new WithRandomHeadersMiddleware(new Header('Foo', 'bar'), new Header('Foo', 'bar'), new Header('Foo', 'bar'), new Header('Foo', 'bar'), new Header('Foo', 'bar'));
-        $b          = $a->withMinimum(5);
-        $middleware = $b->withMaximum(1);
+        $a = new WithRandomHeadersMiddleware(new Header('A', 'a'), new Header('Foo', 'bar'), new Header('Foo', 'bar'), new Header('Foo', 'bar'), new Header('Foo', 'bar'));
+        $b = $a->withMinimum($min);
+
+        self::assertSame($expectedMin, self::getPropertyValue($b, 'minimum'));
+
+        $middleware = $b->withMaximum($max);
         self::assertNotSame($a, $b);
         self::assertNotSame($a, $middleware);
         self::assertNotSame($b, $middleware);
+
+        self::assertSame($expectedMin, self::getPropertyValue($middleware, 'minimum'));
+        self::assertSame($expectedMax, self::getPropertyValue($middleware, 'maximum'));
+    }
+
+    /** @return iterable<array<int>> */
+    public static function minMaxMAthDataProvider(): iterable
+    {
+        yield 'Same' => [1, 1, 1, 1];
+        yield 'Max higher than Min' => [1, 2, 1, 2];
+        yield 'Same but with 2 instead of 1 ' => [2, 2, 2, 2];
+        yield 'Min higher than Max so they are both pulled to Max' => [2, 1, 2, 2];
+        yield 'Min and Max can\'t be higher than the 5 headers we put into it, but with Max lower than Min' => [13, 1, 5, 5];
+        yield 'Min and Max can\'t be higher than the 5 headers we put into it' => [6, 13, 5, 5];
+    }
+
+    private static function getPropertyValue(WithRandomHeadersMiddleware $middleware, string $propertyName): int
+    {
+        $property = (new ReflectionProperty(WithRandomHeadersMiddleware::class, $propertyName));
+        $property->setAccessible(true);
+
+        /** @phpstan-ignore-next-line */
+        return $property->getValue($middleware);
     }
 }