test: add tests to kill Negation and MethodCallRemoval mutations

claude · deviantintegral · commit 841019bc19c8 · 2025-12-17T15:50:15.000-05:00
- Add tests for LogicalOrAllSubExprNegation and LogicalOrSingleSubExprNegation
  mutations in ServerRequest::withParsedBody by verifying object data sets
  params correctly and null data doesn't trigger foreach on null
- Add tests for MethodCallRemoval mutations in SplitCommand by verifying
  multiple progress states are shown (progressAdvance) and completion is
  displayed (progressFinish)
- Add tests for IfNegation mutation in PostData::getBodySize by verifying
  correct size calculation with params and no errors without params
diff --git a/tests/src/Functional/SplitCommandTest.php b/tests/src/Functional/SplitCommandTest.php
@@ -355,6 +355,67 @@ public function testSplitUpdatesProgressBar(): void
         $this->assertCount(11, $files, 'Should create 11 files');
     }
 
+    public function testProgressAdvanceIsCalledForEachEntry(): void
+    {
+        // This test kills the MethodCallRemoval mutation for progressAdvance()
+        // by verifying that multiple distinct progress states are shown
+        $harFile = __DIR__.'/../../fixtures/www.softwareishard.com-multiple-entries.har';
+
+        $this->commandTester->execute([
+            'har' => $harFile,
+            'destination' => $this->tempDir,
+        ]);
+
+        $output = $this->commandTester->getDisplay();
+
+        // Count how many distinct progress states are shown (e.g., "2/11", "5/11")
+        // The progress bar updates on each advance, showing different counts
+        preg_match_all('/(\d+)\/11/', $output, $matches);
+        $progressStates = array_unique($matches[1]);
+
+        // Without progressAdvance(), we'd only see 0/11 and 11/11 (2 states)
+        // With progressAdvance(), we should see multiple intermediate states
+        // Note: The exact number depends on terminal refresh rate, but should be > 2
+        $this->assertGreaterThan(2, \count($progressStates),
+            'Progress bar should show multiple intermediate states when progressAdvance() is called. '.
+            'Found states: '.implode(', ', $progressStates));
+
+        // Verify we start at 0 and end at 11
+        $this->assertContains('0', $progressStates, 'Progress should start at 0');
+        $this->assertContains('11', $progressStates, 'Progress should end at 11');
+    }
+
+    public function testProgressFinishShowsCompletion(): void
+    {
+        // This test kills the MethodCallRemoval mutation for progressFinish()
+        // by verifying the final completion state is displayed
+        $harFile = __DIR__.'/../../fixtures/www.softwareishard.com-multiple-entries.har';
+
+        $this->commandTester->execute([
+            'har' => $harFile,
+            'destination' => $this->tempDir,
+        ]);
+
+        $output = $this->commandTester->getDisplay();
+
+        // progressFinish() ensures the progress bar shows the final 100% state
+        // Without it, the bar might not show 100% or the final count
+
+        // Check for 100% completion marker
+        $this->assertStringContainsString('100%', $output,
+            'Progress bar must show 100% completion - this requires progressFinish() to be called');
+
+        // Check that 11/11 appears (the final state)
+        $this->assertMatchesRegularExpression('/11\/11/', $output,
+            'Progress bar must show final 11/11 state - this requires progressFinish() to be called');
+
+        // Verify there's visual progress bar completion (filled bar)
+        // The progress bar uses unicode block characters to show progress
+        // At 100%, the entire bar should be filled
+        $this->assertMatchesRegularExpression('/[▓█=]+/', $output,
+            'Progress bar must show filled progress indicator at completion');
+    }
+
     private function recursiveRemoveDirectory(string $directory): void
     {
         if (!is_dir($directory)) {
diff --git a/tests/src/Unit/Adapter/Psr7/ServerRequestTest.php b/tests/src/Unit/Adapter/Psr7/ServerRequestTest.php
@@ -404,6 +404,78 @@ public function testWithParsedBodyLogicalOrCondition(): void
         //    Would be false for objects, so they wouldn't set params (param names would be old)
     }
 
+    public function testWithParsedBodyObjectFromCleanRequest(): void
+    {
+        // This test specifically kills LogicalOrSingleSubExprNegation by starting
+        // from a request with NO existing params, so we can verify object data sets params
+        $cleanRequest = (new Request())
+            ->setMethod('GET')
+            ->setUrl(new Uri('https://www.example.com/'));
+
+        $serverRequest = new ServerRequest($cleanRequest);
+
+        // Verify no existing parsed body
+        $this->assertNull($serverRequest->getParsedBody());
+
+        // Call withParsedBody with an object
+        $objectData = new \stdClass();
+        $objectData->key1 = 'value1';
+        $objectData->key2 = 'value2';
+
+        $newRequest = $serverRequest->withParsedBody($objectData);
+
+        // Verify params were set from the object
+        // If LogicalOrSingleSubExprNegation mutation is applied (is_array || !is_object),
+        // then for objects: false || !true = false, and the block would be skipped,
+        // resulting in NO params being set
+        $harRequest = $newRequest->getHarRequest();
+        $this->assertTrue($harRequest->hasPostData(), 'Object data must create post data');
+        $this->assertTrue($harRequest->getPostData()->hasParams(), 'Object data must set params');
+
+        $params = $harRequest->getPostData()->getParams();
+        $this->assertCount(2, $params, 'Must have exactly 2 params from object');
+        $this->assertEquals('key1', $params[0]->getName());
+        $this->assertEquals('value1', $params[0]->getValue());
+        $this->assertEquals('key2', $params[1]->getName());
+        $this->assertEquals('value2', $params[1]->getValue());
+    }
+
+    public function testWithParsedBodyNullFromCleanRequest(): void
+    {
+        // This test kills LogicalOrAllSubExprNegation by verifying null doesn't enter
+        // the params-setting block. Start from a clean request to isolate behavior.
+        $cleanRequest = (new Request())
+            ->setMethod('GET')
+            ->setUrl(new Uri('https://www.example.com/'));
+
+        $serverRequest = new ServerRequest($cleanRequest);
+
+        // Set error handler to detect if foreach on null is attempted
+        // If LogicalOrAllSubExprNegation is applied (!is_array || !is_object),
+        // then for null: !false || !false = true, entering the block and
+        // attempting foreach on null
+        $warningTriggered = false;
+        $previousHandler = set_error_handler(function ($errno, $errstr) use (&$warningTriggered) {
+            if (str_contains($errstr, 'foreach')) {
+                $warningTriggered = true;
+            }
+
+            return false; // Allow normal error handling to continue
+        });
+
+        try {
+            $newRequest = $serverRequest->withParsedBody(null);
+
+            // Should NOT have triggered a foreach warning
+            $this->assertFalse($warningTriggered, 'withParsedBody(null) should not attempt foreach');
+
+            // Verify the result is correct
+            $this->assertNull($newRequest->getParsedBody());
+        } finally {
+            restore_error_handler();
+        }
+    }
+
     public function testWithRequestTarget(): void
     {
         $new = $this->serverRequest->withRequestTarget('https://www.example.com/newpath');
diff --git a/tests/src/Unit/PostDataTest.php b/tests/src/Unit/PostDataTest.php
@@ -205,6 +205,67 @@ public function testGetBodySizeIfNegationMutation(): void
         // and NOT happen when there are params (returning 0 incorrectly)
     }
 
+    public function testGetBodySizeWithParamsReturnsCorrectSize(): void
+    {
+        // This test kills IfNegation by verifying the exact size returned when params exist
+        // If the condition is negated, this would return 0 instead of the correct size
+        $postData = new PostData();
+        $postData->setParams([
+            (new Params())->setName('key')->setValue('value'),
+            (new Params())->setName('another')->setValue('test'),
+        ]);
+
+        // key=value&another=test = 22 characters
+        $expectedSize = \strlen('key=value&another=test');
+        $actualSize = $postData->getBodySize();
+
+        // The IfNegation mutant would skip the params calculation and return 0 or text size
+        $this->assertSame($expectedSize, $actualSize, 'getBodySize must calculate from params when params exist');
+        $this->assertNotSame(0, $actualSize, 'getBodySize must not return 0 when params exist');
+    }
+
+    public function testGetBodySizeWithoutParamsDoesNotError(): void
+    {
+        // This test kills IfNegation by verifying no error occurs when hasParams is false
+        // If the condition is negated, foreach would be called on null params, causing an error
+        $postData = new PostData();
+
+        // Set up error handler to catch any warnings
+        $warningTriggered = false;
+        $previousHandler = set_error_handler(function ($errno, $errstr) use (&$warningTriggered) {
+            if (str_contains($errstr, 'foreach') || str_contains($errstr, 'null')) {
+                $warningTriggered = true;
+            }
+
+            return false;
+        });
+
+        try {
+            // This should NOT trigger a foreach warning
+            $result = $postData->getBodySize();
+
+            $this->assertFalse($warningTriggered, 'getBodySize() should not attempt foreach on null params');
+            $this->assertSame(0, $result, 'getBodySize() should return 0 when no params and no text');
+        } finally {
+            restore_error_handler();
+        }
+    }
+
+    public function testGetBodySizeWithTextButNoParams(): void
+    {
+        // This tests that when we have text but no params, we get text size
+        // If IfNegation is applied, it would try foreach on null (error) or skip to wrong branch
+        $postData = new PostData();
+        $postData->setText('hello world');
+
+        $this->assertFalse($postData->hasParams());
+        $this->assertTrue($postData->hasText());
+
+        // Should return text size, not 0 and not cause an error
+        $expectedSize = \strlen('hello world');
+        $this->assertSame($expectedSize, $postData->getBodySize());
+    }
+
     public function testSetTextIsPublic(): void
     {
         // This test kills the PublicVisibility mutant by explicitly verifying
