MaskGeneratorTest::testGenerateLanguageMaskFromLanguageMap() - Code Metrics - Inspection of "TMP in-memory cache" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — in-memory-cache2 ( de4787 )

by André

created 2019-02-15 12:15 UTC

testGenerateLanguageMaskFromLanguageMap() A

↳ Parent: MaskGeneratorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	2
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0

<?php

/**
 * File contains: eZ\Publish\Core\Persistence\Legacy\Tests\Content\Language\MaskGeneratorTest class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Persistence\Legacy\Tests\Content\Language;

use eZ\Publish\Core\Persistence\Legacy\Tests\Content\LanguageAwareTestCase;
use eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator;
use eZ\Publish\SPI\Persistence\Content\Language;
use eZ\Publish\SPI\Persistence\Content\Language\Handler as LanguageHandler;

/**
 * Test case for Language MaskGenerator.
 */
class MaskGeneratorTest extends LanguageAwareTestCase
{
    /**
     * @param array $languages
     * @param int $expectedMask
     *
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageMaskFromLanguageMap
     * @dataProvider getLanguageMaskData
     */
    public function testGenerateLanguageMaskFromLanguageMap(array $languages, $expectedMask)
    {
        $generator = $this->getMaskGenerator();

        $this->assertSame(
            $expectedMask,
            $generator->generateLanguageMaskFromLanguageMap($languages)
        );
    }

    /**
     * @param array $languages
     * @param int $expectedMask
     *
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageMaskFromLanguageCodes
     * @dataProvider getLanguageMaskData
     */
    public function testGenerateLanguageMaskFromLanguagesCodes(array $languages, $expectedMask)
    {
        $generator = $this->getMaskGenerator();

        $isAlwaysAvailable = array_filter(
            $languages,
            function ($key) {
                return $key === 'always-available';
            },
            ARRAY_FILTER_USE_KEY
        );

        $languageCodes = array_diff($languages, $isAlwaysAvailable);

        $this->assertSame(
            $expectedMask,
            $generator->generateLanguageMaskFromLanguageCodes(array_keys($languageCodes), count($isAlwaysAvailable) > 0)
        );
    }

    /**
     * Returns test data for {@link testGenerateLanguageMaskFromLanguageMap()} and {@link testGenerateLanguageMaskFromLanguagesCodes()}.
     *
     * @return array
     */
    public static function getLanguageMaskData()
    {
        return array(
            'error' => array(
                array(),
                0,
            ),
            'single_lang' => array(
                array('eng-GB' => true),
                4,
            ),
            'multi_lang' => array(
                array('eng-US' => true, 'eng-GB' => true),
                6,
            ),
            'always_available' => array(
                array('always-available' => 'eng-US', 'eng-US' => true),
                3,
            ),
            'full' => array(
                array('always-available' => 'eng-US', 'eng-US' => true, 'eng-GB' => true),
                7,
            ),
        );
    }

    /**
     * @param string $languageCode
     * @param bool $alwaysAvailable
     * @param int $expectedIndicator
     *
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageIndicator
     * @dataProvider getLanguageIndicatorData
     */
    public function testGenerateLanguageIndicator(
        $languageCode,
        $alwaysAvailable,
        $expectedIndicator
    ) {
        $generator = $this->getMaskGenerator();

        $this->assertSame(
            $expectedIndicator,
            $generator->generateLanguageIndicator($languageCode, $alwaysAvailable)
        );
    }

    /**
     * Returns test data for {@link testGenerateLanguageIndicator()}.
     *
     * @return array
     */
    public static function getLanguageIndicatorData()
    {
        return array(
            'not_available' => array(
                'eng-GB',
                false,
                4,
            ),
            'always_available' => array(
                'eng-US',
                true,
                3,
            ),
        );
    }

    /**
     * @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
     */
    public function testIsLanguageAlwaysAvailable()
    {
        $generator = $this->getMaskGenerator();

        $this->assertTrue(
            $generator->isLanguageAlwaysAvailable(
                'eng-GB',
                array(
                    'always-available' => 'eng-GB',
                    'eng-GB' => 'lala',
                )
            )
        );
    }

    /**
     * @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
     */
    public function testIsLanguageAlwaysAvailableOtherLanguage()
    {
        $generator = $this->getMaskGenerator();

        $this->assertFalse(
            $generator->isLanguageAlwaysAvailable(
                'eng-GB',
                array(
                    'always-available' => 'eng-US',
                    'eng-GB' => 'lala',
                )
            )
        );
    }

