SemVer\SemVer\Tests\VersionTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	286
Duplicated Lines	9.79 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
B	testConstructor()	0	35	1
A	testConstructorFailsIfPreReleaseNotValid()	0	4	1
A	testConstructorFailsIfBuildNotValid()	0	4	1
A	provideWrongPreReleaseVersion()	0	14	1
B	testFromString()	0	35	1
A	provideValidVersion()	0	13	1
A	testFromStringFailsWithInvalidString()	0	4	1
A	provideWrongStringVersion()	0	10	1
B	testSort()	0	38	3
A	testToString()	0	13	2
A	testGreaterThan()	7	7	1
A	testGreaterThanOrEqual()	7	7	1
A	testLessThan()	7	7	1
A	testLessThanOrEqual()	7	7	1

<?php

/*
 * This file is part of semver/semver.
 *
 * (c) SemVer <https://github.com/git-pull-request>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace SemVer\SemVer\Tests;

use PHPUnit_Framework_TestCase;
use SemVer\SemVer\Version;

final class VersionTest extends PHPUnit_Framework_TestCase
{
    ////////////////////////////////////////////////////////////////////////////
    // __construct()
    ////////////////////////////////////////////////////////////////////////////

    /**
     * @dataProvider provideValidVersion
     *
     * @param string $unused
     * @param int    $major
     * @param int    $minor
     * @param int    $patch
     * @param string $preRelease
     * @param string $build
     */
    public function testConstructor(
        string $unused,

The parameter $unused is not used and could be removed.

        int $major,
        int $minor,
        int $patch,
        string $preRelease,
        string $build
    ) {
        $version = new Version($major, $minor, $patch, $preRelease, $build);
        static::assertEquals(
            $major,
            $version->getMajor(),
            '__construct() takes the major version as its first argument'
        );
        static::assertEquals(
            $minor,
            $version->getMinor(),
            '__construct() takes the minor version as its second argument'
        );
        static::assertEquals(
            $patch,
            $version->getPatch(),
            '__construct() takes the patch version as its third argument'
        );
        static::assertEquals(
            $preRelease,
            $version->getPreRelease(),
            '__construct() takes the pre-release version as its forth argument'
        );
        static::assertEquals(
            $build,
            $version->getBuild(),
            '__construct() takes the build version as its fifth argument'
        );
    }

    /**
     * @dataProvider             provideWrongPreReleaseVersion
     * @expectedException \SemVer\SemVer\Exception\InvalidArgumentException
     * @expectedExceptionMessage The pre-release version is not compatible with rule 9 of the specifications.
     *
     * @param string $preRelease
     */
    public function testConstructorFailsIfPreReleaseNotValid(string $preRelease)
    {
        new Version(10, 12, 14, $preRelease);
    }

    /**
     * @dataProvider             provideWrongPreReleaseVersion
     * @expectedException \SemVer\SemVer\Exception\InvalidArgumentException
     * @expectedExceptionMessage The build version is not compatible with rule 10 of the specifications.
     *
     * @param string $build
     */
    public function testConstructorFailsIfBuildNotValid(string $build)
    {
        new Version(10, 12, 14, '', $build);
    }

    /** @return array */
    public function provideWrongPreReleaseVersion() : array
    {
        return [
            ['é'],
            ['"'],
            ['~'],
            ['+'],
            ['+R'],
            ['R+'],
            ['.RC'],
            ['.'],
            ['RC.'],
        ];
    }

    ////////////////////////////////////////////////////////////////////////////
    // fromString()
    ////////////////////////////////////////////////////////////////////////////

    /**
     * @dataProvider             provideValidVersion
     *
     * @param string $string
     * @param int    $expectedMajor
     * @param int    $expectedMinor
     * @param int    $expectedPatch
     * @param string $expectedPreRelease
     * @param string $exceptedBuild
     */
    public function testFromString(
        string $string,
        int $expectedMajor,
        int $expectedMinor,
        int $expectedPatch,
        string $expectedPreRelease,
        string $exceptedBuild
    ) {
        $version = Version::fromString($string);
        static::assertEquals(
            $expectedMajor,
            $version->getMajor(),
            '__construct() takes the major version as its first argument'
        );
        static::assertEquals(
            $expectedMinor,
            $version->getMinor(),
            '__construct() takes the minor version as its second argument'
        );
        static::assertEquals(
            $expectedPatch,
            $version->getPatch(),
            '__construct() takes the patch version as its third argument'
        );
        static::assertEquals(
            $expectedPreRelease,
            $version->getPreRelease(),
            '__construct() takes the pre-release version as its forth argument'
        );
        static::assertEquals(
            $exceptedBuild,
            $version->getBuild(),
            '__construct() takes the build version as its fifth argument'
        );
    }

    /** @return array */
    public function provideValidVersion() : array
    {
        return [
            ['1.2.3', 1, 2, 3, '', ''],
            ['1.0.0-alpha', 1, 0, 0, 'alpha', ''],
            ['1.0.0-alpha.1', 1, 0, 0, 'alpha.1', ''],
            ['1.0.0-0.3.7', 1, 0, 0, '0.3.7', ''],
            ['1.0.0-x.7.z.92', 1, 0, 0, 'x.7.z.92', ''],
            ['1.0.0-alpha+001', 1, 0, 0, 'alpha', '001'],
            ['1.0.0+20130313144700', 1, 0, 0, '', '20130313144700'],
            ['1.0.0-beta+exp.sha.5114f85', 1, 0, 0, 'beta', 'exp.sha.5114f85'],
        ];
    }

    /**
     * @dataProvider                   provideWrongStringVersion
     * @expectedException \SemVer\SemVer\Exception\InvalidArgumentException
     * @expectedExceptionMessageRegExp /The string ".+" does not look like a version\./
     *
     * @param string $string
     */
    public function testFromStringFailsWithInvalidString(string $string)
    {
        Version::fromString($string);
    }

    /**
     * @return array
     */
    public function provideWrongStringVersion() : array
    {
        return [
            ['1'],
            ['a'],
            ['1.1'],
            ['1.a'],
            ['1.1.a'],
        ];
    }

    ////////////////////////////////////////////////////////////////////////////
    // sort()
    ////////////////////////////////////////////////////////////////////////////
    public function testSort()
    {
        $result = Version::sort(
            [
                Version::fromString('2.0.0'),
                Version::fromString('1.10.10'),
            ]
        );
        $expectedResult =
            [
                Version::fromString('1.10.10'),
                Version::fromString('2.0.0'),
            ];
        do {
            $shiftResult   = array_shift($result);
            $shiftExpected = array_shift($expectedResult);
            static::assertEquals(
                $shiftExpected->getMajor(),
                $shiftResult->getMajor(),
                '::sort() versions must be ordered by major version'
            );
            static::assertEquals(
                $shiftExpected->getMinor(),
                $shiftResult->getMinor(),
                '::sort() versions must be ordered by major version'
            );
            static::assertEquals(
                $shiftExpected->getPatch(),
                $shiftResult->getPatch(),
                '::sort() versions must be ordered by major version'
            );
            static::assertEquals(
                $shiftExpected->getPreRelease(),
                $shiftResult->getPreRelease(),
                '::sort() versions must be ordered by major version'
            );
        } while (count($result) || count($expectedResult));
    }

    ////////////////////////////////////////////////////////////////////////////
    // __toString()
    ////////////////////////////////////////////////////////////////////////////
    public function testToString()
    {
        $data = [
            '1.0.0',
            '1.0.0-alpha.test',
            '1.0.0-alpha.test+build',
            '1.0.0+build',
        ];

        foreach ($data as $item) {
            static::assertEquals($item, (string) Version::fromString($item));
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    // greaterThan()
    ////////////////////////////////////////////////////////////////////////////
    public function testGreaterThan()

This method seems to be duplicated in your project.

    {
        $current = new Version(1, 0, 0);
        $other   = new Version(1, 1, 0);
        static::assertEquals(false, $current->greaterThan($other));
        static::assertEquals(true, $other->greaterThan($current));
    }

    ////////////////////////////////////////////////////////////////////////////
    // greaterThanOrEqual()
    ////////////////////////////////////////////////////////////////////////////
    public function testGreaterThanOrEqual()

This method seems to be duplicated in your project.

    {
        $current = new Version(1, 0, 0);
        $other   = new Version(1, 1, 0);
        static::assertEquals(false, $current->greaterThanOrEqual($other));
        static::assertEquals(true, $other->greaterThanOrEqual($current));
    }

    ////////////////////////////////////////////////////////////////////////////
    // lessThan()
    ////////////////////////////////////////////////////////////////////////////
    public function testLessThan()

This method seems to be duplicated in your project.

    {
        $current = new Version(1, 0, 0);
        $other   = new Version(1, 1, 0);
        static::assertEquals(true, $current->lessThan($other));
        static::assertEquals(false, $other->lessThan($current));
    }

    ////////////////////////////////////////////////////////////////////////////
    // lessThanOrEqual()
    ////////////////////////////////////////////////////////////////////////////
    public function testLessThanOrEqual()

This method seems to be duplicated in your project.

    {
        $current = new Version(1, 0, 0);
        $other   = new Version(1, 1, 0);
        static::assertEquals(true, $current->lessThanOrEqual($other));
        static::assertEquals(false, $other->lessThanOrEqual($current));
    }
}