Butler\Graphql\Concerns\AssertsPromises

Complexity

Total Complexity

13

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Test Coverage

Coverage

76.09%

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
B	waitForPromise()	0	43	6
A	getLoop()	0	7	2
A	assertPromiseFulfills()	0	24	5

<?php

namespace Butler\Graphql\Concerns;

use Closure;
use Exception;
use React\EventLoop\Factory as LoopFactory;
use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface;

use function React\Promise\all;

trait AssertsPromises
{
    private $loop;

    /**
     * @param  \React\Promise\PromiseInterface|array  $promise
     * @param  mixed|Closure  $expectedValue
     */
    public function assertPromiseFulfills($promise, $expectedValue = null): void
    {
        $this->addToAssertionCount(1);

It seems like addToAssertionCount() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if (! $promise instanceof PromiseInterface) {
            $promise = all($promise);
        }

        try {
            $result = $this->waitForPromise($promise);
        } catch (Exception $_) {
            $this->fail('Failed asserting that promise fulfills. Promise was rejected.');

It seems like fail() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if ($expectedValue instanceof Closure) {
            $this->assertTrue($expectedValue($result));

It seems like assertTrue() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return;
        }

        if (! is_null($expectedValue)) {
            $this->assertEquals(

It seems like assertEquals() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $expectedValue,
                $result,
                'Failed asserting that promise fulfills with a specified value.'
            );
        }
    }

    protected function getLoop(): LoopInterface
    {
        if (! $this->loop) {
            $this->loop = LoopFactory::create();
        }

        return $this->loop;
    }

    private function waitForPromise(PromiseInterface $promise)
    {
        $wait = true;
        $resolved = null;
        $exception = null;
        $rejected = false;

        $promise->then(
            function ($c) use (&$resolved, &$wait) {
                $resolved = $c;
                $wait = false;
                $this->getLoop()->stop();
            },
            function ($error) use (&$exception, &$rejected, &$wait) {
                $exception = $error;
                $rejected = true;
                $wait = false;
                $this->getLoop()->stop();
            }
        );

        // Explicitly overwrite argument with null value. This ensure that this
        // argument does not show up in the stack trace in PHP 7+ only.
        $promise = null;

The assignment to $promise is dead and can be removed.

        while ($wait) {
            $this->getLoop()->run();
        }

        if ($rejected) {
            if (! $exception instanceof Exception) {
                $type = is_object($exception) ? get_class($exception) : gettype($exception);
                $exception = new \UnexpectedValueException(
                    'Promise rejected with unexpected value of type ' . $type,
                    0,
                    $exception instanceof \Throwable ? $exception : null
                );
            }

            throw $exception;
        }

        return $resolved;
    }
}