LoaderTest::localeList() - Code Metrics - Inspection of "Add ability to use APCu for translation cache" - phpmyadmin/motranslator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#42)

unknown

created 2022-03-03 18:07 UTC

LoaderTest::localeList() A

↳ Parent: LoaderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	97
Code Lines	41

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	41
dl	0
loc	97
c	0
b	0
f	0
rs	9.264
cc	1
nc	1
nop	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace PhpMyAdmin\MoTranslator\Tests;

use PhpMyAdmin\MoTranslator\Cache\CacheFactoryInterface;
use PhpMyAdmin\MoTranslator\Cache\CacheInterface;
use PhpMyAdmin\MoTranslator\Loader;
use PhpMyAdmin\MoTranslator\MoParser;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

use function getenv;
use function putenv;

/**
 * Test for mo loading.
 */
class LoaderTest extends TestCase
{
    /**
     * @param array[] $expected
     *
     * @dataProvider localeList
     */
    public function testListLocales(string $locale, array $expected): void
    {
        $this->assertEquals(
            $expected,
            Loader::listLocales($locale)
        );
    }

    /**
     * @return array[]
     */
    public function localeList(): array
    {
        return [
            [
                'cs_CZ',
                [
                    'cs_CZ',
                    'cs',
                ],
            ],
            [
                'sr_CS.UTF-8@latin',
                [
                    'sr_CS.UTF-8@latin',
                    'sr_CS@latin',
                    'sr@latin',
                    'sr_CS.UTF-8',
                    'sr_CS',
                    'sr',
                ],
            ],
            // For a locale containing country code, we prefer
            // full locale name, but if that's not found, fall back
            // to the language only locale name.
            [
                'sr_RS',
                [
                    'sr_RS',
                    'sr',
                ],
            ],
            // If language code is used, it's the only thing returned.
            [
                'sr',
                ['sr'],
            ],
            // There is support for language and charset only.
            [
                'sr.UTF-8',
                [
                    'sr.UTF-8',
                    'sr',
                ],
            ],

            // It can also split out character set from the full locale name.
            [
                'sr_RS.UTF-8',
                [
                    'sr_RS.UTF-8',
                    'sr_RS',
                    'sr',
                ],
            ],

            // There is support for @modifier in locale names as well.
            [
                'sr_RS.UTF-8@latin',
                [
                    'sr_RS.UTF-8@latin',
                    'sr_RS@latin',
                    'sr@latin',
                    'sr_RS.UTF-8',
                    'sr_RS',
                    'sr',
                ],
            ],
            [
                'sr.UTF-8@latin',
                [
                    'sr.UTF-8@latin',
                    'sr@latin',
                    'sr.UTF-8',
                    'sr',
                ],
            ],

            // We can pass in only language and modifier.
            [
                'sr@latin',
                [
                    'sr@latin',
                    'sr',
                ],
            ],

            // If locale name is not following the regular POSIX pattern,
            // it's used verbatim.
            [
                'something',
                ['something'],
            ],

            // Passing in an empty string returns an empty array.
            [
                '',
                [],
            ],
        ];
    }

    private function getLoader(string $domain, string $locale): Loader
    {
        $loader = new Loader();
        $loader->setlocale($locale);
        $loader->textdomain($domain);
        $loader->bindtextdomain($domain, __DIR__ . '/data/locale/');

        return $loader;
    }

    public function testLocaleChange(): void
    {
        $loader = new Loader();
        $loader->setlocale('cs');
        $loader->textdomain('phpmyadmin');
        $loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');
        $translator = $loader->getTranslator('phpmyadmin');
        $this->assertEquals('Typ', $translator->gettext('Type'));
        $loader->setlocale('be_BY');
        $translator = $loader->getTranslator('phpmyadmin');
        $this->assertEquals('Тып', $translator->gettext('Type'));
    }

