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 (1 issue)

Showing only issues like (Show All)

a method exists on all of the called types.

Bug Major

Peter Zentjens 1

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);
        } 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 (1 issue)

Showing only issues like (Show All)

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);
36
37			if (\interface_exists(TranslatorInterface::class)) {
38			$this->translator = $this->createMock(TranslatorInterface::class);
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
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
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 (1 issue)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Duplication Side-by-Side

Filter issues like