Mutant & Mutation tweaks

src/Metrics/MetricsCalculator.php

@@ -68,7 +68,7 @@ class MetricsCalculator
     /**
      * @var int
      */
-    private $notCoveredByTestsCount = 0;
+    private $notExecutedByTestsCount = 0;
 
     /**
      * @var int
@@ -110,7 +110,7 @@ public function collect(MutantExecutionResult ...$executionResults): void
                     break;
 
                 case DetectionStatus::NOT_COVERED:
-                    $this->notCoveredByTestsCount++;
+                    $this->notExecutedByTestsCount++;
                     $this->notCoveredExecutionResults->add($executionResult);
 
                     break;
@@ -164,7 +164,7 @@ public function getTimedOutCount(): int
 
     public function getNotTestedCount(): int
     {
-        return $this->notCoveredByTestsCount;
+        return $this->notExecutedByTestsCount;
     }
 
     public function getTotalMutantsCount(): int

src/Mutant/Mutant.php

@@ -81,16 +81,11 @@ public function getDiff(): string
         return $this->diff;
     }
 
-    public function isCoveredByTest(): bool
-    {
-        return $this->mutation->isCoveredByTest();
-    }
-
     /**
      * @return TestLocation[]
      */
     public function getTests(): array
     {
-        return $this->mutation->getAllTests();
+        return $this->mutation->getTests();
     }
 }

src/Mutant/MutantExecutionResultFactory.php

