TraderInteractiveTest\FilterResponseTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	135
Duplicated Lines	11.85 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	construct()	0	14	1
A	constructWithErrors()	0	14	1
A	constructDefault()	0	12	1
A	gettingInvalidPropertyThrowsException()	0	8	1
A	settingValidPropertyThrowsAnException()	8	8	1
A	settingInvalidPropertyThrowsAnException()	8	8	1
A	toArray()	0	7	1
A	provideToArray()	0	17	1

<?php

namespace TraderInteractiveTest;

use InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use TraderInteractive\Exceptions\ReadOnlyViolationException;
use TraderInteractive\FilterResponse;

/**
 * @coversDefaultClass \TraderInteractive\FilterResponse
 */
class FilterResponseTest extends TestCase
{
    /**
     * @test
     * @covers ::__construct
     */
    public function construct()
    {
        $value = ['foo' => 'bar'];
        $errors = [];
        $unknowns = ['other' => 'unknown'];

        $response = new FilterResponse($value, $errors, $unknowns);

        $this->assertSame(true, $response->success);
        $this->assertSame($value, $response->filteredValue);
        $this->assertSame($errors, $response->errors);
        $this->assertSame(null, $response->errorMessage);
        $this->assertSame($unknowns, $response->unknowns);
    }

    /**
     * @test
     * @covers ::__construct
     */
    public function constructWithErrors()
    {
        $value = ['foo' => 'bar'];
        $errors = ['something bad happened', 'and something else too'];
        $unknowns = ['other' => 'unknown'];

        $response = new FilterResponse($value, $errors, $unknowns);

        $this->assertSame(false, $response->success);
        $this->assertSame($value, $response->filteredValue);
        $this->assertSame($errors, $response->errors);
        $this->assertSame("something bad happened\nand something else too", $response->errorMessage);
        $this->assertSame($unknowns, $response->unknowns);
    }

    /**
     * @test
     * @covers ::__construct
     */
    public function constructDefault()
    {
        $input = ['filtered' => 'input'];

        $response = new FilterResponse($input);

        $this->assertSame(true, $response->success);
        $this->assertSame($input, $response->filteredValue);
        $this->assertSame([], $response->errors);
        $this->assertSame(null, $response->errorMessage);
        $this->assertSame([], $response->unknowns);
    }

    /**
     * @test
     * @covers ::__construct
     */
    public function gettingInvalidPropertyThrowsException()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Property 'foo' does not exist");

        $response = new FilterResponse([]);
        $response->foo;

The property foo does not exist on object<TraderInteractive\FilterResponse>. Since you implemented __get, maybe consider adding a @property annotation.

    }

    /**
     * @test
     * @covers ::__construct
     */
    public function settingValidPropertyThrowsAnException()

This method seems to be duplicated in your project.

    {
        $this->expectException(ReadOnlyViolationException::class);
        $this->expectExceptionMessage("Property 'success' is read-only");

        $response = new FilterResponse([]);
        $response->success = false;
    }

    /**
     * @test
     * @covers ::__construct
     */
    public function settingInvalidPropertyThrowsAnException()

This method seems to be duplicated in your project.

    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Property 'foo' does not exist");

        $response = new FilterResponse([]);
        $response->foo = false;

The property foo does not exist on object<TraderInteractive\FilterResponse>. Since you implemented __set, maybe consider adding a @property annotation.

    }

    /**
     * @test
     * @covers ::toArray
     * @dataProvider provideToArray
     *
     * @param array $value    The filtered value to pass to the response.
     * @param array $errors   The errors to pass to the response.
     * @param array $unknowns The unknowns to pass to the response.
     * @param array $expected The expected array value.
     */
    public function toArray(array $value, array $errors, array $unknowns, array $expected)
    {
        $response = new FilterResponse($value, $errors, $unknowns);
        $arrayResponse = $response->toArray();

        $this->assertSame($expected, $arrayResponse);
    }

    /**
     * @return array
     */
    public function provideToArray() : array
    {
        return [
            'success' => [
                'input' => ['foo' => 'bar'],
                'errors' => [],
                'unknowns' => ['other' => 'unknown'],
                'expected' => [true, ['foo' => 'bar'], null, ['other' => 'unknown']],
            ],
            'failure' => [
                'input' => ['foo' => 'bar'],
                'errors' => ['something bad happened', 'and something else too'],
                'unknowns' => ['other' => 'unknown'],
                'expected' => [false, null, "something bad happened\nand something else too", ['other' => 'unknown']],
            ],
        ];
    }
}