DomainConfigurationTest::testGetDefaultLocale() - Code Metrics - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

DomainConfigurationTest::testGetDefaultLocale() A
last analyzed 2020-11-05 13:23 UTC

↳ Parent: DomainConfigurationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Kunstmaan\MultiDomainBundle\Tests\Helper;

use Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration;
use Kunstmaan\NodeBundle\Entity\Node;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;

class DomainConfigurationTest extends TestCase
{
    /**
     * @var Node
     */
    protected $node;

    public function testGetHostWithMultiLanguage()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('multilangdomain.tld', $object->getHost());
    }

    public function testGetHostWithSingleLanguage()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('singlelangdomain.tld', $object->getHost());
    }

    public function testGetHostWithAlias()
    {
        $request = $this->getAliasedRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('singlelangdomain.tld', $object->getHost());
    }

    /**
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::__construct
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getMasterRequest
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHost
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::hasHostOverride
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHostOverride
     */
    public function testGetHostWithOverrideOnFrontend()
    {
        $request = $this->getRequestWithOverride('/frontend-uri');
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('multilangdomain.tld', $object->getHost());
    }

    /**
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::__construct
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getMasterRequest
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHost
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::hasHostOverride
     * @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHostOverride
     */
    public function testGetHostWithOverrideOnBackend()
    {
        $request = $this->getRequestWithOverride('/nl/admin/backend-uri');
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('singlelangdomain.tld', $object->getHost());
    }

    /**
     * @throws \ReflectionException
     */
    public function testHostOverrideReturnsNull()
    {
        $request = new Request();
        $object = $this->getDomainConfiguration($request);
        $reflection = new ReflectionClass(DomainConfiguration::class);
        $method = $reflection->getMethod('getHostOverride');
        $method->setAccessible(true);

        $this->assertNull($method->invoke($object));
    }

    public function testGetHosts()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('multilangdomain.tld', 'singlelangdomain.tld'), $object->getHosts());
    }

    public function testGetDefaultLocale()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('en_GB', $object->getDefaultLocale());
    }

    public function testGetDefaultLocaleWithUnknownDomain()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('en', $object->getDefaultLocale());
    }

    public function testGetExtraDataWithoutDataSet()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array(), $object->getExtraData());
    }

    public function testGetExtraDataWithDataSet()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('foo' => 'bar'), $object->getExtraData());
    }

    public function testGetRootNode()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals($this->node, $object->getRootNode());
    }

    public function testGetRootNodeWithUnknown()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertNull($object->getRootNode());
    }

    public function testIsMultiDomainHostWithSingleLanguage()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertTrue($object->isMultiDomainHost());
    }

    public function testIsMultiDomainHostWithMultiLanguage()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertTrue($object->isMultiDomainHost());
    }

    public function testIsMultiDomainHostWithUnknown()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertFalse($object->isMultiDomainHost());
    }

    public function testIsMultiLanguageWithSingleLanguage()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertFalse($object->isMultiLanguage());
    }

    public function testIsMultiLanguageWithMultiLanguage()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertTrue($object->isMultiLanguage());
    }

    public function testIsMultiLanguageWithUnknown()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertFalse($object->isMultiLanguage());
    }

    public function testGetFrontendLocalesWithSingleLanguage()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('en'), $object->getFrontendLocales());
    }

    public function testGetHostBaseUrl()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals('http://multilangdomain.tld', $object->getHostBaseUrl('multilangdomain.tld'));
    }

    public function testGetFullHost()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertNull($object->getFullHost('not-here.tld'));
    }

    public function testGetLocalesExtraData()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $data = $object->getLocalesExtraData();
        $this->assertEmpty($data);
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $data = $object->getLocalesExtraData();
        $this->assertArrayHasKey('foo', $data);
    }

    public function testGetFullHostConfig()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $array = $object->getFullHostConfig();
        $this->assertArrayHasKey('multilangdomain.tld', $array);
        $this->assertArrayHasKey('singlelangdomain.tld', $array);
    }

    public function testHasHostSwitched()
    {
        $request = $this->getRequestWithOverride('/admin/somewhere');
        $object = $this->getDomainConfiguration($request);
        $this->assertTrue($object->hasHostSwitched());
    }

    public function testGetHostSwitched()
    {
        $request = $this->getRequestWithOverride('/admin/somewhere');
        $object = $this->getDomainConfiguration($request);
        $switched = $object->getHostSwitched();
        $this->assertArrayHasKey('id', $switched);
        $this->assertArrayHasKey('host', $switched);
        $this->assertArrayHasKey('protocol', $switched);
        $this->assertArrayHasKey('type', $switched);
    }

    public function testFullHostById()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertNull($object->getFullHostById(666));
        $this->assertNotNull($object->getFullHostById(123));
    }

    public function testGetFrontendLocalesWithMultiLanguage()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('nl', 'fr', 'en'), $object->getFrontendLocales());
    }

    public function testGetFrontendLocalesWithUnknown()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('en'), $object->getFrontendLocales());
    }

    public function testGetBackendLocalesWithSingleLanguage()
    {
        $request = $this->getSingleLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('en_GB'), $object->getBackendLocales());
    }

    public function testGetBackendLocalesWithMultiLanguage()
    {
        $request = $this->getMultiLanguageRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('nl_BE', 'fr_BE', 'en_GB'), $object->getBackendLocales());
    }

    public function testGetBackendLocalesWithUnknown()
    {
        $request = $this->getUnknownDomainRequest();
        $object = $this->getDomainConfiguration($request);
        $this->assertEquals(array('en'), $object->getBackendLocales());
    }

    private function getEntityManager()
    {
        $em = $this->createMock('Doctrine\ORM\EntityManagerInterface');
        $em

            ->method('getRepository')
            ->with($this->equalTo(Node::class))
            ->willReturn($this->getNodeRepository());

        return $em;
    }

    private function getAdminRouteHelper()
    {
        $adminRouteReturnValueMap = [
            ['/frontend-uri', false],
            ['/nl/admin/backend-uri', true],
            ['/admin/somewhere', true],
        ];

        $adminRouteHelper = $this->getMockBuilder('Kunstmaan\AdminBundle\Helper\AdminRouteHelper')
            ->disableOriginalConstructor()
            ->getMock();
        $adminRouteHelper
            ->expects($this->any())
            ->method('isAdminRoute')
            ->willReturnMap($adminRouteReturnValueMap);

        return $adminRouteHelper;
    }

    private function getNodeRepository()
    {
        $this->node = $this->createMock('Kunstmaan\NodeBundle\Entity\Node');


        $repository = $this->getMockBuilder('Kunstmaan\NodeBundle\Repository\NodeRepository')
            ->disableOriginalConstructor()
            ->getMock();
        $repository

            ->method('getNodeByInternalName')
            ->willReturn($this->node);

        return $repository;
    }

    private function getUnknownDomainRequest()
    {
        return Request::create('http://unknown.tld/');
    }

    private function getMultiLanguageRequest()
    {
        return Request::create('http://multilangdomain.tld/');
    }

    private function getSingleLanguageRequest()
    {
        return Request::create('http://singlelangdomain.tld/');
    }

    private function getAliasedRequest()
    {
        return Request::create('http://single-alias.tld/');
    }

    private function getRequestWithOverride($uri)
    {
        $session = new Session(new MockArraySessionStorage());
        $session->set(DomainConfiguration::OVERRIDE_HOST, 'singlelangdomain.tld');
        $session->set(DomainConfiguration::SWITCH_HOST, 'multilangdomain.tld');

        $request = Request::create('http://multilangdomain.tld' . $uri);
        $request->setSession($session);
        $request->cookies->set($session->getName(), null);

        return $request;
    }

    private function getDomainConfiguration($request)
    {
        $hostMap = array(
            'multilangdomain.tld' => [
                'id' => 456,
                'host' => 'multilangdomain.tld',
                'protocol' => 'http',
                'type' => 'multi_lang',
                'default_locale' => 'en_GB',
                'locales' => ['nl' => 'nl_BE', 'fr' => 'fr_BE', 'en' => 'en_GB'],
                'reverse_locales' => ['nl_BE' => 'nl', 'fr_BE' => 'fr', 'en_GB' => 'en'],
                'root' => 'homepage_multi',
                'aliases' => ['multi-alias.tld'],
                'extra' => ['foo' => 'bar'],
                'locales_extra' => ['foo' => 'bar'],
            ],
            'singlelangdomain.tld' => [
                'id' => 123,
                'host' => 'singlelangdomain.tld',
                'type' => 'single_lang',
                'default_locale' => 'en_GB',
                'locales' => ['en' => 'en_GB'],
                'reverse_locales' => ['en_GB' => 'en'],
                'root' => 'homepage_single',
                'aliases' => ['single-alias.tld'],
            ],
        );

        $requestStack = $this->createMock('Symfony\Component\HttpFoundation\RequestStack');
        $requestStack->method('getMasterRequest')->willReturn($request);


        return new DomainConfiguration($requestStack, false, 'en', 'en', $this->getAdminRouteHelper(), $this->getEntityManager(), $hostMap);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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


1			<?php
2
3			namespace Kunstmaan\MultiDomainBundle\Tests\Helper;
4
5			use Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration;
6			use Kunstmaan\NodeBundle\Entity\Node;
7			use PHPUnit\Framework\TestCase;
8			use ReflectionClass;
9			use Symfony\Component\HttpFoundation\Request;
10			use Symfony\Component\HttpFoundation\Session\Session;
11			use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
12
13			class DomainConfigurationTest extends TestCase
14			{
15			/**
16			* @var Node
17			*/
18			protected $node;
19
20			public function testGetHostWithMultiLanguage()
21			{
22			$request = $this->getMultiLanguageRequest();
23			$object = $this->getDomainConfiguration($request);
24			$this->assertEquals('multilangdomain.tld', $object->getHost());
25			}
26
27			public function testGetHostWithSingleLanguage()
28			{
29			$request = $this->getSingleLanguageRequest();
30			$object = $this->getDomainConfiguration($request);
31			$this->assertEquals('singlelangdomain.tld', $object->getHost());
32			}
33
34			public function testGetHostWithAlias()
35			{
36			$request = $this->getAliasedRequest();
37			$object = $this->getDomainConfiguration($request);
38			$this->assertEquals('singlelangdomain.tld', $object->getHost());
39			}
40
41			/**
42			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::__construct
43			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getMasterRequest
44			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHost
45			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::hasHostOverride
46			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHostOverride
47			*/
48			public function testGetHostWithOverrideOnFrontend()
49			{
50			$request = $this->getRequestWithOverride('/frontend-uri');
51			$object = $this->getDomainConfiguration($request);
52			$this->assertEquals('multilangdomain.tld', $object->getHost());
53			}
54
55			/**
56			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::__construct
57			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getMasterRequest
58			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHost
59			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::hasHostOverride
60			* @covers \Kunstmaan\MultiDomainBundle\Helper\DomainConfiguration::getHostOverride
61			*/
62			public function testGetHostWithOverrideOnBackend()
63			{
64			$request = $this->getRequestWithOverride('/nl/admin/backend-uri');
65			$object = $this->getDomainConfiguration($request);
66			$this->assertEquals('singlelangdomain.tld', $object->getHost());
67			}
68
69			/**
70			* @throws \ReflectionException
71			*/
72			public function testHostOverrideReturnsNull()
73			{
74			$request = new Request();
75			$object = $this->getDomainConfiguration($request);
76			$reflection = new ReflectionClass(DomainConfiguration::class);
77			$method = $reflection->getMethod('getHostOverride');
78			$method->setAccessible(true);
79
80			$this->assertNull($method->invoke($object));
81			}
82
83			public function testGetHosts()
84			{
85			$request = $this->getSingleLanguageRequest();
86			$object = $this->getDomainConfiguration($request);
87			$this->assertEquals(array('multilangdomain.tld', 'singlelangdomain.tld'), $object->getHosts());
88			}
89
90			public function testGetDefaultLocale()
91			{
92			$request = $this->getSingleLanguageRequest();
93			$object = $this->getDomainConfiguration($request);
94			$this->assertEquals('en_GB', $object->getDefaultLocale());
95			}
96
97			public function testGetDefaultLocaleWithUnknownDomain()
98			{
99			$request = $this->getUnknownDomainRequest();
100			$object = $this->getDomainConfiguration($request);
101			$this->assertEquals('en', $object->getDefaultLocale());
102			}
103
104			public function testGetExtraDataWithoutDataSet()
105			{
106			$request = $this->getSingleLanguageRequest();
107			$object = $this->getDomainConfiguration($request);
108			$this->assertEquals(array(), $object->getExtraData());
109			}
110
111			public function testGetExtraDataWithDataSet()
112			{
113			$request = $this->getMultiLanguageRequest();
114			$object = $this->getDomainConfiguration($request);
115			$this->assertEquals(array('foo' => 'bar'), $object->getExtraData());
116			}
117
118			public function testGetRootNode()
119			{
120			$request = $this->getSingleLanguageRequest();
121			$object = $this->getDomainConfiguration($request);
122			$this->assertEquals($this->node, $object->getRootNode());
123			}
124
125			public function testGetRootNodeWithUnknown()
126			{
127			$request = $this->getUnknownDomainRequest();
128			$object = $this->getDomainConfiguration($request);
129			$this->assertNull($object->getRootNode());
130			}
131
132			public function testIsMultiDomainHostWithSingleLanguage()
133			{
134			$request = $this->getSingleLanguageRequest();
135			$object = $this->getDomainConfiguration($request);
136			$this->assertTrue($object->isMultiDomainHost());
137			}
138
139			public function testIsMultiDomainHostWithMultiLanguage()
140			{
141			$request = $this->getMultiLanguageRequest();
142			$object = $this->getDomainConfiguration($request);
143			$this->assertTrue($object->isMultiDomainHost());
144			}
145
146			public function testIsMultiDomainHostWithUnknown()
147			{
148			$request = $this->getUnknownDomainRequest();
149			$object = $this->getDomainConfiguration($request);
150			$this->assertFalse($object->isMultiDomainHost());
151			}
152
153			public function testIsMultiLanguageWithSingleLanguage()
154			{
155			$request = $this->getSingleLanguageRequest();
156			$object = $this->getDomainConfiguration($request);
157			$this->assertFalse($object->isMultiLanguage());
158			}
159
160			public function testIsMultiLanguageWithMultiLanguage()
161			{
162			$request = $this->getMultiLanguageRequest();
163			$object = $this->getDomainConfiguration($request);
164			$this->assertTrue($object->isMultiLanguage());
165			}
166
167			public function testIsMultiLanguageWithUnknown()
168			{
169			$request = $this->getUnknownDomainRequest();
170			$object = $this->getDomainConfiguration($request);
171			$this->assertFalse($object->isMultiLanguage());
172			}
173
174			public function testGetFrontendLocalesWithSingleLanguage()
175			{
176			$request = $this->getSingleLanguageRequest();
177			$object = $this->getDomainConfiguration($request);
178			$this->assertEquals(array('en'), $object->getFrontendLocales());
179			}
180
181			public function testGetHostBaseUrl()
182			{
183			$request = $this->getSingleLanguageRequest();
184			$object = $this->getDomainConfiguration($request);
185			$this->assertEquals('http://multilangdomain.tld', $object->getHostBaseUrl('multilangdomain.tld'));
186			}
187
188			public function testGetFullHost()
189			{
190			$request = $this->getSingleLanguageRequest();
191			$object = $this->getDomainConfiguration($request);
192			$this->assertNull($object->getFullHost('not-here.tld'));
193			}
194
195			public function testGetLocalesExtraData()
196			{
197			$request = $this->getSingleLanguageRequest();
198			$object = $this->getDomainConfiguration($request);
199			$data = $object->getLocalesExtraData();
200			$this->assertEmpty($data);
201			$request = $this->getMultiLanguageRequest();
202			$object = $this->getDomainConfiguration($request);
203			$data = $object->getLocalesExtraData();
204			$this->assertArrayHasKey('foo', $data);
205			}
206
207			public function testGetFullHostConfig()
208			{
209			$request = $this->getSingleLanguageRequest();
210			$object = $this->getDomainConfiguration($request);
211			$array = $object->getFullHostConfig();
212			$this->assertArrayHasKey('multilangdomain.tld', $array);
213			$this->assertArrayHasKey('singlelangdomain.tld', $array);
214			}
215
216			public function testHasHostSwitched()
217			{
218			$request = $this->getRequestWithOverride('/admin/somewhere');
219			$object = $this->getDomainConfiguration($request);
220			$this->assertTrue($object->hasHostSwitched());
221			}
222
223			public function testGetHostSwitched()
224			{
225			$request = $this->getRequestWithOverride('/admin/somewhere');
226			$object = $this->getDomainConfiguration($request);
227			$switched = $object->getHostSwitched();
228			$this->assertArrayHasKey('id', $switched);
229			$this->assertArrayHasKey('host', $switched);
230			$this->assertArrayHasKey('protocol', $switched);
231			$this->assertArrayHasKey('type', $switched);
232			}
233
234			public function testFullHostById()
235			{
236			$request = $this->getMultiLanguageRequest();
237			$object = $this->getDomainConfiguration($request);
238			$this->assertNull($object->getFullHostById(666));
239			$this->assertNotNull($object->getFullHostById(123));
240			}
241
242			public function testGetFrontendLocalesWithMultiLanguage()
243			{
244			$request = $this->getMultiLanguageRequest();
245			$object = $this->getDomainConfiguration($request);
246			$this->assertEquals(array('nl', 'fr', 'en'), $object->getFrontendLocales());
247			}
248
249			public function testGetFrontendLocalesWithUnknown()
250			{
251			$request = $this->getUnknownDomainRequest();
252			$object = $this->getDomainConfiguration($request);
253			$this->assertEquals(array('en'), $object->getFrontendLocales());
254			}
255
256			public function testGetBackendLocalesWithSingleLanguage()
257			{
258			$request = $this->getSingleLanguageRequest();
259			$object = $this->getDomainConfiguration($request);
260			$this->assertEquals(array('en_GB'), $object->getBackendLocales());
261			}
262
263			public function testGetBackendLocalesWithMultiLanguage()
264			{
265			$request = $this->getMultiLanguageRequest();
266			$object = $this->getDomainConfiguration($request);
267			$this->assertEquals(array('nl_BE', 'fr_BE', 'en_GB'), $object->getBackendLocales());
268			}
269
270			public function testGetBackendLocalesWithUnknown()
271			{
272			$request = $this->getUnknownDomainRequest();
273			$object = $this->getDomainConfiguration($request);
274			$this->assertEquals(array('en'), $object->getBackendLocales());
275			}
276
277			private function getEntityManager()
278			{
279			$em = $this->createMock('Doctrine\ORM\EntityManagerInterface');
280			$em
			0 ignored issues – show Bug introduced 2020-09-15 09:25 UTC by Report Bug Copy Issue Report The method `method()` does not seem to exist on `object<PHPUnit\Framework\MockObject\MockObject>`. 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...
281			->method('getRepository')
282			->with($this->equalTo(Node::class))
283			->willReturn($this->getNodeRepository());
284
285			return $em;
286			}
287
288			private function getAdminRouteHelper()
289			{
290			$adminRouteReturnValueMap = [
291			['/frontend-uri', false],
292			['/nl/admin/backend-uri', true],
293			['/admin/somewhere', true],
294			];
295
296			$adminRouteHelper = $this->getMockBuilder('Kunstmaan\AdminBundle\Helper\AdminRouteHelper')
297			->disableOriginalConstructor()
298			->getMock();
299			$adminRouteHelper
300			->expects($this->any())
301			->method('isAdminRoute')
302			->willReturnMap($adminRouteReturnValueMap);
303
304			return $adminRouteHelper;
305			}
306
307			private function getNodeRepository()
308			{
309			$this->node = $this->createMock('Kunstmaan\NodeBundle\Entity\Node');
			0 ignored issues – show Documentation Bug introduced 2019-02-01 15:08 UTC by Report Bug Copy Issue Report It seems like `$this->createMock('Kunst...eBundle\\Entity\\Node')` of type `object<PHPUnit\Framework\MockObject\MockObject>` is incompatible with the declared type `object<Kunstmaan\NodeBundle\Entity\Node>` of property `$node`. 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...
310
311			$repository = $this->getMockBuilder('Kunstmaan\NodeBundle\Repository\NodeRepository')
312			->disableOriginalConstructor()
313			->getMock();
314			$repository
			0 ignored issues – show Bug introduced 2020-09-15 09:25 UTC by Report Bug Copy Issue Report The method `method()` does not seem to exist on `object<PHPUnit\Framework\MockObject\MockObject>`. 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...
315			->method('getNodeByInternalName')
316			->willReturn($this->node);
317
318			return $repository;
319			}
320
321			private function getUnknownDomainRequest()
322			{
323			return Request::create('http://unknown.tld/');
324			}
325
326			private function getMultiLanguageRequest()
327			{
328			return Request::create('http://multilangdomain.tld/');
329			}
330
331			private function getSingleLanguageRequest()
332			{
333			return Request::create('http://singlelangdomain.tld/');
334			}
335
336			private function getAliasedRequest()
337			{
338			return Request::create('http://single-alias.tld/');
339			}
340
341			private function getRequestWithOverride($uri)
342			{
343			$session = new Session(new MockArraySessionStorage());
344			$session->set(DomainConfiguration::OVERRIDE_HOST, 'singlelangdomain.tld');
345			$session->set(DomainConfiguration::SWITCH_HOST, 'multilangdomain.tld');
346
347			$request = Request::create('http://multilangdomain.tld' . $uri);
348			$request->setSession($session);
349			$request->cookies->set($session->getName(), null);
350
351			return $request;
352			}
353
354			private function getDomainConfiguration($request)
355			{
356			$hostMap = array(
357			'multilangdomain.tld' => [
358			'id' => 456,
359			'host' => 'multilangdomain.tld',
360			'protocol' => 'http',
361			'type' => 'multi_lang',
362			'default_locale' => 'en_GB',
363			'locales' => ['nl' => 'nl_BE', 'fr' => 'fr_BE', 'en' => 'en_GB'],
364			'reverse_locales' => ['nl_BE' => 'nl', 'fr_BE' => 'fr', 'en_GB' => 'en'],
365			'root' => 'homepage_multi',
366			'aliases' => ['multi-alias.tld'],
367			'extra' => ['foo' => 'bar'],
368			'locales_extra' => ['foo' => 'bar'],
369			],
370			'singlelangdomain.tld' => [
371			'id' => 123,
372			'host' => 'singlelangdomain.tld',
373			'type' => 'single_lang',
374			'default_locale' => 'en_GB',
375			'locales' => ['en' => 'en_GB'],
376			'reverse_locales' => ['en_GB' => 'en'],
377			'root' => 'homepage_single',
378			'aliases' => ['single-alias.tld'],
379			],
380			);
381
382			$requestStack = $this->createMock('Symfony\Component\HttpFoundation\RequestStack');
383			$requestStack->method('getMasterRequest')->willReturn($request);
			0 ignored issues – show Bug introduced 2020-09-15 09:25 UTC by Report Bug Copy Issue Report The method `method()` does not seem to exist on `object<PHPUnit\Framework\MockObject\MockObject>`. 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...
384
385			return new DomainConfiguration($requestStack, false, 'en', 'en', $this->getAdminRouteHelper(), $this->getEntityManager(), $hostMap);
			0 ignored issues – show Documentation introduced 2019-09-02 18:26 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `object<Symfony\Component...rInterface>\|string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Documentation introduced 2019-09-02 18:26 UTC by Report Bug Copy Issue Report `$this->getAdminRouteHelper()` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `null\|object<Kunstmaan\Ad...elper\AdminRouteHelper>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Documentation introduced 2019-09-02 18:26 UTC by Report Bug Copy Issue Report `$this->getEntityManager()` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `null\|object<Doctrine\ORM\EntityManagerInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
386			}
387			}
388

Kunstmaan / KunstmaanBundlesCMS

DomainConfigurationTest::testGetDefaultLocale() A last analyzed 2020-11-05 13:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DomainConfigurationTest::testGetDefaultLocale() A
last analyzed 2020-11-05 13:23 UTC