VersionCheckTest::testDeprecatedCacheConstructorParameter() - Code Metrics - Inspection of "[AdminBundle] Prepare code to remove deprecated do..." - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2751)

by Jeroen

created 2020-09-17 20:07 UTC

testDeprecatedCacheConstructorParameter() A

↳ Parent: VersionCheckTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?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 Psr\Cache\CacheItemInterface;
use Symfony\Component\Cache\Adapter\AdapterInterface;
use Symfony\Component\Cache\Adapter\ArrayAdapter;
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\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);


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


        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);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @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);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @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());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @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

            ->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

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

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

        $this->cache

            ->expects($this->once())
            ->method('getItem')
            ->willReturn($cacheItem)
        ;
        $versionCheckerMock = $this->setUpVersionCheckerMock(null);
        $versionCheckerMock->periodicallyCheck();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testCheckWithInvalidResponse()
    {
        $this->container

            ->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

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

        $versionCheckerMock = $this->setUpVersionCheckerMock(['parseComposer']);
        $versionCheckerMock
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('parseComposer')
            ->willReturn(['name' => 'box/spout'])
        ;
        $this->assertFalse($versionCheckerMock->check());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

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

        $this->container

            ->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(CacheItemInterface::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

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

        $this->container

            ->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
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->any())
            ->method('getClient')
            ->willReturn($client)
        ;
        $versionCheckerMock
            ->expects($this->once())
            ->method('getLockPath')
            ->willReturn($lockPath)
        ;

        if ('instanceOf' === $expectedType) {
            $this->assertInstanceOf($expected, $versionCheckerMock->check());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        } 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);
    }
}


Pull Request — master (#2751)

testDeprecatedCacheConstructorParameter() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Kunstmaan\AdminBundle\Tests\Helper;
4
5			use Doctrine\Common\Cache\ArrayCache;
6			use GuzzleHttp\Client;
7			use GuzzleHttp\Handler\MockHandler;
8			use GuzzleHttp\HandlerStack;
9			use GuzzleHttp\Psr7\Response;
10			use Kunstmaan\AdminBundle\Helper\VersionCheck\Exception\ParseException;
11			use Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker;
12			use PHPUnit\Framework\TestCase;
13			use Psr\Cache\CacheItemInterface;
14			use Symfony\Component\Cache\Adapter\AdapterInterface;
15			use Symfony\Component\Cache\Adapter\ArrayAdapter;
16			use Symfony\Component\DependencyInjection\ContainerInterface;
17			use Symfony\Component\HttpFoundation\Request;
18			use Symfony\Component\HttpFoundation\RequestStack;
19			use Symfony\Component\HttpKernel\Kernel;
20			use Symfony\Component\Translation\Translator;
21			use Symfony\Component\Translation\TranslatorInterface as LegacyTranslatorInterface;
22			use Symfony\Contracts\Translation\TranslatorInterface;
23
24			class VersionCheckTest extends TestCase
25			{
26			/** @var \PHPUnit\Framework\MockObject\MockObject\|LegacyTranslatorInterface\|TranslatorInterface */
27			private $translator;
28			/** @var ContainerInterface (mock) */
29			private $container;
30
31			/** @var ArrayAdapter */
32			private $cache;
33
34			public function setUp()
35			{
36			/* @var ContainerInterface $container */
37			$this->container = $this->createMock(ContainerInterface::class);
			0 ignored issues – show Documentation Bug introduced 2019-02-01 15:08 UTC by Report Bug Copy Issue Report It seems like `$this->createMock(\Symfo...tainerInterface::class)` of type `object<PHPUnit\Framework\MockObject\MockObject>` is incompatible with the declared type `object<Symfony\Component...ion\ContainerInterface>` of property `$container`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
38
39			$this->cache = $this->createMock(AdapterInterface::class);

Kunstmaan / KunstmaanBundlesCMS

Pull Request — master (#2751)

testDeprecatedCacheConstructorParameter() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like