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

Completed

Push — lazy-loading-not-avail-content ( 189e64...1dbb7d )

by André

created 2018-11-23 07:26 UTC

MaskGeneratorTest::testIsLanguageAlwaysAvailable() 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	0
dl	0
loc	14
rs	9.7998
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)
        );
    }

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

ezsystems / ezpublish-kernel

Push — lazy-loading-not-avail-content ( 189e64...1dbb7d )

MaskGeneratorTest::testIsLanguageAlwaysAvailable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like