    /**
     * @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
     */
    public function testIsLanguageAlwaysAvailableNoDefault()
    {
        $generator = $this->getMaskGenerator();

        $this->assertFalse(
            $generator->isLanguageAlwaysAvailable(
                'eng-GB',
                array(
                    'eng-GB' => 'lala',
                )
            )
        );
    }

    /**
     * @param int $languageMask
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param bool $expectedResult
     *
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isAlwaysAvailable
     * @dataProvider isAlwaysAvailableProvider
     */
    public function testIsAlwaysAvailable($langMask, $expectedResult)
    {
        $generator = $this->getMaskGenerator();
        self::assertSame($expectedResult, $generator->isAlwaysAvailable($langMask));
    }

    /**
     * Returns test data for {@link testIsAlwaysAvailable()}.
     *
     * @return array
     */
    public function isAlwaysAvailableProvider()
    {
        return array(
            array(2, false),
            array(3, true),
            array(62, false),
            array(14, false),
            array(15, true),
        );
    }

    /**
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::removeAlwaysAvailableFlag
     * @dataProvider removeAlwaysAvailableFlagProvider
     */
    public function testRemoveAlwaysAvailableFlag($langMask, $expectedResult)
    {
        $generator = $this->getMaskGenerator();
        self::assertSame($expectedResult, $generator->removeAlwaysAvailableFlag($langMask));
    }

    /**
     * Returns test data for {@link testRemoveAlwaysAvailableFlag}.
     *
     * @return array
     */
    public function removeAlwaysAvailableFlagProvider()
    {
        return array(
            array(3, 2),
            array(7, 6),
            array(14, 14),
            array(62, 62),
        );
    }

    /**
     * @param int $langMask
     * @param array $expectedResult
     *
     * @covers       \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::extractLanguageIdsFromMask
     * @dataProvider languageIdsFromMaskProvider
     */
    public function testExtractLanguageIdsFromMask($langMask, array $expectedResult)
    {
        $generator = $this->getMaskGenerator();
        self::assertSame($expectedResult, $generator->extractLanguageIdsFromMask($langMask));
    }

    /**
     * Returns test data for {@link testExtractLanguageIdsFromMask}.
     *
     * @return array
     */
    public function languageIdsFromMaskProvider()
    {
        return array(
            array(
                2,
                array(2),
            ),
            array(
                15,
                array(2, 4, 8),
            ),
            array(
                62,
                array(2, 4, 8, 16, 32),
            ),
        );
    }

    /**
     * Returns the mask generator to test.
     *
     * @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator
     */
    protected function getMaskGenerator()
    {
        return new MaskGenerator($this->getLanguageHandler());

    }

    /**
     * Returns a language handler mock.
     *
     * @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\Handler
     */
    protected function getLanguageHandler()
    {
        if (!isset($this->languageHandler)) {
            $this->languageHandler = $this->createMock(LanguageHandler::class);

            $this->languageHandler->expects($this->any())
                                  ->method('loadByLanguageCode')
                                  ->will(
                                      $this->returnCallback(
                                          function ($languageCode) {
                                              switch ($languageCode) {
                                                  case 'eng-US':
                                                      return new Language(
                                                          array(
                                                              'id' => 2,
                                                              'languageCode' => 'eng-US',
                                                              'name' => 'US english',
                                                          )
                                                      );
                                                  case 'eng-GB':
                                                      return new Language(
                                                          array(
                                                              'id' => 4,
                                                              'languageCode' => 'eng-GB',
                                                              'name' => 'British english',
                                                          )
                                                      );
                                              }
                                          }
                                      )
                                  );
        }

        return $this->languageHandler;

    }
}


