Issues in VersionCheckTest.php - Fixed Issues - 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-20 19:39 UTC

unit/Helper/VersionCheck/VersionCheckTest.php (5 issues)

Labels

Severity

Major 5

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Kunstmaan\AdminBundle\Tests\Helper;

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 Doctrine\Common\Cache\Cache;
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 ContainerInterface (mock) */
    private $container;

    /** @var Cache (mock) */
    private $cache;

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

        /* @var Cache $cache */
        $this->cache = $this->createMock(Cache::class);


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

$x = new MyClass();
$x->foo = true;
        } else {
            $this->translator = $this->createMock(LegacyTranslatorInterface::class);
        }
    }

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

        $versionCheckerMock = $this->setUpVersionCheckerMock(null);
        $this->assertIsBool($versionCheckerMock->isEnabled());
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 testPeriodicallyCheck()
    {
        $this->container
            ->expects($this->exactly(3))
            ->method('getParameter')
            ->will($this->onConsecutiveCalls('url', 300, true))
        ;

        $this->cache

            ->expects($this->once())
            ->method('fetch')
            ->willReturn([])
        ;
        $versionCheckerMock = $this->setUpVersionCheckerMock(null);
        $versionCheckerMock->periodicallyCheck();
    }

    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
            ->expects($this->once())
            ->method('parseComposer')
            ->willReturn(['name' => 'box/spout'])
        ;
        $this->assertFalse($versionCheckerMock->check());
    }

    /**
     * @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'))
        ;

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

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

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

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

        $this->container

            ->expects($this->exactly(3))
            ->method('get')
            ->will($this->onConsecutiveCalls($stackMock, $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
            ->expects($this->any())
            ->method('getClient')
            ->willReturn($client)
        ;
        $versionCheckerMock
            ->expects($this->once())
            ->method('getLockPath')
            ->willReturn($lockPath)
        ;

        if ('instanceOf' === $expectedType) {
            $this->assertInstanceOf($expected, $versionCheckerMock->check());
        } 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'],
        ];
    }
}


Pull Request — master (#2751)

unit/Helper/VersionCheck/VersionCheckTest.php (5 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

1			<?php
2
3			namespace Kunstmaan\AdminBundle\Tests\Helper;
4
5			use GuzzleHttp\Client;
6			use GuzzleHttp\Handler\MockHandler;
7			use GuzzleHttp\HandlerStack;
8			use GuzzleHttp\Psr7\Response;
9			use Kunstmaan\AdminBundle\Helper\VersionCheck\Exception\ParseException;
10			use Kunstmaan\AdminBundle\Helper\VersionCheck\VersionChecker;
11			use PHPUnit\Framework\TestCase;
12			use Doctrine\Common\Cache\Cache;
13			use Symfony\Component\DependencyInjection\ContainerInterface;
14			use Symfony\Component\HttpFoundation\Request;
15			use Symfony\Component\HttpFoundation\RequestStack;
16			use Symfony\Component\HttpKernel\Kernel;
17			use Symfony\Component\Translation\Translator;
18			use Symfony\Component\Translation\TranslatorInterface as LegacyTranslatorInterface;
19			use Symfony\Contracts\Translation\TranslatorInterface;
20
21			class VersionCheckTest extends TestCase
22			{
23			/** @var ContainerInterface (mock) */
24			private $container;
25
26			/** @var Cache (mock) */
27			private $cache;
28
29			public function setUp()
30			{
31			/* @var ContainerInterface $container */
32			$this->container = $this->createMock(ContainerInterface::class);
33
34			/* @var Cache $cache */
35			$this->cache = $this->createMock(Cache::class);
			0 ignored issues – show Documentation Bug introduced 2019-02-01 15:08 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `$this->createMock(\Doctr...mon\Cache\Cache::class)` of type `object<PHPUnit\Framework\MockObject\MockObject>` is incompatible with the declared type `object<Doctrine\Common\Cache\Cache>` of property `$cache`. 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...
36
37			if (\interface_exists(TranslatorInterface::class)) {
38			$this->translator = $this->createMock(TranslatorInterface::class);
			0 ignored issues – show Bug introduced 2020-02-21 14:27 UTC by Report Bug Copy Issue Report Show Similar Issues like this The property `translator` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
39			} else {
40			$this->translator = $this->createMock(LegacyTranslatorInterface::class);
41			}
42			}
43
44			/**
45			* @param array\|null $methods
46			*
47			* @return \PHPUnit\Framework\MockObject\MockObject\|VersionChecker
48			*/
49			public function setUpVersionCheckerMock(?array $methods)
50			{
51			$versionCheckerMock = $this->getMockBuilder(VersionChecker::class)
52			->setConstructorArgs([$this->container, $this->cache, $this->translator])
53			->setMethods($methods)
54			->getMock()
55			;
56
57			return $versionCheckerMock;
58			}
59
60			public function testIsEnabled()
61			{
62			$this->container
63			->expects($this->exactly(3))
64			->method('getParameter')
65			->will($this->onConsecutiveCalls('url', 300, true))
66			;
67
68			$versionCheckerMock = $this->setUpVersionCheckerMock(null);
69			$this->assertIsBool($versionCheckerMock->isEnabled());
			0 ignored issues – show Bug introduced 2019-02-08 12:16 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `isEnabled` does only exist in `Kunstmaan\AdminBundle\He...ionCheck\VersionChecker`, but not in `PHPUnit\Framework\MockObject\MockObject`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
70			}
71
72			public function testPeriodicallyCheck()
73			{
74			$this->container
75			->expects($this->exactly(3))
76			->method('getParameter')
77			->will($this->onConsecutiveCalls('url', 300, true))
78			;
79
80			$this->cache
			0 ignored issues – show Bug introduced 2019-02-08 12:16 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `expects()` does not seem to exist on `object<Doctrine\Common\Cache\Cache>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
81			->expects($this->once())
82			->method('fetch')
83			->willReturn([])
84			;
85			$versionCheckerMock = $this->setUpVersionCheckerMock(null);
86			$versionCheckerMock->periodicallyCheck();
87			}
88
89			public function testCheckWithInvalidResponse()
90			{
91			$this->container
92			->expects($this->exactly(4))
93			->method('getParameter')
94			->will($this->onConsecutiveCalls('url', 300, true, 'title'))
95			;
96
97			$requestMock = $this->createMock(Request::class);
98
99			$stackMock = $this->createMock(RequestStack::class);
100			$stackMock
101			->expects($this->once())
102			->method('getCurrentRequest')
103			->willReturn($requestMock)
104			;
105			$kernelMock = $this->createMock(Kernel::class);
106
107			$this->container
108			->expects($this->exactly(2))
109			->method('get')
110			->will($this->onConsecutiveCalls($stackMock, $kernelMock))
111			;
112
113			$versionCheckerMock = $this->setUpVersionCheckerMock(['parseComposer']);
114			$versionCheckerMock
115			->expects($this->once())
116			->method('parseComposer')
117			->willReturn(['name' => 'box/spout'])
118			;
119			$this->assertFalse($versionCheckerMock->check());
120			}
121
122			/**
123			* @dataProvider provider
124			*/
125			public function testCheck(string $lockPath, string $expectedType, string $expected)
126			{
127			if ('exception' === $expectedType) {
128			$this->expectException(ParseException::class);
129			$this->expectExceptionMessage($expected);
130			}
131
132			$this->container
133			->expects($this->any())
134			->method('getParameter')
135			->will($this->onConsecutiveCalls('url', 300, true, 'title'))
136			;
137
138			$requestMock = $this->createMock(Request::class);
139
140			$stackMock = $this->createMock(RequestStack::class);
141			$stackMock
142			->expects($this->once())
143			->method('getCurrentRequest')
144			->willReturn($requestMock)
145			;
146
147			$translatorMock = $this->createMock(Translator::class);
148			$translatorMock
149			->expects($this->any())
150			->method('trans')
151			->willReturn('translated')
152			;
153
154			$kernelMock = $this->createMock(Kernel::class);
155
156			$this->container
			0 ignored issues – show Bug introduced 2019-02-08 12:16 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `expects()` does not seem to exist on `object<Symfony\Component...ion\ContainerInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
157			->expects($this->exactly(3))
158			->method('get')
159			->will($this->onConsecutiveCalls($stackMock, $kernelMock, $translatorMock))
160			;
161
162			$mock = new MockHandler([
163			new Response(200, ['X-Foo' => 'Bar'], \json_encode(['foo' => 'bar'])),
164			]);
165
166			$handler = HandlerStack::create($mock);
167			$client = new Client(['handler' => $handler]);
168
169			$versionCheckerMock = $this->setUpVersionCheckerMock(['getClient', 'getLockPath']);
170			$versionCheckerMock
171			->expects($this->any())
172			->method('getClient')
173			->willReturn($client)
174			;
175			$versionCheckerMock
176			->expects($this->once())
177			->method('getLockPath')
178			->willReturn($lockPath)
179			;
180
181			if ('instanceOf' === $expectedType) {
182			$this->assertInstanceOf($expected, $versionCheckerMock->check());
183			} else {
184			$versionCheckerMock->check();
185			}
186			}
187
188			public function provider()
189			{
190			$baseDir = __DIR__ . '/testdata';
191
192			return [
193			'composer.lock ok' => [$baseDir.'/composer_ok.lock', 'instanceOf', \stdClass::class],
194			'composer.lock broken' => [$baseDir.'/composer_broken.lock', 'exception', 'translated (#4)'],
195			'composer.lock bundleless' => [$baseDir.'/composer_bundleless.lock', 'exception', 'translated'],
196			'composer.lock not found' => [$baseDir.'/composer_not_there.lock', 'exception', 'translated'],
197			];
198			}
199			}
200

Kunstmaan / KunstmaanBundlesCMS

Pull Request — master (#2751)

unit/Helper/VersionCheck/VersionCheckTest.php (5 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Duplication Side-by-Side

Filter issues like