Chekote\NounStore\Assert\KeyValueContainsTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testFailedMatchThrowsRuntimeException()	0	16	1
A	testInvalidArgumentExceptionBubblesUpFromKeyValueContains()	0	15	1
A	setUp()	0	6	1
A	testInvalidArgumentExceptionBubblesUpFromKeyExists()	0	12	1
A	testSuccessfulMatchThrowsNoException()	0	12	1
A	testMissingKeyThrowsOutOfBoundsException()	0	13	1

<?php namespace Chekote\NounStore\Assert;

use Chekote\NounStore\Key\KeyTest;
use Chekote\Phake\Phake;
use InvalidArgumentException;
use OutOfBoundsException;
use RuntimeException;

/**
 * @covers \Chekote\NounStore\Assert::keyValueContains()
 */
class KeyValueContainsTest extends AssertTest
{
    public function setUp()
    {
        parent::setUp();

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

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

    }

    public function testInvalidArgumentExceptionBubblesUpFromKeyExists()
    {
        $value = 'Some Value';
        $exception = new InvalidArgumentException('Key syntax is invalid');

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

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

It seems like $this->assert can also be of type Chekote\NounStore\Assert; 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());

        $this->assert->keyValueContains(KeyTest::INVALID_KEY, $value);

The method keyValueContains() does not exist on Phake_IMock.

    }

    // An invalid key should not get past keyExists(), so this should never actually be possible. But we test
    // the behavior here to ensure that our method behaves correctly should the impossible ever occur.
    public function testInvalidArgumentExceptionBubblesUpFromKeyValueContains()
    {
        $value = 'Some Value';
        $exception = new InvalidArgumentException('Key syntax is invalid');

        /* @noinspection PhpUndefinedMethodInspection */
        {
            Phake::expect($this->assert, 1)->keyExists(KeyTest::INVALID_KEY)->thenReturn(true);

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

            Phake::expect($this->store, 1)->keyValueContains(KeyTest::INVALID_KEY, $value)->thenThrow($exception);

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

It seems like $this->store can also be of type Chekote\NounStore\Store; 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());

        $this->assert->keyValueContains(KeyTest::INVALID_KEY, $value);
    }

    public function testMissingKeyThrowsOutOfBoundsException()
    {
        $key = '10th Thing';
        $value = 'Some Value';
        $exception = new OutOfBoundsException("Entry '$key' was not found in the store.");

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

It seems like $this->assert can also be of type Chekote\NounStore\Assert; 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());

        $this->assert->keyValueContains($key, $value);
    }

    public function testFailedMatchThrowsRuntimeException()
    {
        $key = '10th Thing';
        $value = 'Some Value';
        $exception = new RuntimeException("Entry '$key' does not contain '$value'");

        /* @noinspection PhpUndefinedMethodInspection */
        {
            Phake::expect($this->assert, 1)->keyExists($key)->thenReturn(null);

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

            Phake::expect($this->store, 1)->keyValueContains($key, $value)->thenReturn(false);

It seems like $this->store can also be of type Chekote\NounStore\Store; 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());

        $this->assert->keyValueContains($key, $value);
    }

    public function testSuccessfulMatchThrowsNoException()
    {
        $key = '10th Thing';
        $value = 'Some Value';

        /* @noinspection PhpUndefinedMethodInspection */
        {
            Phake::expect($this->assert, 1)->keyExists($key)->thenReturn(null);

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

            Phake::expect($this->store, 1)->keyValueContains($key, $value)->thenReturn(true);

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

        }

        $this->assert->keyValueContains($key, $value);
    }
}