Merge branch 'master' into 3.0

php-cs-fixer

@@ -25,8 +25,8 @@ if (defined('HHVM_VERSION_ID')) {
     } else {
         exit(1);
     }
-} elseif (!defined('PHP_VERSION_ID') || \PHP_VERSION_ID < 50600 || \PHP_VERSION_ID >= 70400) {
-    fwrite(STDERR, "PHP needs to be a minimum version of PHP 5.6.0 and maximum version of PHP 7.3.*.\n");
+} elseif (!defined('PHP_VERSION_ID') || \PHP_VERSION_ID < 50600 || \PHP_VERSION_ID >= 70500) {
+    fwrite(STDERR, "PHP needs to be a minimum version of PHP 5.6.0 and maximum version of PHP 7.4.*.\n");
 
     if (getenv('PHP_CS_FIXER_IGNORE_ENV')) {
         fwrite(STDERR, "Ignoring environment requirements because `PHP_CS_FIXER_IGNORE_ENV` is set. Execution may be unstable.\n");

tests/AutoReview/TravisTest.php

@@ -31,58 +31,106 @@ final class TravisTest extends TestCase
 {
     public function testTestJobsRunOnEachPhp()
     {
-        $expectedVersions = [];
-        $expectedMinPhp = (float) $this->getMinPhpVersionFromEntryFile();
-        $expectedMaxPhp = (float) $this->getMaxPhpVersionFromEntryFile();
+        $supportedVersions = [];
+        $supportedMinPhp = (float) $this->getMinPhpVersionFromEntryFile();
+        $supportedMaxPhp = (float) $this->getMaxPhpVersionFromEntryFile();
 
-        if ($expectedMinPhp < 7) {
-            $expectedMinPhp = 7;
-            $expectedVersions[] = '5.6';
+        if ($supportedMinPhp < 7) {
+            $supportedMinPhp = 7;
+            $supportedVersions[] = '5.6';
         }
 
-        for ($version = $expectedMinPhp; $version <= $expectedMaxPhp; $version += 0.1) {
-            $expectedVersions[] = sprintf('%.1f', $version);
+        for ($version = $supportedMinPhp; $version <= $supportedMaxPhp; $version += 0.1) {
+            $supportedVersions[] = sprintf('%.1f', $version);
         }
 
-        $jobs = array_filter($this->getTravisJobs(), function ($job) {
-            return false !== strpos($job['stage'], 'Test');
-        });
-        static::assertGreaterThanOrEqual(1, \count($jobs));
+        $ciVersions = $this->getAllPhpVersionsUsedByCiForTests();
 
-        $versions = array_map(function ($job) {
-            return $job['php'];
-        }, $jobs);
+        static::assertGreaterThanOrEqual(1, \count($ciVersions));
+
+        self::assertSupportedPhpVersionsAreCoveredByCiJobs($supportedVersions, $ciVersions);
+        self::assertUpcomingPhpVersionIsCoveredByCiJob(end($supportedVersions), $ciVersions);
+    }
+
+    public function testDeploymentJobsRunOnLatestStablePhpThatIsSupportedByTool()
+    {
+        $ciVersionsForDeployments = $this->getAllPhpVersionsUsedByCiForDeployments();
+        $ciVersions = $this->getAllPhpVersionsUsedByCiForTests();
+        $expectedPhp = $this->getMaxPhpVersionFromEntryFile();
+
+        if (\in_array($expectedPhp.'snapshot', $ciVersions, true)) {
+            // last version of used PHP is snapshot. we should test against previous one, that is stable
+            $expectedPhp = (string) ((float) $expectedPhp - 0.1);
+        }
+
+        static::assertGreaterThanOrEqual(1, \count($ciVersionsForDeployments));
+        static::assertGreaterThanOrEqual(1, \count($ciVersions));
 
-        foreach ($expectedVersions as $expectedVersion) {
-            static::assertContains($expectedVersion, $versions);
+        foreach ($ciVersionsForDeployments as $ciVersionsForDeployment) {
+            static::assertTrue(
+                version_compare($expectedPhp, $ciVersionsForDeployment, 'eq'),
+                sprintf('Expects %s to be %s', $ciVersionsForDeployment, $expectedPhp)
+            );
         }
+    }
 
+    private static function assertUpcomingPhpVersionIsCoveredByCiJob($lastSupportedVersion, array $ciVersions)
+    {
         if (!class_exists(TraversableContains::class)) {
             static::markTestSkipped('TraversableContains not available.');
         }
 
-        static::assertThat($versions, static::logicalOr(
+        static::assertThat($ciVersions, static::logicalOr(
+            // if `$lastsupportedVersion` is already a snapshot version
+            new TraversableContains(sprintf('%.1fsnapshot', $lastSupportedVersion)),
+            // if `$lastsupportedVersion` is not snapshot version, expect CI to run snapshot of next PHP version
             new TraversableContains('nightly'),
-            new TraversableContains(sprintf('%.1fsnapshot', end($expectedVersions) + 0.1))
+            new TraversableContains(sprintf('%.1fsnapshot', $lastSupportedVersion + 0.1))
+        ));
+    }
+
+    private static function assertSupportedPhpVersionsAreCoveredByCiJobs(array $supportedVersions, array $ciVersions)
+    {
+        $lastSupportedVersion = array_pop($supportedVersions);
+
+        foreach ($supportedVersions as $expectedVersion) {
+            static::assertContains($expectedVersion, $ciVersions);
+        }
+
+        if (!class_exists(TraversableContains::class)) {
+            static::markTestSkipped('TraversableContains not available.');
+        }
+
+        static::assertThat($ciVersions, static::logicalOr(
+            new TraversableContains($lastSupportedVersion),
+            new TraversableContains(sprintf('%.1fsnapshot', $lastSupportedVersion))
         ));
     }
 
-    public function testDeploymentJobsRunOnLatestPhp()
+    private function getAllPhpVersionsUsedByCiForDeployments()
     {
         $jobs = array_filter($this->getTravisJobs(), function ($job) {
             return 'Deployment' === $job['stage'];
         });
-        static::assertGreaterThanOrEqual(1, \count($jobs));
 
-        $expectedPhp = $this->getMaxPhpVersionFromEntryFile();
+        $versions = array_map(function ($job) {
+            return (string) $job['php'];
+        }, $jobs);
 
-        foreach ($jobs as $job) {
-            $jobPhp = (string) $job['php'];
-            static::assertTrue(
-                version_compare($expectedPhp, $jobPhp, 'eq'),
-                sprintf('Expects %s to be %s', $jobPhp, $expectedPhp)
-            );
-        }
+        return $versions;
+    }
+
+    private function getAllPhpVersionsUsedByCiForTests()
+    {
+        $jobs = array_filter($this->getTravisJobs(), function ($job) {
+            return false !== strpos($job['stage'], 'Test');
+        });
+
+        $versions = array_map(function ($job) {
+            return (string) $job['php'];
+        }, $jobs);
+
+        return $versions;
     }
 
     private function convertPhpVerIdToNiceVer($verId)

tests/Fixtures/Integration/misc/PHP7.test → tests/Fixtures/Integration/misc/PHP7_0.test

@@ -1,5 +1,5 @@
 --TEST--
-PHP 7 test.
+PHP 7.0 test.
 --RULESET--
 {
     "@Symfony": true,

tests/Smoke/CiIntegrationTest.php

@@ -139,7 +139,7 @@ final class CiIntegrationTest extends AbstractSmokeTest
             $steps[4],
         ]);
 
-        $optionalIncompatibilityWarning = 'PHP needs to be a minimum version of PHP 5.6.0 and maximum version of PHP 7.3.*.
+        $optionalIncompatibilityWarning = 'PHP needs to be a minimum version of PHP 5.6.0 and maximum version of PHP 7.4.*.
 Ignoring environment requirements because `PHP_CS_FIXER_IGNORE_ENV` is set. Execution may be unstable.
 ';