@@ -86,7 +86,7 @@ private function retrieveProcessOutput(Process $process): string
 
     private function retrieveDetectionStatus(MutantProcess $mutantProcess): string
     {
-        if (!$mutantProcess->getMutant()->isCoveredByTest()) {
+        if (!$mutantProcess->getMutant()->getMutation()->hasTests()) {
             return DetectionStatus::NOT_COVERED;
         }
 

src/Mutation/Mutation.php

@@ -70,7 +70,7 @@ class Mutation
     private $attributes;
     private $originalFileAst;
     private $tests;
-    private $coveredByTests;
+    private $executedByTests;
 
     /**
      * @var string|null
@@ -106,7 +106,7 @@ public function __construct(
         $this->mutatedNode = $mutatedNode;
         $this->mutationByMutatorIndex = $mutationByMutatorIndex;
         $this->tests = $tests;
-        $this->coveredByTests = count($tests) > 0;
+        $this->executedByTests = count($tests) > 0;
     }
 
     public function getOriginalFilePath(): string
@@ -150,16 +150,15 @@ public function getMutatedNode(): MutatedNode
         return $this->mutatedNode;
     }
 
-    // TODO: hasTest()?
-    public function isCoveredByTest(): bool
+    public function hasTests(): bool
     {
-        return $this->coveredByTests;
+        return $this->executedByTests;
     }
 
     /**
      * @return TestLocation[]
      */
-    public function getAllTests(): array
+    public function getTests(): array
     {
         return $this->tests;
     }

src/Process/Builder/MutantProcessBuilder.php

@@ -70,12 +70,14 @@ public function __construct(
 
     public function createProcessForMutant(Mutant $mutant, string $testFrameworkExtraOptions = ''): MutantProcess
     {
+        $mutation = $mutant->getMutation();
+
         $process = new Process(
             $this->testFrameworkAdapter->getMutantCommandLine(
-                $mutant->getTests(),
+                $mutation->getTests(),
                 $mutant->getFilePath(),
-                $mutant->getMutation()->getHash(),
-                $mutant->getMutation()->getOriginalFilePath(),
+                $mutation->getHash(),
+                $mutation->getOriginalFilePath(),
                 $testFrameworkExtraOptions
             )
         );

src/Process/Runner/MutationTestingRunner.php

@@ -89,8 +89,11 @@ public function run(iterable $mutations, string $testFrameworkExtraOptions): voi
                 return $this->mutantFactory->create($mutation);
             })
             ->filter(function (Mutant $mutant) {
-                // It's a proxy call to Mutation, can be done one stage up
-                if ($mutant->isCoveredByTest()) {
+                // The filtering is done here since with a mutant and not earlier with a mutation
+                // since:
+                // - if pass the filtering, the mutant is going to be used
+                // - if does not pass the filtering, the mutant is used for the reports
+                if ($mutant->getMutation()->hasTests()) {
                     return true;
                 }
 

tests/phpunit/Mutant/MutantAssertions.php

@@ -35,29 +35,21 @@
 
 namespace Infection\Tests\Mutant;
 
-use Infection\AbstractTestFramework\Coverage\TestLocation;
 use Infection\Mutant\Mutant;
 use Infection\Mutation\Mutation;
 
 trait MutantAssertions
 {
-    /**
-     * @param TestLocation[] $expectedTests
-     */
     public function assertMutantStateIs(
         Mutant $mutant,
         string $expectedFilePath,
         Mutation $expectedMutation,
         string $expectedMutatedCode,
-        string $expectedDiff,
-        bool $expectedCoveredByTests,
-        array $expectedTests
+        string $expectedDiff
     ): void {
         $this->assertSame($expectedFilePath, $mutant->getFilePath());
         $this->assertSame($expectedMutation, $mutant->getMutation());
         $this->assertSame($expectedMutatedCode, $mutant->getMutatedCode());
         $this->assertSame($expectedDiff, $mutant->getDiff());
-        $this->assertSame($expectedCoveredByTests, $mutant->isCoveredByTest());
-        $this->assertSame($expectedTests, $mutant->getTests());
     }
 }

tests/phpunit/Mutant/MutantFactoryTest.php

@@ -98,13 +98,7 @@ public function test_it_creates_a_mutant_instance_from_the_given_mutation(): voi
                 new Node\Name('Acme'),
                 [new Node\Scalar\LNumber(0)]
             )],
-            $tests = [
-                new TestLocation(
-                    'FooTest::test_it_can_instantiate',
-                    '/path/to/acme/FooTest.php',
-                    0.01
-                ),
-            ]
+            []
         );
 
         $expectedMutantFilePath = sprintf(
@@ -140,9 +134,7 @@ public function test_it_creates_a_mutant_instance_from_the_given_mutation(): voi
             $expectedMutantFilePath,
             $mutation,
             'mutated code',
-            'code diff',
-            true,
-            $tests
+            'code diff'
         );
     }
 

tests/phpunit/Mutant/MutantTest.php

@@ -50,16 +50,12 @@ final class MutantTest extends TestCase
 
     /**
      * @dataProvider valuesProvider
-     *
-     * @param TestLocation[] $expectedTests
      */
     public function test_it_can_be_instantiated(
         string $filePath,
         Mutation $mutation,
         string $mutatedCode,
-        string $diff,
-        bool $expectedCoveredByTests,
-        array $expectedTests
+        string $diff
     ): void {
         $mutant = new Mutant($filePath, $mutation, $mutatedCode, $diff);
 
@@ -68,9 +64,7 @@ public function test_it_can_be_instantiated(
             $filePath,
             $mutation,
             $mutatedCode,
-            $diff,
-            $expectedCoveredByTests,
-            $expectedTests
+            $diff
         );
     }
 
@@ -110,8 +104,6 @@ public function valuesProvider(): iterable
             ),
             'mutated code',
             'diff value',
-            true,
-            $tests,
         ];
 
         yield 'nominal without tests' => [
@@ -131,8 +123,6 @@ public function valuesProvider(): iterable
             ),
             'mutated code',
             'diff value',
-            false,
-            [],
         ];
     }
 }

tests/phpunit/Mutation/MutationTest.php

@@ -66,7 +66,7 @@ public function test_it_can_be_instantiated(
         array $tests,
         array $expectedAttributes,
         int $expectedOriginalStartingLine,
-        bool $expectedCoveredByTests,
+        bool $expectedHasTests,
         string $expectedHash
     ): void {
         $mutation = new Mutation(
@@ -87,8 +87,8 @@ public function test_it_can_be_instantiated(
         $this->assertSame($expectedOriginalStartingLine, $mutation->getOriginalStartingLine());
         $this->assertSame($mutatedNodeClass, $mutation->getMutatedNodeClass());
         $this->assertSame($mutatedNode, $mutation->getMutatedNode());
-        $this->assertSame($tests, $mutation->getAllTests());
-        $this->assertSame($expectedCoveredByTests, $mutation->isCoveredByTest());
+        $this->assertSame($tests, $mutation->getTests());
+        $this->assertSame($expectedHasTests, $mutation->hasTests());
         $this->assertSame($expectedHash, $mutation->getHash());
     }