Chekote\NounStore\Store\GetTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	testGetReturnsItemAtEndOfStack()	0	14	1
A	testGetWithIndexParameterReturnsIndexItem()	0	14	1
A	testGetReturnsNullWhenIndexDoesNotExist()	0	14	1
A	testGetWithNthKeyReturnsNthItem()	0	14	1
A	testGetReturnsNullWhenKeyDoesNotExist()	0	14	1
A	setUp()	0	6	1
A	testGetReturnsNullWhenNthKeyDoesNotExist()	0	14	1
A	testGetThrowsInvalidArgumentExceptionWithMismatchedNthAndIndex()	0	11	1

<?php namespace Chekote\NounStore\Store;

use 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?

    }

    /**
     * Tests that InvalidArgumentException is thrown if Store::get is called with the index parameter
     * and the key also contains an nth value, but they do not match.
     */
    public function testGetThrowsInvalidArgumentExceptionWithMismatchedNthAndIndex()
    {
        $key = '1st Thing';
        $index = 1;

        /* @noinspection PhpUndefinedMethodInspection */
        Phake::when($this->key)->parse($key, $index)->thenThrow(new InvalidArgumentException());

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?

        $this->expectException(InvalidArgumentException::class);

        $this->store->get($key, $index);

The method get() does not exist on Phake_IMock.

    }

    /**
     * Tests that Store::get returns the item at the end of the stack.
     */
    public function testGetReturnsItemAtEndOfStack()
    {
        $key = self::KEY;
        $index = null;
        $parsedKey = self::KEY;
        $parsedIndex = null;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(true);

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?

        }

        $this->assertEquals(self::SECOND_VALUE, $this->store->get(self::KEY));
    }

    /**
     * Tests that Store::get returns the nth item at of the stack when the $key contains nth.
     */
    public function testGetWithNthKeyReturnsNthItem()
    {
        $key = '1st ' . self::KEY;
        $index = null;
        $parsedKey = self::KEY;
        $parsedIndex = 0;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(true);

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?

        }

        $this->assertEquals(self::FIRST_VALUE, $this->store->get($key));
    }

    /**
     * Tests that Store::get returns the index item at of the stack when index parameter is provided.
     */
    public function testGetWithIndexParameterReturnsIndexItem()
    {
        $key = self::KEY;
        $index = 0;
        $parsedKey = self::KEY;
        $parsedIndex = 0;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(true);

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?

        }

        $this->assertEquals(self::FIRST_VALUE, $this->store->get(self::KEY, $index));
    }

    /**
     * Tests that Store::get returns null when the specified $key does not exist.
     */
    public function testGetReturnsNullWhenKeyDoesNotExist()
    {
        $key = 'Thing';
        $index = null;
        $parsedKey = 'Thing';
        $parsedIndex = null;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(false);

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?

        }

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

    /**
     * Tests that Store::get returns null when the specified nth $key does not exist.
     */
    public function testGetReturnsNullWhenNthKeyDoesNotExist()
    {
        $key = '3rd ' . self::KEY;
        $index = null;
        $parsedKey = self::KEY;
        $parsedIndex = 2;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(false);

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?

        }

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

    /**
     * Tests that Store::get returns null when the specified $index param does not exist.
     */
    public function testGetReturnsNullWhenIndexDoesNotExist()
    {
        $key = self::KEY;
        $index = 2;
        $parsedKey = self::KEY;
        $parsedIndex = 2;

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

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?

            Phake::when($this->store)->keyExists($parsedKey, $parsedIndex)->thenReturn(false);

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?

        }

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