Digia\Lumen\GraphQL\Tests\GraphQLServiceTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testGetProcessorCached()	0	13	1
A	testGetProcessorNotCached()	0	13	1
A	setUp()	0	9	1
A	testGetProcessor()	0	8	1
A	testForgetProcessor()	0	8	1

<?php

namespace Digia\Lumen\GraphQL\Tests;

use Digia\Lumen\GraphQL\Execution\Processor;
use Digia\Lumen\GraphQL\GraphQLService;
use Youshido\GraphQL\Schema\Schema;
use Illuminate\Contracts\Cache\Repository as CacheRepository;

class GraphQLServiceTest extends TestCase
{
    /**
     * @var GraphQLService
     */
    protected $service;

    /**
     * @var CacheRepository
     */
    protected $cache;

    /**
     * @var Processor
     */
    protected $processor;

    /**
     * @inheritdoc
     */
    public function setUp()
    {
        /** @var \PHPUnit_Framework_MockObject_MockObject|CacheRepository $cacheRepository */
        $this->cache = $this->getMockBuilder(CacheRepository::class)

It seems like $this->getMockBuilder(Illuminate\Contracts\Cache\Repository::class)->setMethods(array('get', 'forever'))->getMockForAbstractClass() of type PHPUnit_Framework_MockObject_MockObject is incompatible with the declared type Illuminate\Contracts\Cache\Repository of property $cache.

                             ->setMethods(['get', 'forever'])
                             ->getMockForAbstractClass();

        $this->processor = new Processor(new Schema());
        $this->service = new GraphQLService($this->processor, $this->cache);
    }


    public function testGetProcessor()
    {
        $this->cache->expects($this->any())
                     ->method('get')
                     ->with(GraphQLService::PROCESSOR_CACHE_KEY)
                     ->willReturn($this->processor);

        $this->assertEquals($this->processor, $this->service->getProcessor());
    }

    /**
     * Tests that a processor instance is stored in the cache if it doesn't exist yet
     */
    public function testGetProcessorNotCached()
    {
        // get() should return null
        $this->cache->expects($this->once())
                        ->method('get')
                        ->willReturn(null);

        // forever() should be called
        $this->cache->expects($this->once())
                        ->method('forever')
                        ->with(GraphQLService::PROCESSOR_CACHE_KEY);

        $this->service->getProcessor();
    }

    /**
     * Tests that the cache is left untouched if a cached instance exists
     */
    public function testGetProcessorCached()
    {
        // get() should return Processor
        $this->cache->expects($this->once())
                        ->method('get')
                        ->willReturn($this->processor);

        // forever() should be never be called
        $this->cache->expects($this->never())
                        ->method('forever');
        $processor = new Processor(new Schema());

        $this->assertEquals($processor, $this->service->getProcessor());
    }

    /**
     * Tests that the cache is really cleared
     */
    public function testForgetProcessor()
    {
        // forget() should be called once
        $this->cache->expects($this->once())
                        ->method('forget')
                        ->with(GraphQLService::PROCESSOR_CACHE_KEY);

        $this->service->forgetProcessor();
    }
}