NelsonMartell\Test\TestCase\VersionComponentTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	147
Duplicated Lines	10.2 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getTargetClassName()	0	4	1
A	testParseMethod()	0	16	1
A	testParseMethodWithInvalidArguments()	0	4	1
A	testPerformsConversionToString()	15	15	1
A	testPerformsImplicitConversionToString()	0	7	1
B	testCanCheckIfVersionComponentIsInDefaultOrNullState()	0	62	5

<?php
/**
 * PHP: Nelson Martell Library file
 *
 * Content:
 * - Test case for: [NelsonMartell] Version
 *
 * Copyright © 2016 Nelson Martell (http://nelson6e65.github.io)
 *
 * Licensed under The MIT License (MIT)
 * For full copyright and license information, please see the LICENSE
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright 2016 Nelson Martell
 * @link      http://nelson6e65.github.io/php_nml/
 * @since     v0.6.0
 * @license   http://www.opensource.org/licenses/mit-license.php The MIT License (MIT)
 * */

namespace NelsonMartell\Test\TestCase;

use NelsonMartell as NML;
use NelsonMartell\VersionComponent;
use NelsonMartell\Extensions\String;
use NelsonMartell\Test\DataProviders\VersionComponentTestProvider;
use \PHPUnit_Framework_TestCase as TestCase;
use \InvalidArgumentException;

/**
 *
 * @author Nelson Martell <nelson6e65@gmail.com>
 * @internal
 * */
class VersionComponentTest extends TestCase
{
    use VersionComponentTestProvider;

    public function getTargetClassName()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return VersionComponent::class;
    }

    /**
     * @testdox Performs conversion from compatible objects
     * @coverage VersionComponent::parse
     * @dataProvider goodVersionComponentParseMethodArgumentsProvider
     */
    public function testParseMethod(VersionComponent $expected, $obj)
    {
        $actual = VersionComponent::parse($obj);

        $message = String::format(
            '{class}::{method}({obj}); // {actual}',
            [
                'class'  => VersionComponent::class,
                'method' => 'isValid',
                'obj'    => static::export($obj),
                'actual' => static::export($actual)
            ]
        );

        $this->assertEquals($expected, $actual, $message);
    }

    /**
     * @testdox Informs if error occurs on parsing incompatible objects
     * @coverage VersionComponent::parse
     * @dataProvider badVersionComponentParseMethodArgumentsProvider
     * @expectedException \InvalidArgumentException
     */
    public function testParseMethodWithInvalidArguments($obj)
    {
        $actual = VersionComponent::parse($obj);

$actual is not used, you could remove the assignment.

    }

    /**
     * @coverage VersionComponent::__toString
     * @coverage VersionComponent::toString
     * @dataProvider versionComponentToStringMethodArgumentsProvider
     */
    public function testPerformsConversionToString($expected, VersionComponent $versionComponent)

This method seems to be duplicated in your project.

    {
        $actual = $versionComponent->toString();

        $message = String::format(
            '$versionComponent->{method}(); // {actual}',
            [
                'method' => 'toString',
                'actual' => static::export($actual)
            ]
        );

        $this->assertInternalType('string', $actual, $message.' # Should return a string #');
        $this->assertEquals($expected, $actual, $message);
    }

    /**
     * @coverage VersionComponent::__toString
     * @coverage VersionComponent::toString
     * @depends testPerformsConversionToString
     * @dataProvider versionComponentToStringMethodArgumentsProvider
     */
    public function testPerformsImplicitConversionToString($str, VersionComponent $obj)
    {
        $expected = "<VersionComponent>$str</VersionComponent>";

As per coding-style, please use concatenation or sprintf for the variable $str instead of interpolation.

        $actual   = "<VersionComponent>$obj</VersionComponent>";

As per coding-style, please use concatenation or sprintf for the variable $obj instead of interpolation.

        $this->assertEquals($expected, $actual);
    }

    /**
     * @coverage VersionComponent::isNull
     * @coverage VersionComponent::isNotNull
     * @coverage VersionComponent::isDefault
     * @coverage VersionComponent::isNotDefault
     * @dataProvider nullOrDefaultStatesProvider
     */
    public function testCanCheckIfVersionComponentIsInDefaultOrNullState($expected, VersionComponent $versionComponent)
    {
        static $format = '$versionComponent->{method}(); // {actual}';

        $actuals['isDefault']    = $versionComponent->isDefault();

$actuals was never initialized. Although not strictly required by PHP, it is generally a good practice to add $actuals = array(); before regardless.

        $actuals['isNotDefault'] = $versionComponent->isNotDefault();
        $actuals['isNull']       = $versionComponent->isNull();
        $actuals['isNotNull']    = $versionComponent->isNotNull();

        $messages = [];

        foreach ($actuals as $method => $actual) {
            $messages[$method] = String::format($format, ['method' => $method, 'actual' => static::export($actual)]);
        }

        foreach ($actuals as $method => $actual) {
            // Pre-tests for returning type
            $this->assertInternalType('boolean', $actual, $messages[$method].' # Should return a boolean #');
        }

        // Pre-tests for different values
        $this->assertNotEquals(
            $actuals['isDefault'],
            $actuals['isNotDefault'],
            $messages['isDefault'].PHP_EOL.$messages['isNotDefault']
        );

        $this->assertNotEquals(
            $actuals['isNull'],
            $actuals['isNotNull'],
            $messages['isNull'].PHP_EOL.$messages['isNotNull']
        );


        // Test expected
        if ($expected === 'default') {
            $this->assertTrue($actuals['isDefault'], $messages['isDefault']);

            // Can't be null AND default
            $this->assertNotEquals(
                $actuals['isNull'],
                $actuals['isDefault'],
                '#Can\'t be both, DEFAULT and NULL, at the same time'.PHP_EOL.
                $messages['isDefault'].PHP_EOL.
                $messages['isNull']
            );
        } elseif ($expected === 'null') {
            $this->assertTrue($actuals['isNull'], $messages['isNull']);

            // Can't be null AND default
            $this->assertNotEquals(
                $actuals['isNull'],
                $actuals['isDefault'],
                '#Can\'t be both, NULL and DEFAULT, at the same time'.PHP_EOL.
                $messages['isNull'].PHP_EOL.
                $messages['isDefault']
            );
        } else {
            $this->assertTrue($actuals['isNotDefault'], $messages['isNotDefault']);
            $this->assertTrue($actuals['isNotNull'], $messages['isNotNull']);
        }
    }
}

As per coding style, files should not end with a newline character.