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

Completed

Push — EZP-30006 ( 77280a )

by André

created 2019-01-14 07:46 UTC

MaskGeneratorTest::testRemoveAlwaysAvailableFlag() 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	5
rs	10
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();


        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 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($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::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
50		if (isset($languages['always-available'])) {
51		$isAlwaysAvailable = true;
52		unset($languages['always-available']);
53		} else {
54		$isAlwaysAvailable = false;
55		}
56
57		$this->assertSame(
58		$expectedMask,
59		$generator->generateLanguageMaskFromLanguageCodes(array_keys($languages), $isAlwaysAvailable)
60		);
61		}
62
63		/**
64		* Returns test data for {@link testGenerateLanguageMaskFromLanguageMap()} and {@link testGenerateLanguageMaskFromLanguagesCodes()}.
65		*
66		* @return array
67		*/
68		public static function getLanguageMaskData()
69		{
70		return array(
71		'error' => array(
72		array(),
73		0,
74		),
75		'single_lang' => array(
76		array('eng-GB' => true),
77		4,
78		),
79		'multi_lang' => array(
80		array('eng-US' => true, 'eng-GB' => true),
81		6,
82		),
83		'always_available' => array(
84		array('always-available' => 'eng-US', 'eng-US' => true),
85		3,
86		),
87		'full' => array(
88		array('always-available' => 'eng-US', 'eng-US' => true, 'eng-GB' => true),
89		7,
90		),
91		);
92		}
93
94		/**
95		* @param string $languageCode
96		* @param bool $alwaysAvailable
97		* @param int $expectedIndicator
98		*
99		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::generateLanguageIndicator
100		* @dataProvider getLanguageIndicatorData
101		*/
102		public function testGenerateLanguageIndicator(
103		$languageCode,
104		$alwaysAvailable,
105		$expectedIndicator
106		) {
107		$generator = $this->getMaskGenerator();
108
109		$this->assertSame(
110		$expectedIndicator,
111		$generator->generateLanguageIndicator($languageCode, $alwaysAvailable)
112		);
113		}
114
115		/**
116		* Returns test data for {@link testGenerateLanguageIndicator()}.
117		*
118		* @return array
119		*/
120		public static function getLanguageIndicatorData()
121		{
122		return array(
123		'not_available' => array(
124		'eng-GB',
125		false,
126		4,
127		),
128		'always_available' => array(
129		'eng-US',
130		true,
131		3,
132		),
133		);
134		}
135
136		/**
137		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
138		*/
139		public function testIsLanguageAlwaysAvailable()
140		{
141		$generator = $this->getMaskGenerator();
142
143		$this->assertTrue(
144		$generator->isLanguageAlwaysAvailable(
145		'eng-GB',
146		array(
147		'always-available' => 'eng-GB',
148		'eng-GB' => 'lala',
149		)
150		)
151		);
152		}
153
154		/**
155		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
156		*/
157		public function testIsLanguageAlwaysAvailableOtherLanguage()
158		{
159		$generator = $this->getMaskGenerator();
160
161		$this->assertFalse(
162		$generator->isLanguageAlwaysAvailable(
163		'eng-GB',
164		array(
165		'always-available' => 'eng-US',
166		'eng-GB' => 'lala',
167		)
168		)
169		);
170		}
171
172		/**
173		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isLanguageAlwaysAvailable
174		*/
175		public function testIsLanguageAlwaysAvailableNoDefault()
176		{
177		$generator = $this->getMaskGenerator();
178
179		$this->assertFalse(
180		$generator->isLanguageAlwaysAvailable(
181		'eng-GB',
182		array(
183		'eng-GB' => 'lala',
184		)
185		)
186		);
187		}
188
189		/**
190		* @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...
191		* @param bool $expectedResult
192		*
193		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::isAlwaysAvailable
194		* @dataProvider isAlwaysAvailableProvider
195		*/
196		public function testIsAlwaysAvailable($langMask, $expectedResult)
197		{
198		$generator = $this->getMaskGenerator();
199		self::assertSame($expectedResult, $generator->isAlwaysAvailable($langMask));
200		}
201
202		/**
203		* Returns test data for {@link testIsAlwaysAvailable()}.
204		*
205		* @return array
206		*/
207		public function isAlwaysAvailableProvider()
208		{
209		return array(
210		array(2, false),
211		array(3, true),
212		array(62, false),
213		array(14, false),
214		array(15, true),
215		);
216		}
217
218		/**
219		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::removeAlwaysAvailableFlag
220		* @dataProvider removeAlwaysAvailableFlagProvider
221		*/
222		public function testRemoveAlwaysAvailableFlag($langMask, $expectedResult)
223		{
224		$generator = $this->getMaskGenerator();
225		self::assertSame($expectedResult, $generator->removeAlwaysAvailableFlag($langMask));
226		}
227
228		/**
229		* Returns test data for {@link testRemoveAlwaysAvailableFlag}.
230		*
231		* @return array
232		*/
233		public function removeAlwaysAvailableFlagProvider()
234		{
235		return array(
236		array(3, 2),
237		array(7, 6),
238		array(14, 14),
239		array(62, 62),
240		);
241		}
242
243		/**
244		* @param int $langMask
245		* @param array $expectedResult
246		*
247		* @covers \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator::extractLanguageIdsFromMask
248		* @dataProvider languageIdsFromMaskProvider
249		*/
250		public function testExtractLanguageIdsFromMask($langMask, array $expectedResult)
251		{
252		$generator = $this->getMaskGenerator();
253		self::assertSame($expectedResult, $generator->extractLanguageIdsFromMask($langMask));
254		}
255
256		/**
257		* Returns test data for {@link testExtractLanguageIdsFromMask}.
258		*
259		* @return array
260		*/
261		public function languageIdsFromMaskProvider()
262		{
263		return array(
264		array(
265		2,
266		array(2),
267		),
268		array(
269		15,
270		array(2, 4, 8),
271		),
272		array(
273		62,
274		array(2, 4, 8, 16, 32),
275		),
276		);
277		}
278
279		/**
280		* Returns the mask generator to test.
281		*
282		* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\MaskGenerator
283		*/
284		protected function getMaskGenerator()
285		{
286		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...
287		}
288
289		/**
290		* Returns a language handler mock.
291		*
292		* @return \eZ\Publish\Core\Persistence\Legacy\Content\Language\Handler
293		*/
294		protected function getLanguageHandler()
295		{
296		if (!isset($this->languageHandler)) {
297		$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...
298		$this->languageHandler->expects($this->any())
299		->method($this->anything())// loadByLanguageCode && loadListByLanguageCodes
300		->will(
301		$this->returnCallback(
302		function ($languageCodes) {
303		if (is_string($languageCodes)){
304		$language = $languageCodes;
305		$languageCodes = [$language];
306		}
307
308		$languages = [];
309	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...
310		$languages['eng-US'] = new Language(
311		[
312		'id' => 2,
313		'languageCode' => 'eng-US',
314		'name' => 'US english',
315		]
316		);
317		}
318
319	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...
320		$languages['eng-GB'] = new Language(
321		[
322		'id' => 4,
323		'languageCode' => 'eng-GB',
324		'name' => 'British english',
325		]
326		);
327		}
328
329		return isset($language) ? $languages[$language] : $languages;
330		}
331		)
332		);
333		}
334
335		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 335 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...
336		}
337		}
338

ezsystems / ezpublish-kernel

Push — EZP-30006 ( 77280a )

MaskGeneratorTest::testRemoveAlwaysAvailableFlag() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like