Overblog\GraphQLBundle\Tests\Error\ReactPromiseAdapterTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	testWaitWithNotSupportedPromise()	0	5	1
A	testWaitRejectedPromise()	0	5	1
B	testWaitAsyncPromise()	0	24	1
A	testSkipsConversionWhenPromiseIsAGraphQlOne()	0	12	1

<?php

namespace Overblog\GraphQLBundle\Tests\Error;

use GraphQL\Executor\Promise\Promise;
use Overblog\GraphQLBundle\Executor\Promise\Adapter\ReactPromiseAdapter;
use PHPUnit\Framework\TestCase;
use React\Promise\FulfilledPromise;
use Symfony\Component\Process\PhpProcess;

class ReactPromiseAdapterTest extends TestCase
{
    /** @var ReactPromiseAdapter */
    private $adapter;

    public function setUp()
    {
        $this->adapter = new ReactPromiseAdapter();
    }

    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage The "Overblog\GraphQLBundle\Executor\Promise\Adapter\ReactPromiseAdapter::wait" method must be call with compatible a Promise.
     */
    public function testWaitWithNotSupportedPromise()
    {
        $noSupportedPromise = new Promise(new \stdClass(), $this->adapter);
        $this->adapter->wait($noSupportedPromise);
    }

    /**
     * @expectedException \Exception
     * @expectedExceptionMessage Promise has been rejected!
     */
    public function testWaitRejectedPromise()
    {
        $rejected = $this->adapter->createRejected(new \Exception('Promise has been rejected!'));

new \Exception('Promise has been rejected!') is of type object<Exception>, but the function expects a object<Throwable>.

        $this->adapter->wait($rejected);
    }

    public function testWaitAsyncPromise()
    {
        $output = 'OK!';
        $process = new PhpProcess(<<<EOF
<?php
usleep(30);
echo '$output';
EOF
        );

        $promise = $this->adapter->create(function (callable $resolve) use (&$process) {
            $process->start(function () use ($resolve, &$process) {
                $output = $process->getOutput();
                $resolve($output);
            });
        });

        $this->assertEquals(
            $output,
            $this->adapter->wait($promise, function () use (&$process) {
                $process->wait();
            })
        );
    }

    public function testSkipsConversionWhenPromiseIsAGraphQlOne()
    {
        $reactAdapter = new ReactPromiseAdapter();
        $reactPromise = new FulfilledPromise(1);

        $promise = $reactAdapter->convertThenable($reactPromise);
        // Test it's already converted then skip it
        $reactAdapter->convertThenable($promise);

        $this->assertInstanceOf(Promise::class, $promise);
        $this->assertInstanceOf(FulfilledPromise::class, $promise->adoptedPromise);
    }
}