Chekote\NounStore\Key\ProcessMatchesTest

Complexity

Total Complexity

4

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testExceptionBubblesUpFromResolveIndex()	0	12	1
A	successDataProvider()	0	12	1
A	testSuccess()	0	9	1

<?php namespace Chekote\NounStore\Key;

use Chekote\Phake\Phake;
use InvalidArgumentException;

/**
 * @covers \Chekote\NounStore\Key::processMatches()
 */
class ProcessMatchesTest extends KeyTest
{
    const MATCHES_NO_NTH = ['thing', '', '', 'thing'];
    const MATCHES_NO_NTH_PROPERTY = ["thing's address", '', '', 'thing', "'s address", 'address'];
    const MATCHES_NTH = ['15th thing', '15th ', '15', 'thing'];
    const MATCHES_NTH_AND_PROPERTY = ["15th thing's address", '15th ', '15', 'thing', "'s address", 'address'];

    public function setUp()
    {
        parent::setUp();

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::when($this->key)->processMatches(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 successDataProvider()
    {
        return [
        //  index, matches,                        resolvedIndex, expectedNth, expectedKey, expectedProperty
            [null, self::MATCHES_NO_NTH,                    null,        null, 'thing',     null     ],
            [   1, self::MATCHES_NO_NTH,                       1,        null, 'thing',     null     ],
            [null, self::MATCHES_NO_NTH_PROPERTY,           null,        null, 'thing',     'address'],
            [   1, self::MATCHES_NO_NTH_PROPERTY,              1,        null, 'thing',     'address'],
            [null, self::MATCHES_NTH,                         14,          15, 'thing',     null     ],
            [  14, self::MATCHES_NTH,                         14,          15, 'thing',     null     ],
            [null, self::MATCHES_NTH_AND_PROPERTY,            14,          15, 'thing',     'address'],
            [  14, self::MATCHES_NTH_AND_PROPERTY,            14,          15, 'thing',     'address'],
        ];
    }

    /**
     * @dataProvider successDataProvider()
     * @param int|null    $index            the index to pass to the method.
     * @param array       $matches          the regex matches to pass to the method.
     * @param int|null    $resolvedIndex    the index that mocked resolveIndex() should return.
     * @param string      $expectedKey      the expected key to be returned from the method.
     * @param int|null    $expectedNth      the nth expected to be pulled from the $matches array.
     * @param string|null $expectedProperty the expected property to be returned from the method.
     */
    public function testSuccess($index, array $matches, $resolvedIndex, $expectedNth, $expectedKey, $expectedProperty)
    {
        /* @noinspection PhpUndefinedMethodInspection */
        Phake::expect($this->key, 1)->resolveIndex($index, $expectedNth)->thenReturn($resolvedIndex);

The method resolveIndex() does not exist on Chekote\Phake\Expectation. 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::expect() does only seem to accept Phake_IMock, maybe add an additional type check?

        /* @noinspection PhpUndefinedMethodInspection */
        $this->assertEquals(
            [$expectedKey, $resolvedIndex, $expectedProperty],
            Phake::makeVisible($this->key)->processMatches($index, $matches)

The method processMatches() 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?

        );
    }

    public function testExceptionBubblesUpFromResolveIndex()
    {
        $exception = new InvalidArgumentException('nth must be equal to or larger than 1');

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::expect($this->key, 1)->resolveIndex(Phake::anyParameters())->thenThrow($exception);

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

        $this->expectException(get_class($exception));
        $this->expectExceptionMessage($exception->getMessage());

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::makeVisible($this->key)->processMatches(null, ['0th thing', '0th ', '0', 'thing']);

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?

    }
}