test/classes/VersionInformationTest.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Tests for methods in PhpMyAdmin\VersionInformation class
   5  *
   6  * @package PhpMyAdmin-test
   7  */
   8 declare(strict_types=1);
   9
  10 namespace PhpMyAdmin\Tests;
  11
  12 use PhpMyAdmin\Tests\PmaTestCase;
  13 use PhpMyAdmin\VersionInformation;
  14 use stdClass;
  15
  16 /**
  17  * Tests for methods in PhpMyAdmin\VersionInformation class
  18  *
  19  * @package PhpMyAdmin-test
  20  */
  21 class VersionInformationTest extends PmaTestCase
  22 {
  23     private $_releases;
  24
  25     /**
  26      * Sets up the fixture, for example, opens a network connection.
  27      * This method is called before a test is executed.
  28      *
  29      * @return void
  30      */
  31     protected function setUp(): void
  32     {
  33         $this->_releases = [];
  34
  35         $release = new stdClass();
  36         $release->date = "2015-09-08";
  37         $release->php_versions = ">=5.3,<7.1";
  38         $release->version = "4.4.14.1";
  39         $release->mysql_versions = ">=5.5";
  40         $this->_releases[] = $release;
  41
  42         $release = new stdClass();
  43         $release->date = "2015-09-09";
  44         $release->php_versions = ">=5.3,<7.0";
  45         $release->version = "4.4.13.3";
  46         $release->mysql_versions = ">=5.5";
  47         $this->_releases[] = $release;
  48
  49         $release = new stdClass();
  50         $release->date = "2015-05-13";
  51         $release->php_versions = ">=5.2,<5.3";
  52         $release->version = "4.0.10.10";
  53         $release->mysql_versions = ">=5.0";
  54         $this->_releases[] = $release;
  55     }
  56
  57     /**
  58      * Test version checking
  59      *
  60      * @return void
  61      *
  62      * @group large
  63      * @group network
  64      */
  65     public function testGetLatestVersion()
  66     {
  67         $GLOBALS['cfg']['ProxyUrl'] = PROXY_URL;
  68         $GLOBALS['cfg']['ProxyUser'] = PROXY_USER;
  69         $GLOBALS['cfg']['ProxyPass'] = PROXY_PASS;
  70         $GLOBALS['cfg']['VersionCheck'] = true;
  71         $versionInformation = new VersionInformation();
  72         $version = $versionInformation->getLatestVersion();
  73         $this->assertNotEmpty($version->version);
  74         $this->assertNotEmpty($version->date);
  75     }
  76
  77     /**
  78      * Test version to int conversion.
  79      *
  80      * @param string $version Version string
  81      * @param int    $numeric Integer matching version
  82      *
  83      * @return void
  84      *
  85      * @dataProvider dataVersions
  86      */
  87     public function testVersionToInt($version, $numeric): void
  88     {
  89         $versionInformation = new VersionInformation();
  90         $this->assertEquals(
  91             $numeric,
  92             $versionInformation->versionToInt($version)
  93         );
  94     }
  95
  96
  97     /**
  98      * Data provider for version parsing
  99      *
 100      * @return array with test data
 101      */
 102     public function dataVersions()
 103     {
 104         return [
 105             [
 106                 '1.0.0',
 107                 1000050,
 108             ],
 109             [
 110                 '2.0.0.2-dev',
 111                 2000002,
 112             ],
 113             [
 114                 '3.4.2.1',
 115                 3040251,
 116             ],
 117             [
 118                 '3.4.2-dev3',
 119                 3040203,
 120             ],
 121             [
 122                 '3.4.2-dev',
 123                 3040200,
 124             ],
 125             [
 126                 '3.4.2-pl',
 127                 3040260,
 128             ],
 129             [
 130                 '3.4.2-pl3',
 131                 3040263,
 132             ],
 133             [
 134                 '4.4.2-rc22',
 135                 4040252,
 136             ],
 137             [
 138                 '4.4.2-rc',
 139                 4040230,
 140             ],
 141             [
 142                 '4.4.22-beta22',
 143                 4042242,
 144             ],
 145             [
 146                 '4.4.22-beta',
 147                 4042220,
 148             ],
 149             [
 150                 '4.4.21-alpha22',
 151                 4042132,
 152             ],
 153             [
 154                 '4.4.20-alpha',
 155                 4042010,
 156             ],
 157             [
 158                 '4.40.20-alpha-dev',
 159                 4402010,
 160             ],
 161             [
 162                 '4.4a',
 163                 4000050,
 164             ],
 165             [
 166                 '4.4.4-test',
 167                 4040400,
 168             ],
 169             [
 170                 '4.1.0',
 171                 4010050,
 172             ],
 173             [
 174                 '4.0.1.3',
 175                 4000153,
 176             ],
 177             [
 178                 '4.1-dev',
 179                 4010000,
 180             ],
 181         ];
 182     }
 183
 184     /**
 185      * Tests getLatestCompatibleVersion() when there is only one server confgiured
 186      *
 187      * @return void
 188      */
 189     public function testGetLatestCompatibleVersionWithSingleServer()
 190     {
 191         $GLOBALS['cfg']['Servers'] = [
 192             [],
 193         ];
 194
 195         $mockVersionInfo = $this->getMockBuilder('PhpMyAdmin\VersionInformation')
 196             ->setMethods(['evaluateVersionCondition'])
 197             ->getMock();
 198
 199         $mockVersionInfo->expects($this->at(0))
 200             ->method('evaluateVersionCondition')
 201             ->with('PHP', '>=5.3')
 202             ->will($this->returnValue(true));
 203
 204         $mockVersionInfo->expects($this->at(1))
 205             ->method('evaluateVersionCondition')
 206             ->with('PHP', '<7.1')
 207             ->will($this->returnValue(true));
 208
 209         $mockVersionInfo->expects($this->at(2))
 210             ->method('evaluateVersionCondition')
 211             ->with('MySQL', '>=5.5')
 212             ->will($this->returnValue(true));
 213
 214         $compatible = $mockVersionInfo
 215             ->getLatestCompatibleVersion($this->_releases);
 216         $this->assertEquals('4.4.14.1', $compatible['version']);
 217     }
 218
 219     /**
 220      * Tests getLatestCompatibleVersion() when there are multiple servers configured
 221      *
 222      * @return void
 223      */
 224     public function testGetLatestCompatibleVersionWithMultipleServers()
 225     {
 226         $GLOBALS['cfg']['Servers'] = [
 227             [],
 228             [],
 229         ];
 230
 231         $mockVersionInfo = $this->getMockBuilder('PhpMyAdmin\VersionInformation')
 232             ->setMethods(['evaluateVersionCondition'])
 233             ->getMock();
 234
 235         $mockVersionInfo->expects($this->at(0))
 236             ->method('evaluateVersionCondition')
 237             ->with('PHP', '>=5.3')
 238             ->will($this->returnValue(true));
 239
 240         $mockVersionInfo->expects($this->at(1))
 241             ->method('evaluateVersionCondition')
 242             ->with('PHP', '<7.1')
 243             ->will($this->returnValue(true));
 244
 245         $compatible = $mockVersionInfo
 246             ->getLatestCompatibleVersion($this->_releases);
 247         $this->assertEquals('4.4.14.1', $compatible['version']);
 248     }
 249
 250     /**
 251      * Tests getLatestCompatibleVersion() with an old PHP version
 252      *
 253      * @return void
 254      */
 255     public function testGetLatestCompatibleVersionWithOldPHPVersion()
 256     {
 257         $GLOBALS['cfg']['Servers'] = [
 258             [],
 259             [],
 260         ];
 261
 262         $mockVersionInfo = $this->getMockBuilder('PhpMyAdmin\VersionInformation')
 263             ->setMethods(['evaluateVersionCondition'])
 264             ->getMock();
 265
 266         $mockVersionInfo->expects($this->at(0))
 267             ->method('evaluateVersionCondition')
 268             ->with('PHP', '>=5.3')
 269             ->will($this->returnValue(false));
 270
 271         $mockVersionInfo->expects($this->at(1))
 272             ->method('evaluateVersionCondition')
 273             ->with('PHP', '>=5.3')
 274             ->will($this->returnValue(false));
 275
 276         $mockVersionInfo->expects($this->at(2))
 277             ->method('evaluateVersionCondition')
 278             ->with('PHP', '>=5.2')
 279             ->will($this->returnValue(true));
 280
 281         $mockVersionInfo->expects($this->at(3))
 282             ->method('evaluateVersionCondition')
 283             ->with('PHP', '<5.3')
 284             ->will($this->returnValue(true));
 285
 286         $compatible = $mockVersionInfo
 287             ->getLatestCompatibleVersion($this->_releases);
 288         $this->assertEquals('4.0.10.10', $compatible['version']);
 289     }
 290
 291
 292     /**
 293      * Tests getLatestCompatibleVersion() with an new PHP version
 294      *
 295      * @dataProvider dataProviderVersionConditions
 296      * @param array[]     $versions           The versions to use
 297      * @param array[]     $conditions         The conditions that will be executed
 298      * @param string|null $matchedLastVersion The version that will be matched
 299      * @return void
 300      */
 301     public function testGetLatestCompatibleVersionWithNewPHPVersion(array $versions, array $conditions, ?string $matchedLastVersion): void
 302     {
 303         $GLOBALS['cfg']['Servers'] = [];
 304
 305         $mockVersionInfo = $this->getMockBuilder(VersionInformation::class)
 306             ->setMethods(['evaluateVersionCondition'])
 307             ->getMock();
 308
 309         $i = 0;
 310         foreach ($conditions as $conditionArray) {
 311             [
 312                 $condition,
 313                 $returnValue,
 314             ] = $conditionArray;
 315             $mockVersionInfo->expects($this->at($i))
 316                 ->method('evaluateVersionCondition')
 317                 ->with('PHP', $condition)
 318                 ->will($this->returnValue($returnValue));
 319             $i++;
 320         }
 321         /** @var VersionInformation $mockVersionInfo */
 322         $compatible = $mockVersionInfo->getLatestCompatibleVersion($versions);
 323         $this->assertEquals($matchedLastVersion, $compatible['version'] ?? null);
 324     }
 325
 326     /**
 327      * Provider for testGetLatestCompatibleVersionWithNewPHPVersion
 328      * Returns the conditions to be used for mocks
 329      * @return array[]
 330      */
 331     public function dataProviderVersionConditions(): array
 332     {
 333         return [
 334             [
 335                 [
 336                     ((object) [
 337                         'date' => '2019-12-26',
 338                         'php_versions' => '>=5.5,<8.0',
 339                         'version' => '4.9.3',
 340                         'mysql_versions' => '>=5.5',
 341                     ]),
 342                     ((object) [
 343                         'date' => '2019-12-26',
 344                         'php_versions' => '>=7.1,<8.0',
 345                         'version' => '5.0.0',
 346                         'mysql_versions' => '>=5.5',
 347                     ]),
 348                 ],
 349                 [
 350                     [
 351                         '>=5.5',
 352                         true,
 353                     ],
 354                     [
 355                         '<8.0',
 356                         true,
 357                     ],
 358                     [
 359                         '>=7.1',
 360                         true,
 361                     ],
 362                     [
 363                         '<8.0',
 364                         false,
 365                     ],
 366                 ],
 367                 '4.9.3',
 368             ],
 369             [
 370                 [
 371                     ((object) [
 372                         'date' => '2019-12-26',
 373                         'php_versions' => '>=5.5,<7.0',
 374                         'version' => '6.0.0',
 375                         'mysql_versions' => '>=5.5',
 376                     ]),
 377                     ((object) [
 378                         'date' => '2019-12-26',
 379                         'php_versions' => '>=7.1,<8.0',
 380                         'version' => '5.0.0',
 381                         'mysql_versions' => '>=5.5',
 382                     ]),
 383                 ],
 384                 [
 385                     [
 386                         '>=5.5',
 387                         true,
 388                     ],
 389                     [
 390                         '<7.0',
 391                         true,
 392                     ],
 393                     [
 394                         '>=7.1',
 395                         false,
 396                     ],
 397                 ],
 398                 '6.0.0',
 399             ],
 400             [
 401                 [
 402                     ((object) [
 403                         'date' => '2019-12-26',
 404                         'php_versions' => '>=5.5,<7.0',
 405                         'version' => '6.0.0-rc1',
 406                         'mysql_versions' => '>=5.5',
 407                     ]),
 408                     ((object) [
 409                         'date' => '2019-12-26',
 410                         'php_versions' => '>=7.1,<8.0',
 411                         'version' => '6.0.0-rc2',
 412                         'mysql_versions' => '>=5.5',
 413                     ]),
 414                 ],
 415                 [
 416                     [
 417                         '>=5.5',
 418                         true,
 419                     ],
 420                     [
 421                         '<7.0',
 422                         true,
 423                     ],
 424                     [
 425                         '>=7.1',
 426                         false,
 427                     ],
 428                 ],
 429                 '6.0.0-rc1',
 430             ],
 431             [
 432                 [
 433                     ((object) [
 434                         'date' => '2019-12-26',
 435                         'php_versions' => '>=5.5,<7.0',
 436                         'version' => '6.0.0',
 437                         'mysql_versions' => '>=5.5',
 438                     ]),
 439                     ((object) [
 440                         'date' => '2019-12-26',
 441                         'php_versions' => '>=7.1,<8.0',
 442                         'version' => '5.0.0',
 443                         'mysql_versions' => '>=5.5',
 444                     ]),
 445                 ],
 446                 [
 447                     [
 448                         '>=5.5',
 449                         false,
 450                     ],
 451                     [
 452                         '>=7.1',
 453                         true,
 454                     ],
 455                     [
 456                         '<8.0',
 457                         false,
 458                     ],
 459                 ],
 460                 null,
 461             ],
 462             [
 463                 [
 464                     ((object) [
 465                         'date' => '2019-12-26',
 466                         'php_versions' => '>=5.5,<7.0',
 467                         'version' => '6.0.0',
 468                         'mysql_versions' => '>=5.5',
 469                     ]),
 470                     ((object) [
 471                         'date' => '2019-12-26',
 472                         'php_versions' => '>=7.1,<8.0',
 473                         'version' => '5.0.0',
 474                         'mysql_versions' => '>=5.5',
 475                     ]),
 476                 ],
 477                 [
 478                     [
 479                         '>=5.5',
 480                         false,
 481                     ],
 482                     [
 483                         '>=7.1',
 484                         true,
 485                     ],
 486                     [
 487                         '<8.0',
 488                         true,
 489                     ],
 490                 ],
 491                 '5.0.0',
 492             ],
 493             [
 494                 [
 495                     ((object) [
 496                         'date' => '2019-12-26',
 497                         'php_versions' => '>=5.5,<8.0',
 498                         'version' => '4.9.3',
 499                         'mysql_versions' => '>=5.5',
 500                     ]),
 501                     ((object) [
 502                         'date' => '2019-12-26',
 503                         'php_versions' => '>=7.1,<8.0',
 504                         'version' => '5.0.0',
 505                         'mysql_versions' => '>=5.5',
 506                     ]),
 507                 ],
 508                 [
 509                     [
 510                         '>=5.5',
 511                         true,
 512                     ],
 513                     [
 514                         '<8.0',
 515                         true,
 516                     ],
 517                     [
 518                         '>=7.1',
 519                         true,
 520                     ],
 521                     [
 522                         '<8.0',
 523                         true,
 524                     ],
 525                 ],
 526                 '5.0.0',
 527             ],
 528             [
 529                 [
 530                     ((object) [
 531                         'date' => '2019-12-26',
 532                         'php_versions' => '>=7.1,<8.0',
 533                         'version' => '5.0.0',
 534                         'mysql_versions' => '>=5.5',
 535                     ]),
 536                     ((object) [
 537                         'date' => '2019-12-26',
 538                         'php_versions' => '>=5.5,<8.0',
 539                         'version' => '4.9.3',
 540                         'mysql_versions' => '>=5.5',
 541                     ]),
 542                 ],
 543                 [
 544                     [
 545                         '>=7.1',
 546                         true,
 547                     ],
 548                     [
 549                         '<8.0',
 550                         true,
 551                     ],
 552                     [
 553                         '>=5.5',
 554                         true,
 555                     ],
 556                     [
 557                         '<8.0',
 558                         true,
 559                     ],
 560                 ],
 561                 '5.0.0',
 562             ],
 563         ];
 564     }
 565
 566     /**
 567      * Tests evaluateVersionCondition() method
 568      *
 569      * @return void
 570      */
 571     public function testEvaluateVersionCondition()
 572     {
 573         $mockVersionInfo = $this->getMockBuilder('PhpMyAdmin\VersionInformation')
 574             ->setMethods(['getPHPVersion'])
 575             ->getMock();
 576
 577         $mockVersionInfo->expects($this->any())
 578             ->method('getPHPVersion')
 579             ->will($this->returnValue('5.2.4'));
 580
 581         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.3'));
 582         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '<5.3'));
 583         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>=5.2'));
 584         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '>5.2'));
 585         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.3'));
 586
 587         $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<=5.2'));
 588         $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '<5.2'));
 589         $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>=7.0'));
 590         $this->assertFalse($mockVersionInfo->evaluateVersionCondition('PHP', '>7.0'));
 591         $this->assertTrue($mockVersionInfo->evaluateVersionCondition('PHP', '!=5.2'));
 592     }
 593 }