Kunstmaan\AdminBundle\Tests\Helper\VersionCheckTest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	227
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	13	2
A	testDeprecatedCacheConstructorParameter()	0	4	1
A	testCacheConstructorParameterType()	0	7	1
A	testTranslatorConstructorParameterType()	0	7	1
A	setUpVersionCheckerMock()	0	10	1
A	testIsEnabled()	0	12	1
A	testPeriodicallyCheck()	0	20	1
A	testCheckWithInvalidResponse()	0	32	1
B	testCheck()	0	68	4
A	provider()	0	11	1
A	getVersionChecker()	0	4	1

<?php

namespace Kunstmaan\AdminBundle\Tests\Helper;

use Doctrine\Common\Cache\ArrayCache;
use GuzzleHttp\Client;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Response;
use Kunstmaan\AdminBundle\Helper\VersionCheck\Exception\ParseException;
use Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Cache\Adapter\AdapterInterface;
use Symfony\Component\Cache\Adapter\ArrayAdapter;
use Symfony\Component\Cache\CacheItem;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\Translation\Translator;
use Symfony\Component\Translation\TranslatorInterface as LegacyTranslatorInterface;
use Symfony\Contracts\Cache\ItemInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

class VersionCheckTest extends TestCase
{
    /** @var \PHPUnit\Framework\MockObject\MockObject|LegacyTranslatorInterface|TranslatorInterface */
    private $translator;
    /** @var ContainerInterface (mock) */
    private $container;

    /** @var ArrayAdapter */
    private $cache;

    public function setUp()
    {
        /* @var ContainerInterface $container */
        $this->container = $this->createMock(ContainerInterface::class);

It seems like $this->createMock(\Symfony\Component\DependencyInjection\ContainerInterface::class) of type object<PHPUnit\Framework\MockObject\MockObject> is incompatible with the declared type object<Symfony\Component\DependencyInjection\ContainerInterface> of property $container.

        $this->cache = $this->createMock(AdapterInterface::class);

It seems like $this->createMock(\Symfony\Component\Cache\Adapter\AdapterInterface::class) of type object<PHPUnit\Framework\MockObject\MockObject> is incompatible with the declared type object<Symfony\Component\Cache\Adapter\ArrayAdapter> of property $cache.

        if (\interface_exists(TranslatorInterface::class)) {
            $this->translator = $this->createMock(TranslatorInterface::class);
        } else {
            $this->translator = $this->createMock(LegacyTranslatorInterface::class);
        }
    }

    /**
     * @group legacy
     * @expectedDeprecation Passing an instance of "Doctrine\Common\Cache\Cache" as the second argument in "Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker::__construct" is deprecated since KunstmaanAdminBundle 5.7 and an instance of "Symfony\Component\Cache\Adapter\AdapterInterface" will be required in KunstmaanAdminBundle 6.0.
     */
    public function testDeprecatedCacheConstructorParameter()
    {
        new VersionChecker($this->createMock(ContainerInterface::class), new ArrayCache(), $this->translator);

$this->createMock(\Symfony\Component\DependencyInjection\ContainerInterface::class) is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<Symfony\Component\DependencyInjection\ContainerInterface>.

    }

    /**
     * @group legacy
     */
    public function testCacheConstructorParameterType()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('The "$cache" parameter should implement "Doctrine\Common\Cache\Cache" or "Symfony\Component\Cache\Adapter\AdapterInterface"');

        new VersionChecker($this->createMock(ContainerInterface::class), new \stdClass(), $this->translator);

$this->createMock(\Symfony\Component\DependencyInjection\ContainerInterface::class) is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<Symfony\Component\DependencyInjection\ContainerInterface>.

new \stdClass() is of type object<stdClass>, but the function expects a object<Doctrine\Common\Cache\Cache>|object<Symfony\Component\Cache\Adapter\AdapterInterface>.

    }

    /**
     * @group legacy
     */
    public function testTranslatorConstructorParameterType()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('The "$translator" parameter should be instance of "Symfony\Contracts\Translation\TranslatorInterface" or "Symfony\Component\Translation\TranslatorInterface"');

        new VersionChecker($this->createMock(ContainerInterface::class), new ArrayCache(), new \stdClass());

$this->createMock(\Symfony\Component\DependencyInjection\ContainerInterface::class) is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<Symfony\Component\DependencyInjection\ContainerInterface>.

    }

    /**
     * @param array|null $methods
     *
     * @return \PHPUnit\Framework\MockObject\MockObject|VersionChecker
     */
    public function setUpVersionCheckerMock(?array $methods)
    {
        $versionCheckerMock = $this->getMockBuilder(VersionChecker::class)
            ->setConstructorArgs([$this->container, $this->cache, $this->translator])
            ->setMethods($methods)
            ->getMock()
        ;

        return $versionCheckerMock;
    }

    public function testIsEnabled()
    {
        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->exactly(3))
            ->method('getParameter')
            ->will($this->onConsecutiveCalls('url', 300, true))
        ;

        $versionChecker = $this->getVersionChecker($this->container,  new ArrayAdapter(), $this->translator);

        $this->assertTrue($versionChecker->isEnabled());
    }

    public function testPeriodicallyCheck()
    {
        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->exactly(3))
            ->method('getParameter')
            ->will($this->onConsecutiveCalls('url', 300, true))
        ;

        $cacheItem = $this->createMock(ItemInterface::class);
        $cacheItem->method('isHit')->willReturn(true);
        $cacheItem->method('get')->willReturn([]);

        $this->cache

