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

Completed

Push — EZP-30006 ( ccc002...bed72d )

by André

created 2019-02-04 18:24 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::generateLanguageMask
     * @dataProvider getLanguageMaskData
     */
    public function testGenerateLanguageMask(array $languages, $expectedMask)
    {
        $generator = $this->getMaskGenerator();

        $this->assertSame(
            $expectedMask,
            $generator->generateLanguageMask($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();

        if (isset($languages['always-available'])) {
            $isAlwaysAvailable = true;
            unset($languages['always-available']);
        } else {
            $isAlwaysAvailable = false;
        }

        $this->assertSame(
            $expectedMask,
            $generator->generateLanguageMaskFromLanguageCodes(array_keys($languages), $isAlwaysAvailable)
        );
    }

    /**
     * Returns test data for {@link testGenerateLanguageMask()} 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($this->anything())// loadByLanguageCode && loadListByLanguageCodes
                                  ->will(
                                      $this->returnCallback(
                                          function ($languageCodes) {
                                              if (is_string($languageCodes)) {
                                                  $language = $languageCodes;
                                                  $languageCodes = [$language];
                                              }

                                              $languages = [];
                                              if (in_array('eng-US', $languageCodes, true)) {

                                                  $languages['eng-US'] = new Language(
                                                      [
                                                          'id' => 2,
                                                          'languageCode' => 'eng-US',
                                                          'name' => 'US english',
                                                      ]
                                                  );
                                              }

                                              if (in_array('eng-GB', $languageCodes, true)) {

                                                  $languages['eng-GB'] = new Language(
                                                       [
                                                           'id' => 4,
                                                           'languageCode' => 'eng-GB',
                                                           'name' => 'British english',
                                                       ]
                                                   );
                                              }

                                              return isset($language) ? $languages[$language] : $languages;
                                          }
                                      )
                                  );
        }

        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::generateLanguageMask
26		* @dataProvider getLanguageMaskData
27		*/
28		public function testGenerateLanguageMask(array $languages, $expectedMask)
29		{
30		$generator = $this->getMaskGenerator();
31
32		$this->assertSame(
33		$expectedMask,
34		$generator->generateLanguageMask($languages)
		0 ignored issues – show Deprecated Code introduced 2019-02-04 18:44 UTC by Report Bug Copy Issue Report The method `eZ\Publish\Core\Persiste...:generateLanguageMask()` has been deprecated with message: Move towards using {@see generateLanguageMaskFromLanguageCodes()} or the other generate* methods. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
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		if (isset($languages['always-available'])) {
50		$isAlwaysAvailable = true;
51		unset($languages['always-available']);
52		} else {
53		$isAlwaysAvailable = false;
54		}
55
56		$this->assertSame(
57		$expectedMask,
58		$generator->generateLanguageMaskFromLanguageCodes(array_keys($languages), $isAlwaysAvailable)
59		);
60		}
61
62		/**
63		* Returns test data for {@link testGenerateLanguageMask()} and {@link testGenerateLanguageMaskFromLanguagesCodes()}.
64		*
65		* @return array
66		*/
67		public static function getLanguageMaskData()
68		{
69		return array(
70		'error' => array(
71		array(),
72		0,
73		),
74		'single_lang' => array(
75		array('eng-GB' => true),
76		4,
77		),
78		'multi_lang' => array(
79		array('eng-US' => true, 'eng-GB' => true),
80		6,
81		),
82		'always_available' => array(
83		array('always-available' => 'eng-US', 'eng-US' => true),
84		3,
85		),
86		'full' => array(
87		array('always-available' => 'eng-US', 'eng-US' => true, 'eng-GB' => true),
88		7,
89		),
90		);
91		}
92
93		/**
94		* @param string $languageCode
95		* @param bool $alwaysAvailable
96		* @param int $expectedIndicator
97		*
98		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageIndicator
99		* @dataProvider getLanguageIndicatorData
100		*/
101		public function testGenerateLanguageIndicator(
102		$languageCode,
103		$alwaysAvailable,
104		$expectedIndicator
105		) {
106		$generator = $this->getMaskGenerator();
107
108		$this->assertSame(
109		$expectedIndicator,
110		$generator->generateLanguageIndicator($languageCode, $alwaysAvailable)
111		);
112		}
113
114		/**
115		* Returns test data for {@link testGenerateLanguageIndicator()}.
116		*
117		* @return array
118		*/
119		public static function getLanguageIndicatorData()
120		{
121		return array(
122		'not_available' => array(
123		'eng-GB',
124		false,
125		4,
126		),
127		'always_available' => array(
128		'eng-US',
129		true,
130		3,
131		),
132		);
133		}
134
135		/**
136		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
137		*/
138		public function testIsLanguageAlwaysAvailable()
139		{
140		$generator = $this->getMaskGenerator();
141
142		$this->assertTrue(
143		$generator->isLanguageAlwaysAvailable(
144		'eng-GB',
145		array(
146		'always-available' => 'eng-GB',
147		'eng-GB' => 'lala',
148		)
149		)
150		);
151		}
152
153		/**
154		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
155		*/
156		public function testIsLanguageAlwaysAvailableOtherLanguage()
157		{
158		$generator = $this->getMaskGenerator();
159
160		$this->assertFalse(
161		$generator->isLanguageAlwaysAvailable(
162		'eng-GB',
163		array(
164		'always-available' => 'eng-US',
165		'eng-GB' => 'lala',
166		)
167		)
168		);
169		}
170
171		/**
172		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
173		*/
174		public function testIsLanguageAlwaysAvailableNoDefault()
175		{
176		$generator = $this->getMaskGenerator();
177
178		$this->assertFalse(
179		$generator->isLanguageAlwaysAvailable(
180		'eng-GB',
181		array(
182		'eng-GB' => 'lala',
183		)
184		)
185		);
186		}
187
188		/**
189		* @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...
190		* @param bool $expectedResult
191		*
192		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isAlwaysAvailable
193		* @dataProvider isAlwaysAvailableProvider
194		*/
195		public function testIsAlwaysAvailable($langMask, $expectedResult)
196		{
197		$generator = $this->getMaskGenerator();
198		self::assertSame($expectedResult, $generator->isAlwaysAvailable($langMask));
199		}
200
201		/**
202		* Returns test data for {@link testIsAlwaysAvailable()}.
203		*
204		* @return array
205		*/
206		public function isAlwaysAvailableProvider()
207		{
208		return array(
209		array(2, false),
210		array(3, true),
211		array(62, false),
212		array(14, false),
213		array(15, true),
214		);
215		}
216
217		/**
218		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::removeAlwaysAvailableFlag
219		* @dataProvider removeAlwaysAvailableFlagProvider
220		*/
221		public function testRemoveAlwaysAvailableFlag($langMask, $expectedResult)
222		{
223		$generator = $this->getMaskGenerator();
224		self::assertSame($expectedResult, $generator->removeAlwaysAvailableFlag($langMask));
225		}
226
227		/**
228		* Returns test data for {@link testRemoveAlwaysAvailableFlag}.
229		*
230		* @return array
231		*/
232		public function removeAlwaysAvailableFlagProvider()
233		{
234		return array(
235		array(3, 2),
236		array(7, 6),
237		array(14, 14),
238		array(62, 62),
239		);
240		}
241
242		/**
243		* @param int $langMask
244		* @param array $expectedResult
245		*
246		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::extractLanguageIdsFromMask
247		* @dataProvider languageIdsFromMaskProvider
248		*/
249		public function testExtractLanguageIdsFromMask($langMask, array $expectedResult)
250		{
251		$generator = $this->getMaskGenerator();
252		self::assertSame($expectedResult, $generator->extractLanguageIdsFromMask($langMask));
253		}
254
255		/**
256		* Returns test data for {@link testExtractLanguageIdsFromMask}.
257		*
258		* @return array
259		*/
260		public function languageIdsFromMaskProvider()
261		{
262		return array(
263		array(
264		2,
265		array(2),
266		),
267		array(
268		15,
269		array(2, 4, 8),
270		),
271		array(
272		62,
273		array(2, 4, 8, 16, 32),
274		),
275		);
276		}
277
278		/**
279		* Returns the mask generator to test.
280		*
281		* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator
282		*/
283		protected function getMaskGenerator()
284		{
285		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...
286		}
287
288		/**
289		* Returns a language handler mock.
290		*
291		* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\Handler
292		*/
293		protected function getLanguageHandler()
294		{
295		if (!isset($this->languageHandler)) {
296		$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...
297		$this->languageHandler->expects($this->any())
298		->method($this->anything())// loadByLanguageCode && loadListByLanguageCodes
299		->will(
300		$this->returnCallback(
301		function ($languageCodes) {
302		if (is_string($languageCodes)) {
303		$language = $languageCodes;
304		$languageCodes = [$language];
305		}
306
307		$languages = [];
308	View Code Duplication	if (in_array('eng-US', $languageCodes, true)) {
		0 ignored issues – show Duplication introduced 2019-01-14 08:05 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
309		$languages['eng-US'] = new Language(
310		[
311		'id' => 2,
312		'languageCode' => 'eng-US',
313		'name' => 'US english',
314		]
315		);
316		}
317
318	View Code Duplication	if (in_array('eng-GB', $languageCodes, true)) {
		0 ignored issues – show Duplication introduced 2019-01-14 08:05 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
319		$languages['eng-GB'] = new Language(
320		[
321		'id' => 4,
322		'languageCode' => 'eng-GB',
323		'name' => 'British english',
324		]
325		);
326		}
327
328		return isset($language) ? $languages[$language] : $languages;
329		}
330		)
331		);
332		}
333
334		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 334 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...
335		}
336		}
337

ezsystems / ezpublish-kernel

Push — EZP-30006 ( ccc002...bed72d )

testGenerateLanguageMaskFromLanguageMap() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like