1			<?php
2
3			/**
4			* File contains: eZ\Publish\Core\Persistence\Legacy\Tests\Content\Language\MaskGeneratorTest class.
5			*
6			* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7			* @license For full copyright and license information view LICENSE file distributed with this source code.
8			*/
9			namespace eZ\Publish\Core\Persistence\Legacy\Tests\Content\Language;
10
11			use eZ\Publish\Core\Persistence\Legacy\Tests\Content\LanguageAwareTestCase;
12			use eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator;
13			use eZ\Publish\SPI\Persistence\Content\Language;
14			use eZ\Publish\SPI\Persistence\Content\Language\Handler as LanguageHandler;
15
16			/**
17			* Test case for Language MaskGenerator.
18			*/
19			class MaskGeneratorTest extends LanguageAwareTestCase
20			{
21			/**
22			* @param array $languages
23			* @param int $expectedMask
24			*
25			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageMaskFromLanguageMap
26			* @dataProvider getLanguageMaskData
27			*/
28			public function testGenerateLanguageMaskFromLanguageMap(array $languages, $expectedMask)
29			{
30			$generator = $this->getMaskGenerator();
31
32			$this->assertSame(
33			$expectedMask,
34			$generator->generateLanguageMaskFromLanguageMap($languages)
35			);
36			}
37
38			/**
39			* @param array $languages
40			* @param int $expectedMask
41			*
42			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageMaskFromLanguageCodes
43			* @dataProvider getLanguageMaskData
44			*/
45			public function testGenerateLanguageMaskFromLanguagesCodes(array $languages, $expectedMask)
46			{
47			$generator = $this->getMaskGenerator();
48
49			$isAlwaysAvailable = array_filter(
50			$languages,
51			function ($key) {
52			return $key === 'always-available';
53			},
54			ARRAY_FILTER_USE_KEY
55			);
56
57			$languageCodes = array_diff($languages, $isAlwaysAvailable);
58
59			$this->assertSame(
60			$expectedMask,
61			$generator->generateLanguageMaskFromLanguageCodes(array_keys($languageCodes), count($isAlwaysAvailable) > 0)
62			);
63			}
64
65			/**
66			* Returns test data for {@link testGenerateLanguageMaskFromLanguageMap()} and {@link testGenerateLanguageMaskFromLanguagesCodes()}.
67			*
68			* @return array
69			*/
70			public static function getLanguageMaskData()
71			{
72			return array(
73			'error' => array(
74			array(),
75			0,
76			),
77			'single_lang' => array(
78			array('eng-GB' => true),
79			4,
80			),
81			'multi_lang' => array(
82			array('eng-US' => true, 'eng-GB' => true),
83			6,
84			),
85			'always_available' => array(
86			array('always-available' => 'eng-US', 'eng-US' => true),
87			3,
88			),
89			'full' => array(
90			array('always-available' => 'eng-US', 'eng-US' => true, 'eng-GB' => true),
91			7,
92			),
93			);
94			}
95
96			/**
97			* @param string $languageCode
98			* @param bool $alwaysAvailable
99			* @param int $expectedIndicator
100			*
101			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageIndicator
102			* @dataProvider getLanguageIndicatorData
103			*/
104			public function testGenerateLanguageIndicator(
105			$languageCode,
106			$alwaysAvailable,
107			$expectedIndicator
108			) {
109			$generator = $this->getMaskGenerator();
110
111			$this->assertSame(
112			$expectedIndicator,
113			$generator->generateLanguageIndicator($languageCode, $alwaysAvailable)
114			);
115			}
116
117			/**
118			* Returns test data for {@link testGenerateLanguageIndicator()}.
119			*
120			* @return array
121			*/
122			public static function getLanguageIndicatorData()
123			{
124			return array(
125			'not_available' => array(
126			'eng-GB',
127			false,
128			4,
129			),
130			'always_available' => array(
131			'eng-US',
132			true,
133			3,
134			),
135			);
136			}
137
138			/**
139			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
140			*/
141			public function testIsLanguageAlwaysAvailable()
142			{
143			$generator = $this->getMaskGenerator();
144
145			$this->assertTrue(
146			$generator->isLanguageAlwaysAvailable(
147			'eng-GB',
148			array(
149			'always-available' => 'eng-GB',
150			'eng-GB' => 'lala',
151			)
152			)
153			);
154			}
155
156			/**
157			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
158			*/
159			public function testIsLanguageAlwaysAvailableOtherLanguage()
160			{
161			$generator = $this->getMaskGenerator();
162
163			$this->assertFalse(
164			$generator->isLanguageAlwaysAvailable(
165			'eng-GB',
166			array(
167			'always-available' => 'eng-US',
168			'eng-GB' => 'lala',
169			)
170			)
171			);
172			}
173
174			/**
175			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
176			*/
177			public function testIsLanguageAlwaysAvailableNoDefault()
178			{
179			$generator = $this->getMaskGenerator();
180
181			$this->assertFalse(
182			$generator->isLanguageAlwaysAvailable(
183			'eng-GB',
184			array(
185			'eng-GB' => 'lala',
186			)
187			)
188			);
189			}
190
191			/**
192			* @param int $languageMask
			0 ignored issues – show Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report There is no parameter named `$languageMask`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
193			* @param bool $expectedResult
194			*
195			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isAlwaysAvailable
196			* @dataProvider isAlwaysAvailableProvider
197			*/
198			public function testIsAlwaysAvailable($langMask, $expectedResult)
199			{
200			$generator = $this->getMaskGenerator();
201			self::assertSame($expectedResult, $generator->isAlwaysAvailable($langMask));
202			}
203
204			/**
205			* Returns test data for {@link testIsAlwaysAvailable()}.
206			*
207			* @return array
208			*/
209			public function isAlwaysAvailableProvider()
210			{
211			return array(
212			array(2, false),
213			array(3, true),
214			array(62, false),
215			array(14, false),
216			array(15, true),
217			);
218			}
219
220			/**
221			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::removeAlwaysAvailableFlag
222			* @dataProvider removeAlwaysAvailableFlagProvider
223			*/
224			public function testRemoveAlwaysAvailableFlag($langMask, $expectedResult)
225			{
226			$generator = $this->getMaskGenerator();
227			self::assertSame($expectedResult, $generator->removeAlwaysAvailableFlag($langMask));
228			}
229
230			/**
231			* Returns test data for {@link testRemoveAlwaysAvailableFlag}.
232			*
233			* @return array
234			*/
235			public function removeAlwaysAvailableFlagProvider()
236			{
237			return array(
238			array(3, 2),
239			array(7, 6),
240			array(14, 14),
241			array(62, 62),
242			);
243			}
244
245			/**
246			* @param int $langMask
247			* @param array $expectedResult
248			*
249			* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::extractLanguageIdsFromMask
250			* @dataProvider languageIdsFromMaskProvider
251			*/
252			public function testExtractLanguageIdsFromMask($langMask, array $expectedResult)
253			{
254			$generator = $this->getMaskGenerator();
255			self::assertSame($expectedResult, $generator->extractLanguageIdsFromMask($langMask));
256			}
257
258			/**
259			* Returns test data for {@link testExtractLanguageIdsFromMask}.
260			*
261			* @return array
262			*/
263			public function languageIdsFromMaskProvider()
264			{
265			return array(
266			array(
267			2,
268			array(2),
269			),
270			array(
271			15,
272			array(2, 4, 8),
273			),
274			array(
275			62,
276			array(2, 4, 8, 16, 32),
277			),
278			);
279			}
280
281			/**
282			* Returns the mask generator to test.
283			*
284			* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator
285			*/
286			protected function getMaskGenerator()
287			{
288			return new MaskGenerator($this->getLanguageHandler());
			0 ignored issues – show Bug introduced 2018-01-16 12:36 UTC by Report Bug Copy Issue Report It seems like `$this->getLanguageHandler()` targeting `eZ\Publish\Core\Persiste...t::getLanguageHandler()` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `eZ\Publish\Core\Persiste...enerator::__construct()` does only seem to accept `object<eZ\Publish\SPI\Pe...ntent\Language\Handler>`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
289			}
290
291			/**
292			* Returns a language handler mock.
293			*
294			* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\Handler
295			*/
296			protected function getLanguageHandler()
297			{
298			if (!isset($this->languageHandler)) {
299			$this->languageHandler = $this->createMock(LanguageHandler::class);
			0 ignored issues – show Documentation Bug introduced 2018-01-16 12:36 UTC by Report Bug Copy Issue Report It seems like `$this->createMock(\eZ\Pu...anguage\Handler::class)` of type `object<PHPUnit\Framework\MockObject\MockObject>` is incompatible with the declared type `object<eZ\Publish\Core\P...CachingLanguageHandler>` of property `$languageHandler`. 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...
300			$this->languageHandler->expects($this->any())
301			->method('loadByLanguageCode')
302			->will(
303			$this->returnCallback(
304			function ($languageCode) {
305			switch ($languageCode) {
306			case 'eng-US':
307			return new Language(
308			array(
309			'id' => 2,
310			'languageCode' => 'eng-US',
311			'name' => 'US english',
312			)
313			);
314			case 'eng-GB':
315			return new Language(
316			array(
317			'id' => 4,
318			'languageCode' => 'eng-GB',
319			'name' => 'British english',
320			)
321			);
322			}
323			}
324			)
325			);
326			}
327
328			return $this->languageHandler;
			0 ignored issues – show Bug Compatibility introduced 2018-01-16 12:36 UTC by Report Bug Copy Issue Report The expression `$this->languageHandler;` of type `PHPUnit\Framework\MockOb...\CachingLanguageHandler` adds the type `PHPUnit\Framework\MockObject\MockObject` to the return on line 328 which is incompatible with the return type of the parent method `eZ\Publish\Core\Persiste...ase::getLanguageHandler` of type `eZ\Publish\Core\Persiste...\CachingLanguageHandler`. Loading history...
329			}
330			}
331

ezsystems / ezpublish-kernel

Push — in-memory-cache2 ( de4787 )

testGenerateLanguageMaskFromLanguageMap() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like