The method expects() does not seem to exist on object<Symfony\Component\Cache\Adapter\ArrayAdapter>.

            ->expects($this->once())
            ->method('getItem')
            ->willReturn($cacheItem)
        ;
        $versionCheckerMock = $this->setUpVersionCheckerMock(null);
        $versionCheckerMock->periodicallyCheck();

The method periodicallyCheck does only exist in Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker, but not in PHPUnit\Framework\MockObject\MockObject.

    }

    public function testCheckWithInvalidResponse()
    {
        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->exactly(4))
            ->method('getParameter')
            ->will($this->onConsecutiveCalls('url', 300, true, 'title'))
        ;

        $requestMock = $this->createMock(Request::class);

        $stackMock = $this->createMock(RequestStack::class);
        $stackMock
            ->expects($this->once())
            ->method('getCurrentRequest')
            ->willReturn($requestMock)
        ;
        $kernelMock = $this->createMock(Kernel::class);

        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->exactly(2))
            ->method('get')
            ->will($this->onConsecutiveCalls($stackMock, $kernelMock))
        ;

        $versionCheckerMock = $this->setUpVersionCheckerMock(['parseComposer']);
        $versionCheckerMock

The method expects does only exist in PHPUnit\Framework\MockObject\MockObject, but not in Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker.

            ->expects($this->once())
            ->method('parseComposer')
            ->willReturn(['name' => 'box/spout'])
        ;
        $this->assertFalse($versionCheckerMock->check());

The method check does only exist in Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker, but not in PHPUnit\Framework\MockObject\MockObject.

    }

    /**
     * @dataProvider provider
     */
    public function testCheck(string $lockPath, string $expectedType, string $expected)
    {
        if ('exception' === $expectedType) {
            $this->expectException(ParseException::class);
            $this->expectExceptionMessage($expected);
        }

        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->any())
            ->method('getParameter')
            ->will($this->onConsecutiveCalls('url', 300, true, 'title'))
        ;

        $requestStack = new RequestStack();
        $requestStack->push(new Request());

        $translatorMock = $this->createMock(Translator::class);
        $translatorMock
            ->expects($this->any())
            ->method('trans')
            ->willReturn('translated')
        ;

        $kernelMock = $this->createMock(Kernel::class);

        if ('instanceOf' === $expectedType) {
            $cacheItem = $this->createMock(ItemInterface::class);
            $cacheItem->method('isHit')->willReturn(false);
            $cacheItem->expects($this->once())->method('expiresAfter')->with(300);
            $cacheItem->expects($this->once())->method('set')->with($this->isInstanceOf($expected));

            $this->cache

The method expects() does not seem to exist on object<Symfony\Component\Cache\Adapter\ArrayAdapter>.

                ->expects($this->once())
                ->method('getItem')
                ->willReturn($cacheItem);
        }

        $this->container

The method expects() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            ->expects($this->exactly(3))
            ->method('get')
            ->will($this->onConsecutiveCalls($requestStack, $kernelMock, $translatorMock))
        ;

        $mock = new MockHandler([
            new Response(200, ['X-Foo' => 'Bar'], \json_encode(['foo' => 'bar'])),
        ]);

        $handler = HandlerStack::create($mock);
        $client = new Client(['handler' => $handler]);

        $versionCheckerMock = $this->setUpVersionCheckerMock(['getClient', 'getLockPath']);
        $versionCheckerMock

The method expects does only exist in PHPUnit\Framework\MockObject\MockObject, but not in Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker.

            ->expects($this->any())
            ->method('getClient')
            ->willReturn($client)
        ;
        $versionCheckerMock
            ->expects($this->once())
            ->method('getLockPath')
            ->willReturn($lockPath)
        ;

        if ('instanceOf' === $expectedType) {
            $this->assertInstanceOf($expected, $versionCheckerMock->check());

The method check does only exist in Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker, but not in PHPUnit\Framework\MockObject\MockObject.

        } else {
            $versionCheckerMock->check();
        }
    }

    public function provider()
    {
        $baseDir = __DIR__ . '/testdata';

        return [
            'composer.lock ok' => [$baseDir.'/composer_ok.lock', 'instanceOf', \stdClass::class],
            'composer.lock broken' => [$baseDir.'/composer_broken.lock', 'exception', 'translated (#4)'],
            'composer.lock bundleless' => [$baseDir.'/composer_bundleless.lock', 'exception', 'translated'],
            'composer.lock not found' => [$baseDir.'/composer_not_there.lock', 'exception', 'translated'],
        ];
    }

    private function getVersionChecker(ContainerInterface $container, AdapterInterface $cache, $translator)
    {
        return new VersionChecker($container, $cache, $translator);
    }
}