Overblog\GraphQLBundle\Tests\Relay\Connection\Output\ConnectionBuilderFromPromisedTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testReturnsAllElementsWithoutFilters()	0	6	1
A	testRespectsASmallerFirst()	0	6	1
A	testInvalidPromise()	0	4	1
A	invalidPromiseDataProvider()	0	10	1
A	testRespectsASmallerFirstWhenSlicing()	0	13	1
A	testInvalidPromiseWhenSlicing()	0	4	1
A	promisedLetters()	0	4	2
A	assertEqualsFromPromised()	0	4	1
A	await()	0	19	2

<?php

/*
 * This file is part of the OverblogGraphQLBundle package.
 *
 * (c) Overblog <http://github.com/overblog/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Overblog\GraphQLBundle\Tests\Relay\Connection\Output;

use Overblog\GraphQLBundle\Relay\Connection\Output\ConnectionBuilder;
use React\Promise\FulfilledPromise;

class ConnectionBuilderFromPromisedTest extends AbstractConnectionBuilderTest
{
    public function testReturnsAllElementsWithoutFilters()
    {
        $promise = ConnectionBuilder::connectionFromPromisedArray($this->promisedLetters(), []);
        $expected = $this->getExpectedConnection($this->letters, false, false);
        $this->assertEqualsFromPromised($expected, $promise);
    }

    public function testRespectsASmallerFirst()
    {
        $promise = ConnectionBuilder::connectionFromPromisedArray($this->promisedLetters(), ['first' => 2]);
        $expected = $this->getExpectedConnection(['A', 'B'], false, true);
        $this->assertEqualsFromPromised($expected, $promise);
    }

    /**
     * @param $invalidPromise
     * @dataProvider invalidPromiseDataProvider
     *
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage This is not a valid promise.
     */
    public function testInvalidPromise($invalidPromise)
    {
        ConnectionBuilder::connectionFromPromisedArray($invalidPromise, []);
    }

    public function invalidPromiseDataProvider()
    {
        return [
            [new \stdClass()],
            ['fake'],
            [['fake']],
            [false],
            [true],
        ];
    }

    public function testRespectsASmallerFirstWhenSlicing()
    {
        $promise = ConnectionBuilder::connectionFromPromisedArraySlice(
            $this->promisedLetters(['A', 'B', 'C']),
            ['first' => 2],
            [
                'sliceStart' => 0,
                'arrayLength' => 5,
            ]
        );
        $expected = $this->getExpectedConnection(['A', 'B'], false, true);
        $this->assertEqualsFromPromised($expected, $promise);
    }

    /**
     * @param $invalidPromise
     * @dataProvider invalidPromiseDataProvider
     *
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage This is not a valid promise.
     */
    public function testInvalidPromiseWhenSlicing($invalidPromise)
    {
        ConnectionBuilder::connectionFromPromisedArraySlice($invalidPromise, [], []);
    }

    private function promisedLetters(array $letters = null)
    {
        return \React\Promise\resolve($letters ?: $this->letters);
    }

    private function assertEqualsFromPromised($expected, FulfilledPromise $promise)
    {
        $this->assertEquals($expected, self::await($promise));
    }

    private static function await(FulfilledPromise $promise)
    {
        $resolvedValue = null;
        $rejectedReason = null;
        $promise->then(
            function ($value) use (&$resolvedValue) {
                $resolvedValue = $value;
            },
            function ($reason) use (&$rejectedReason) {
                $rejectedReason = $reason;
            }
        );

        if ($rejectedReason instanceof \Exception) {
            throw $rejectedReason;
        }

        return $resolvedValue;
    }
}