    /**
     * @dataProvider translatorData
     */
    public function testGetTranslator(string $domain, string $locale, string $otherdomain, string $expected): void
    {
        $loader = $this->getLoader($domain, $locale);
        $translator = $loader->getTranslator($otherdomain);
        $this->assertEquals(
            $expected,
            $translator->gettext('Type')
        );
    }

    /**
     * @return array[]
     */
    public function translatorData(): array
    {
        return [
            [
                'phpmyadmin',
                'cs',
                '',
                'Typ',
            ],
            [
                'phpmyadmin',
                'cs_CZ',
                '',
                'Typ',
            ],
            [
                'phpmyadmin',
                'be_BY',
                '',
                'Тып',
            ],
            [
                'phpmyadmin',
                'be@latin',
                '',
                'Typ',
            ],
            [
                'phpmyadmin',
                'cs',
                'other',
                'Type',
            ],
            [
                'other',
                'cs',
                'phpmyadmin',
                'Type',
            ],
        ];
    }

    public function testInstance(): void
    {
        $loader = Loader::getInstance();
        $loader->setlocale('cs');
        $loader->textdomain('phpmyadmin');
        $loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');

        $translator = $loader->getTranslator();
        $this->assertEquals(
            'Typ',
            $translator->gettext('Type')
        );

        /* Ensure the object survives */
        $loader = Loader::getInstance();
        $translator = $loader->getTranslator();
        $this->assertEquals(
            'Typ',
            $translator->gettext('Type')
        );

        /* Ensure the object can support different locale files for the same domain */
        $loader = Loader::getInstance();
        $loader->setlocale('be_BY');
        $loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');
        $translator = $loader->getTranslator();
        $this->assertEquals(
            'Тып',
            $translator->gettext('Type')
        );
    }

    public function testDetect(): void
    {
        $GLOBALS['lang'] = 'foo';
        $loader = Loader::getInstance();
        $this->assertEquals(
            'foo',
            $loader->detectlocale()
        );
        unset($GLOBALS['lang']);
    }

    public function testDetectEnv(): void
    {
        $loader = Loader::getInstance();
        foreach (['LC_MESSAGES', 'LC_ALL', 'LANG'] as $var) {
            putenv($var);
            if (getenv($var) === false) {
                continue;
            }

            $this->markTestSkipped('Unsetting environment does not work');
        }

        unset($GLOBALS['lang']);
        putenv('LC_ALL=baz');
        $this->assertEquals(
            'baz',
            $loader->detectlocale()
        );
        putenv('LC_ALL');
        putenv('LC_MESSAGES=bar');
        $this->assertEquals(
            'bar',
            $loader->detectlocale()
        );
        putenv('LC_MESSAGES');
        putenv('LANG=barr');
        $this->assertEquals(
            'barr',
            $loader->detectlocale()
        );
        putenv('LANG');
        $this->assertEquals(
            'en',
            $loader->detectlocale()
        );
    }

