MaskGeneratorTest - Code Metrics - Inspection of "EZP-29764: As a Developer I want to update single..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 05264e...b99b30 )

by Łukasz

created 2018-12-14 15:15 UTC

MaskGeneratorTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	312
Duplicated Lines	2.88 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
dl	9
loc	312
rs	10
c	0
b	0
f	0
wmc	19
lcom	1
cbo	5

16 Methods

Rating	Name	Duplication	Size	Complexity
A	testGenerateLanguageMask()	0	9	1
A	testGenerateLanguageMaskFromLanguagesCodes()	0	19	1
A	getLanguageMaskData()	0	25	1
A	testGenerateLanguageIndicator()	0	12	1
A	getLanguageIndicatorData()	0	15	1
A	testIsLanguageAlwaysAvailable()	0	14	1
A	testIsLanguageAlwaysAvailableOtherLanguage()	0	14	1
A	testIsLanguageAlwaysAvailableNoDefault()	0	13	1
A	testIsAlwaysAvailable()	0	5	1
A	isAlwaysAvailableProvider()	0	10	1
A	testRemoveAlwaysAvailableFlag()	0	5	1
A	removeAlwaysAvailableFlagProvider()	9	9	1
A	testExtractLanguageIdsFromMask()	0	5	1
A	languageIdsFromMaskProvider()	0	17	1
A	getMaskGenerator()	0	4	1
A	getLanguageHandler()	0	34	4

How to fix Duplicated Code

<?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();

        $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 testGenerateLanguageMask()}.
     *
     * @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::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)
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 testGenerateLanguageMask()}.
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	View Code Duplication	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 — master ( 05264e...b99b30 )

MaskGeneratorTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like