Unit\Chekote\NounStore\Store\GetTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	60
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testKeyIsParsedAndParsedValuesAreUsed()	0	10	1
A	setUp()	0	6	1
A	happyPathProvider()	0	12	1
A	testInvalidArgumentExceptionBubblesUpFromParse()	0	11	1
A	testHappyPath()	0	5	1

<?php namespace Unit\Chekote\NounStore\Store;

use Unit\Chekote\NounStore\Key\KeyTest;
use Unit\Chekote\Phake\Phake;
use InvalidArgumentException;

/**
 * @covers \Chekote\NounStore\Store::get()
 */
class GetTest extends StoreTest
{
    public function setUp()
    {
        parent::setUp();

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

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

    }

    public function testKeyIsParsedAndParsedValuesAreUsed()
    {
        $key = '2nd ' . StoreTest::KEY;
        $parsedKey = StoreTest::KEY;
        $parsedIndex = 1;

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::expect($this->key, 1)->parse($key)->thenReturn([[$parsedKey, $parsedIndex]]);

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

The method parse() does not exist on Unit\Chekote\Phake\Expectation. Since you implemented __call, consider adding a @method annotation.

        $this->assertEquals(StoreTest::$SECOND_VALUE, $this->store->get($key));

The method get() does not exist on Phake_IMock.

    }

    public function testInvalidArgumentExceptionBubblesUpFromParse()
    {
        $exception = new InvalidArgumentException('Key syntax is invalid');

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

It seems like $this->key can also be of type Chekote\NounStore\Key; however, parameter $mock of Unit\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());

        $this->store->get(KeyTest::INVALID_KEY);
    }

    /**
     * @dataProvider happyPathProvider
     * @param string  $key       the key to fetch.
     * @param array[] $parsedKey the parsed key.
     * @param mixed   $expected  the expected value.
     */
    public function testHappyPath($key, $parsedKey, $expected) {
        /* @noinspection PhpUndefinedMethodInspection */
        Phake::expect($this->key, 1)->parse($key)->thenReturn($parsedKey);

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

        $this->assertEquals($expected, $this->store->get($key));
    }

    public function happyPathProvider() {
        return [
            //                                                     key                                        parsed key                                  expected
            'Noun without index returns most recent noun'      => [StoreTest::KEY,                            [[StoreTest::KEY, null]],                   StoreTest::$MOST_RECENT_VALUE],
            'Noun with index returns specific noun'            => ['1st ' . StoreTest::KEY,                   [[StoreTest::KEY,    0]],                   StoreTest::$FIRST_VALUE],
            'Non-existent noun returns null'                   => ['3rd ' . StoreTest::KEY,                   [[StoreTest::KEY,    2]],                   null],
            'Possessive noun w/o index string property'        => [StoreTest::KEY . "'s color",               [[StoreTest::KEY, null], ['color', null]],  'Blue'],
            'Possessive noun with index string property'       => ['1st ' . StoreTest::KEY . "'s color",      [[StoreTest::KEY, 0], ['color', null]],     'Red'],
            'Possessive noun w/o index collection w/o index'   => [StoreTest::KEY . "'s option",              [[StoreTest::KEY, null], ['option', null]], 'Air Conditioning'],
            'Possessive noun with index collection w/o index'  => ['1st ' . StoreTest::KEY . "'s option",     [[StoreTest::KEY, 0], ['option', null]],    'Heated Seats'],
            'Possessive noun w/o index collection with index'  => [StoreTest::KEY . "'s 1st option",          [[StoreTest::KEY, null], ['option', 0]],    'Cruise Control'],
            'Possessive noun with index collection with index' => ['1st ' . StoreTest::KEY . "'s 1st option", [[StoreTest::KEY, 0], ['option', 0]],       'GPS'],
        ];
    }
}