SyncTest::testReturnsAPromiseIfAnyFieldIsAsynchronous() - Code Metrics - Inspection of "Add more BuildSchema tests + cleanup" - webonyx/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Push — master ( 6e7cf2...804daa )

by Vladimir
created 2018-08-22 09:21 UTC
testReturnsAPromiseIfAnyFieldIsAsynchronous() A

↳ Parent: SyncTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	6
dl	0
loc	9
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
<?php
namespace GraphQL\Tests\Executor;

use GraphQL\Deferred;
use GraphQL\Error\Error;
use GraphQL\Error\FormattedError;
use GraphQL\Executor\ExecutionResult;
use GraphQL\Executor\Executor;
use GraphQL\Executor\Promise\Adapter\SyncPromise;
use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
use GraphQL\Executor\Promise\Promise;
use GraphQL\GraphQL;
use GraphQL\Language\Parser;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use GraphQL\Utils\Utils;
use GraphQL\Validator\DocumentValidator;
use PHPUnit\Framework\TestCase;

class SyncTest extends TestCase
{
    /** @var Schema */
    private $schema;

    /** @var SyncPromiseAdapter */
    private $promiseAdapter;

    public function setUp()
    {
        $this->schema = new Schema([
            'query' => new ObjectType([
                'name' => 'Query',
                'fields' => [
                    'syncField' => [
                        'type' => Type::string(),
                        'resolve' => function ($rootValue) {
                            return $rootValue;
                        }
                    ],
                    'asyncField' => [
                        'type' => Type::string(),
                        'resolve' => function ($rootValue) {
                            return new Deferred(function () use ($rootValue) {
                                return $rootValue;
                            });
                        }
                    ]
                ]
            ]),
            'mutation' => new ObjectType([
                'name' => 'Mutation',
                'fields' => [
                    'syncMutationField' => [
                        'type' => Type::string(),
                        'resolve' => function ($rootValue) {
                            return $rootValue;
                        }
                    ]
                ]
            ])
        ]);
        $this->promiseAdapter = new SyncPromiseAdapter();
    }

    // Describe: Execute: synchronously when possible

    /**
     * @it does not return a Promise for initial errors
     */
    public function testDoesNotReturnAPromiseForInitialErrors()
    {
        $doc = 'fragment Example on Query { syncField }';
        $result = $this->execute(
            $this->schema,
            Parser::parse($doc),
            'rootValue'
        );
        $this->assertSync(['errors' => [['message' => 'Must provide an operation.']]], $result);
    }

    /**
     * @it does not return a Promise if fields are all synchronous
     */
    public function testDoesNotReturnAPromiseIfFieldsAreAllSynchronous()
    {
        $doc = 'query Example { syncField }';
        $result = $this->execute(
            $this->schema,
            Parser::parse($doc),
            'rootValue'
        );
        $this->assertSync(['data' => ['syncField' => 'rootValue']], $result);
    }

    /**
     * @it does not return a Promise if mutation fields are all synchronous
     */
    public function testDoesNotReturnAPromiseIfMutationFieldsAreAllSynchronous()
    {
        $doc = 'mutation Example { syncMutationField }';
        $result = $this->execute(
            $this->schema,
            Parser::parse($doc),
            'rootValue'
        );
        $this->assertSync(['data' => ['syncMutationField' => 'rootValue']], $result);
    }

    /**
     * @it returns a Promise if any field is asynchronous
     */
    public function testReturnsAPromiseIfAnyFieldIsAsynchronous()
    {
        $doc = 'query Example { syncField, asyncField }';
        $result = $this->execute(
            $this->schema,
            Parser::parse($doc),
            'rootValue'
        );
        $this->assertAsync(['data' => ['syncField' => 'rootValue', 'asyncField' => 'rootValue']], $result);
    }

    // Describe: graphqlSync

    /**
     * @it does not return a Promise for syntax errors
     */
    public function testDoesNotReturnAPromiseForSyntaxErrors()
    {
        $doc = 'fragment Example on Query { { { syncField }';
        $result = $this->graphqlSync(
            $this->schema,
            $doc
        );
        $this->assertSync([
            'errors' => [
                ['message' => 'Syntax Error: Expected Name, found {',
                'locations' => [['line' => 1, 'column' => 29]]]
            ]
        ], $result);
    }

    /**
     * @it does not return a Promise for validation errors
     */
    public function testDoesNotReturnAPromiseForValidationErrors()
    {
        $doc = 'fragment Example on Query { unknownField }';
        $validationErrors = DocumentValidator::validate($this->schema, Parser::parse($doc));
        $result = $this->graphqlSync(
            $this->schema,
            $doc
        );
        $expected = [
            'errors' => Utils::map($validationErrors, function ($e) {
                return FormattedError::createFromException($e);
            })
        ];
        $this->assertSync($expected, $result);
    }

    /**
     * @it does not return a Promise for sync execution
     */
    public function testDoesNotReturnAPromiseForSyncExecution()
    {
        $doc = 'query Example { syncField }';
        $result = $this->graphqlSync(
            $this->schema,
            $doc,
            'rootValue'
        );
        $this->assertSync(['data' => ['syncField' => 'rootValue']], $result);
    }

    private function graphqlSync($schema, $doc, $rootValue = null)
    {
        return GraphQL::promiseToExecute($this->promiseAdapter, $schema, $doc, $rootValue);
    }

    private function execute($schema, $doc, $rootValue = null)
    {
        return Executor::promiseToExecute($this->promiseAdapter, $schema, $doc, $rootValue);
    }

    private function assertSync($expectedFinalArray, $actualResult)
    {
        $message = 'Failed assertion that execution was synchronous';
        $this->assertInstanceOf(Promise::class, $actualResult, $message);
        $this->assertInstanceOf(SyncPromise::class, $actualResult->adoptedPromise, $message);
        $this->assertEquals(SyncPromise::FULFILLED, $actualResult->adoptedPromise->state, $message);
        $this->assertInstanceOf(ExecutionResult::class, $actualResult->adoptedPromise->result, $message);
        $this->assertArraySubset($expectedFinalArray, $actualResult->adoptedPromise->result->toArray(), $message);
        $this->assertArraySubset($expectedFinalArray, $actualResult->adoptedPromise->result->toArray(), /** @scrutinizer ignore-type */ $message);
    }

    private function assertAsync($expectedFinalArray, $actualResult)
    {
        $message = 'Failed assertion that execution was asynchronous';
        $this->assertInstanceOf(Promise::class, $actualResult, $message);
        $this->assertInstanceOf(SyncPromise::class, $actualResult->adoptedPromise, $message);
        $this->assertEquals(SyncPromise::PENDING, $actualResult->adoptedPromise->state, $message);
        $resolvedResult = $this->promiseAdapter->wait($actualResult);
        $this->assertInstanceOf(ExecutionResult::class, $resolvedResult, $message);
        $this->assertArraySubset($expectedFinalArray, $resolvedResult->toArray(), $message);
        $this->assertArraySubset($expectedFinalArray, $resolvedResult->toArray(), /** @scrutinizer ignore-type */ $message);
    }
}

webonyx / graphql-php

Push — master ( 6e7cf2...804daa )

testReturnsAPromiseIfAnyFieldIsAsynchronous() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