    public function testSetCacheFactory(): void
    {
        $expected = 'Foo';
        $locale = 'be_BY';
        $domain = 'apcu';

        $cache = $this->createMock(CacheInterface::class);
        $cache->method('get')
            ->willReturn($expected);
        /** @var CacheFactoryInterface&MockObject $factory */
        $factory = $this->createMock(CacheFactoryInterface::class);
        $factory->expects($this->once())
            ->method('getInstance')
            ->with($this->isInstanceOf(MoParser::class), $locale, $domain)
            ->willReturn($cache);

        Loader::setCacheFactory($factory);
        $loader = Loader::getInstance();
        $loader->setlocale($locale);
        $loader->bindtextdomain($domain, __DIR__ . '/data/locale/');
        $translator = $loader->getTranslator($domain);

        $actual = $translator->gettext('Type');
        $this->assertEquals($expected, $actual);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace PhpMyAdmin\MoTranslator\Tests;
6
7			use PhpMyAdmin\MoTranslator\Cache\CacheFactoryInterface;
8			use PhpMyAdmin\MoTranslator\Cache\CacheInterface;
9			use PhpMyAdmin\MoTranslator\Loader;
10			use PhpMyAdmin\MoTranslator\MoParser;
11			use PHPUnit\Framework\MockObject\MockObject;
12			use PHPUnit\Framework\TestCase;
13
14			use function getenv;
15			use function putenv;
16
17			/**
18			* Test for mo loading.
19			*/
20			class LoaderTest extends TestCase
21			{
22			/**
23			* @param array[] $expected
24			*
25			* @dataProvider localeList
26			*/
27			public function testListLocales(string $locale, array $expected): void
28			{
29			$this->assertEquals(
30			$expected,
31			Loader::listLocales($locale)
32			);
33			}
34
35			/**
36			* @return array[]
37			*/
38			public function localeList(): array
39			{
40			return [
41			[
42			'cs_CZ',
43			[
44			'cs_CZ',
45			'cs',
46			],
47			],
48			[
49			'sr_CS.UTF-8@latin',
50			[
51			'sr_CS.UTF-8@latin',
52			'sr_CS@latin',
53			'sr@latin',
54			'sr_CS.UTF-8',
55			'sr_CS',
56			'sr',
57			],
58			],
59			// For a locale containing country code, we prefer
60			// full locale name, but if that's not found, fall back
61			// to the language only locale name.
62			[
63			'sr_RS',
64			[
65			'sr_RS',
66			'sr',
67			],
68			],
69			// If language code is used, it's the only thing returned.
70			[
71			'sr',
72			['sr'],
73			],
74			// There is support for language and charset only.
75			[
76			'sr.UTF-8',
77			[
78			'sr.UTF-8',
79			'sr',
80			],
81			],
82
83			// It can also split out character set from the full locale name.
84			[
85			'sr_RS.UTF-8',
86			[
87			'sr_RS.UTF-8',
88			'sr_RS',
89			'sr',
90			],
91			],
92
93			// There is support for @modifier in locale names as well.
94			[
95			'sr_RS.UTF-8@latin',
96			[
97			'sr_RS.UTF-8@latin',
98			'sr_RS@latin',
99			'sr@latin',
100			'sr_RS.UTF-8',
101			'sr_RS',
102			'sr',
103			],
104			],
105			[
106			'sr.UTF-8@latin',
107			[
108			'sr.UTF-8@latin',
109			'sr@latin',
110			'sr.UTF-8',
111			'sr',
112			],
113			],
114
115			// We can pass in only language and modifier.
116			[
117			'sr@latin',
118			[
119			'sr@latin',
120			'sr',
121			],
122			],
123
124			// If locale name is not following the regular POSIX pattern,
125			// it's used verbatim.
126			[
127			'something',
128			['something'],
129			],
130
131			// Passing in an empty string returns an empty array.
132			[
133			'',
134			[],
135			],
136			];
137			}
138
139			private function getLoader(string $domain, string $locale): Loader
140			{
141			$loader = new Loader();
142			$loader->setlocale($locale);
143			$loader->textdomain($domain);
144			$loader->bindtextdomain($domain, __DIR__ . '/data/locale/');
145
146			return $loader;
147			}
148
149			public function testLocaleChange(): void
150			{
151			$loader = new Loader();
152			$loader->setlocale('cs');
153			$loader->textdomain('phpmyadmin');
154			$loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');
155			$translator = $loader->getTranslator('phpmyadmin');
156			$this->assertEquals('Typ', $translator->gettext('Type'));
157			$loader->setlocale('be_BY');
158			$translator = $loader->getTranslator('phpmyadmin');
159			$this->assertEquals('Тып', $translator->gettext('Type'));
160			}
161
162			/**
163			* @dataProvider translatorData
164			*/
165			public function testGetTranslator(string $domain, string $locale, string $otherdomain, string $expected): void
166			{
167			$loader = $this->getLoader($domain, $locale);
168			$translator = $loader->getTranslator($otherdomain);
169			$this->assertEquals(
170			$expected,
171			$translator->gettext('Type')
172			);
173			}
174
175			/**
176			* @return array[]
177			*/
178			public function translatorData(): array
179			{
180			return [
181			[
182			'phpmyadmin',
183			'cs',
184			'',
185			'Typ',
186			],
187			[
188			'phpmyadmin',
189			'cs_CZ',
190			'',
191			'Typ',
192			],
193			[
194			'phpmyadmin',
195			'be_BY',
196			'',
197			'Тып',
198			],
199			[
200			'phpmyadmin',
201			'be@latin',
202			'',
203			'Typ',
204			],
205			[
206			'phpmyadmin',
207			'cs',
208			'other',
209			'Type',
210			],
211			[
212			'other',
213			'cs',
214			'phpmyadmin',
215			'Type',
216			],
217			];
218			}
219
220			public function testInstance(): void
221			{
222			$loader = Loader::getInstance();
223			$loader->setlocale('cs');
224			$loader->textdomain('phpmyadmin');
225			$loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');
226
227			$translator = $loader->getTranslator();
228			$this->assertEquals(
229			'Typ',
230			$translator->gettext('Type')
231			);
232
233			/* Ensure the object survives */
234			$loader = Loader::getInstance();
235			$translator = $loader->getTranslator();
236			$this->assertEquals(
237			'Typ',
238			$translator->gettext('Type')
239			);
240
241			/* Ensure the object can support different locale files for the same domain */
242			$loader = Loader::getInstance();
243			$loader->setlocale('be_BY');
244			$loader->bindtextdomain('phpmyadmin', __DIR__ . '/data/locale/');
245			$translator = $loader->getTranslator();
246			$this->assertEquals(
247			'Тып',
248			$translator->gettext('Type')
249			);
250			}
251
252			public function testDetect(): void
253			{
254			$GLOBALS['lang'] = 'foo';
255			$loader = Loader::getInstance();
256			$this->assertEquals(
257			'foo',
258			$loader->detectlocale()
259			);
260			unset($GLOBALS['lang']);
261			}
262
263			public function testDetectEnv(): void
264			{
265			$loader = Loader::getInstance();
266			foreach (['LC_MESSAGES', 'LC_ALL', 'LANG'] as $var) {
267			putenv($var);
268			if (getenv($var) === false) {
269			continue;
270			}
271
272			$this->markTestSkipped('Unsetting environment does not work');
273			}
274
275			unset($GLOBALS['lang']);
276			putenv('LC_ALL=baz');
277			$this->assertEquals(
278			'baz',
279			$loader->detectlocale()
280			);
281			putenv('LC_ALL');
282			putenv('LC_MESSAGES=bar');
283			$this->assertEquals(
284			'bar',
285			$loader->detectlocale()
286			);
287			putenv('LC_MESSAGES');
288			putenv('LANG=barr');
289			$this->assertEquals(
290			'barr',
291			$loader->detectlocale()
292			);
293			putenv('LANG');
294			$this->assertEquals(
295			'en',
296			$loader->detectlocale()
297			);
298			}
299
300			public function testSetCacheFactory(): void
301			{
302			$expected = 'Foo';
303			$locale = 'be_BY';
304			$domain = 'apcu';
305
306			$cache = $this->createMock(CacheInterface::class);
307			$cache->method('get')
308			->willReturn($expected);
309			/** @var CacheFactoryInterface&MockObject $factory */
310			$factory = $this->createMock(CacheFactoryInterface::class);
311			$factory->expects($this->once())
312			->method('getInstance')
313			->with($this->isInstanceOf(MoParser::class), $locale, $domain)
314			->willReturn($cache);
315
316			Loader::setCacheFactory($factory);
317			$loader = Loader::getInstance();
318			$loader->setlocale($locale);
319			$loader->bindtextdomain($domain, __DIR__ . '/data/locale/');
320			$translator = $loader->getTranslator($domain);
321
322			$actual = $translator->gettext('Type');
323			$this->assertEquals($expected, $actual);
324			}
325			}
326

phpmyadmin / motranslator

Pull Request — master (#42)

LoaderTest::localeList() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like