Chekote\NounStore\Key\ResolveIndexTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	invalidNthDataProvider()	0	7	1
A	setUp()	0	6	1
A	validIndexAndNthDataProvider()	0	8	1
A	testValidNthIsReturnedDecrementedByOne()	0	6	1
A	testThrowsExceptionIfKeyAndIndexMismatch()	0	7	1
A	mismatchedIndexAndNthDataProvider()	0	10	1
A	testThrowsExceptionIfNthIsLessThanOne()	0	7	1
A	testIndexIsReturnedIfNthIsNull()	0	7	1

<?php namespace Chekote\NounStore\Key;

use Chekote\Phake\Phake;
use InvalidArgumentException;

/**
 * @covers \Chekote\NounStore\Key::resolveIndex()
 */
class ResolveIndexTest extends KeyTest
{
    public function setUp()
    {
        parent::setUp();

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::when($this->key)->resolveIndex(Phake::anyParameters())->thenCallParent();

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Phake::when() does only seem to accept Phake_IMock, maybe add an additional type check?

    }

    public function testIndexIsReturnedIfNthIsNull()
    {
        $index = 10;
        $nth = null;

        /* @noinspection PhpUndefinedMethodInspection */
        $this->assertEquals($index, Phake::makeVisible($this->key)->resolveIndex($index, $nth));

The method resolveIndex() does not exist on Chekote\Phake\Proxies\VisibilityProxy. Since you implemented __call, consider adding a @method annotation.

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Chekote\Phake\Phake::makeVisible() does only seem to accept Phake_IMock, maybe add an additional type check?

    }

    /**
     * @return array
     */
    public function mismatchedIndexAndNthDataProvider()
    {
        return [
        //   index, nth
            [    1,   0],
            [    1,   1],
            [    1,   5],
            [    4,   0],
            [    4,   4],
            [    4,  10],
        ];
    }

    /**
     * @dataProvider mismatchedIndexAndNthDataProvider
     * @param int $index the mismatched index to pass along with the nth
     * @param int $nth   the mismatched nth to pass along with the index
     */
    public function testThrowsExceptionIfKeyAndIndexMismatch($index, $nth)
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("index $index was provided with nth $nth, but they are not equivalent");

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::makeVisible($this->key)->resolveIndex($index, $nth);

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Chekote\Phake\Phake::makeVisible() does only seem to accept Phake_IMock, maybe add an additional type check?

    }

    /**
     * @return array
     */
    public function invalidNthDataProvider()
    {
        return [
            [  0],
            [ -1],
            [ -4],
            [-10],
        ];
    }

    /**
     * @dataProvider invalidNthDataProvider
     * @param int $nth the invalid nth to pass along with the index
     */
    public function testThrowsExceptionIfNthIsLessThanOne($nth)
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('nth must be equal to or larger than 1');

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::makeVisible($this->key)->resolveIndex(null, $nth);

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Chekote\Phake\Phake::makeVisible() does only seem to accept Phake_IMock, maybe add an additional type check?

    }

    /**
     * @return array
     */
    public function validIndexAndNthDataProvider()
    {
        return [
        //   index, nth
            [    0,   1],
            [   10,  11],
            [  100, 101],
            [ null,  50],
        ];
    }

    /**
     * Tests that calling with valid index and key param returns nth decremented by 1.
     *
     * @dataProvider validIndexAndNthDataProvider
     * @param int $index the valid index to pass along with the nth
     * @param int $nth   the valid nth to pass along with the index
     */
    public function testValidNthIsReturnedDecrementedByOne($index, $nth)
    {
        $expected = $nth - 1;

        /* @noinspection PhpUndefinedMethodInspection */
        $this->assertEquals($expected, Phake::makeVisible($this->key)->resolveIndex($index, $nth));

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Chekote\Phake\Phake::makeVisible() does only seem to accept Phake_IMock, maybe add an additional type check?

    }
}