test/classes/LanguageTest.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * tests for Advisor class
   5  *
   6  * @package PhpMyAdmin-test
   7  */
   8 declare(strict_types=1);
   9
  10 namespace PhpMyAdmin\Tests;
  11
  12 use PhpMyAdmin\LanguageManager;
  13 use PhpMyAdmin\Tests\PmaTestCase;
  14
  15 /**
  16  * Tests behaviour of PMA_Advisor class
  17  *
  18  * @package PhpMyAdmin-test
  19  */
  20 class LanguageTest extends PmaTestCase
  21 {
  22     /**
  23      * @var LanguageManager
  24      */
  25     private $manager;
  26
  27     /**
  28      * Setup for Language tests.
  29      *
  30      * @return void
  31      */
  32     protected function setUp(): void
  33     {
  34         $loc = LOCALE_PATH . '/cs/LC_MESSAGES/phpmyadmin.mo';
  35         if (! is_readable($loc)) {
  36             $this->markTestSkipped('Missing compiled locales.');
  37         }
  38         $this->manager = new LanguageManager();
  39     }
  40
  41     /**
  42      * @return void
  43      */
  44     protected function tearDown(): void
  45     {
  46         // Ensure we have English locale after tests
  47         $this->manager->getLanguage('en')->activate();
  48     }
  49
  50     /**
  51      * Test language filtering
  52      *
  53      * @return void
  54      */
  55     public function testAvailable()
  56     {
  57         $GLOBALS['PMA_Config']->set('FilterLanguages', 'cs|en$');
  58
  59         $langs = $this->manager->availableLocales();
  60
  61         $this->assertCount(2, $langs);
  62         $this->assertContains('cs', $langs);
  63         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
  64     }
  65
  66     /**
  67      * Test no language filtering
  68      *
  69      * @return void
  70      */
  71     public function testAllAvailable()
  72     {
  73         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
  74
  75         $langs = $this->manager->availableLocales();
  76
  77         $this->assertContains('cs', $langs);
  78         $this->assertContains('en', $langs);
  79     }
  80
  81     /**
  82      * Test whether listing locales works
  83      *
  84      * @return void
  85      */
  86     public function testList()
  87     {
  88         $langs = $this->manager->listLocaleDir();
  89         $this->assertContains('cs', $langs);
  90         $this->assertContains('en', $langs);
  91     }
  92
  93     /**
  94      * Test for getting available languages
  95      *
  96      * @return void
  97      */
  98     public function testLanguages()
  99     {
 100         $langs = $this->manager->availableLanguages();
 101         $this->assertGreaterThan(1, count($langs));
 102
 103         /* Ensure we have name for every language */
 104         foreach ($langs as $lang) {
 105             $this->assertNotEquals($lang->getCode(), strtolower($lang->getEnglishName()));
 106         }
 107     }
 108
 109     /**
 110      * Test for MySQL locales
 111      *
 112      * @return void
 113      */
 114     public function testMySQLLocale()
 115     {
 116         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
 117         $czech = $this->manager->getLanguage('cs');
 118         $this->assertNotFalse($czech);
 119         $this->assertEquals('cs_CZ', $czech->getMySQLLocale());
 120
 121         $azerbaijani = $this->manager->getLanguage('az');
 122         $this->assertNotFalse($azerbaijani);
 123         $this->assertEquals('', $azerbaijani->getMySQLLocale());
 124     }
 125
 126     /**
 127      * Test for getting available sorted languages
 128      *
 129      * @return void
 130      */
 131     public function testSortedLanguages()
 132     {
 133         $langs = $this->manager->sortedLanguages();
 134         $this->assertGreaterThan(1, count($langs));
 135     }
 136
 137     /**
 138      * Test getting language by code
 139      *
 140      * @return void
 141      */
 142     public function testGet()
 143     {
 144         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
 145         $lang = $this->manager->getLanguage('cs');
 146         $this->assertNotEquals(false, $lang);
 147         $this->assertEquals('Czech', $lang->getEnglishName());
 148         $this->assertEquals('Čeština', $lang->getNativeName());
 149         $lang = $this->manager->getLanguage('nonexisting');
 150         $this->assertEquals(false, $lang);
 151     }
 152
 153     /**
 154      * Test language selection
 155      *
 156      * @param string $lang    Value for forced language
 157      * @param string $post    Value for language in POST
 158      * @param string $get     Value for language in GET
 159      * @param string $cookie  Value for language in COOKIE
 160      * @param string $accept  Value for HTTP Accept-Language header
 161      * @param string $agent   Value for HTTP User-Agent header
 162      * @param string $default Value for default language
 163      * @param string $expect  Expected language name
 164      *
 165      * @return void
 166      *
 167      * @dataProvider selectDataProvider
 168      */
 169     public function testSelect($lang, $post, $get, $cookie, $accept, $agent, $default, $expect): void
 170     {
 171         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
 172         $GLOBALS['PMA_Config']->set('Lang', $lang);
 173         $GLOBALS['PMA_Config']->set('is_https', false);
 174         $_POST['lang'] = $post;
 175         $_GET['lang'] = $get;
 176         $_COOKIE['pma_lang'] = $cookie;
 177         $_SERVER['HTTP_ACCEPT_LANGUAGE'] = $accept;
 178         $_SERVER['HTTP_USER_AGENT'] = $agent;
 179         $GLOBALS['PMA_Config']->set('DefaultLang', $default);
 180
 181         $lang = $this->manager->selectLanguage();
 182
 183         $this->assertEquals($expect, $lang->getEnglishName());
 184
 185         $GLOBALS['PMA_Config']->set('Lang', '');
 186         $_POST['lang'] = '';
 187         $_GET['lang'] = '';
 188         $_COOKIE['pma_lang'] = '';
 189         $_SERVER['HTTP_ACCEPT_LANGUAGE'] = '';
 190         $_SERVER['HTTP_USER_AGENT'] = '';
 191         $GLOBALS['PMA_Config']->set('DefaultLang', 'en');
 192     }
 193
 194     /**
 195      * Data provider for language selection test.
 196      *
 197      * @return array Test parameters.
 198      */
 199     public function selectDataProvider()
 200     {
 201         return [
 202             [
 203                 'cs',
 204                 'en',
 205                 '',
 206                 '',
 207                 '',
 208                 '',
 209                 '',
 210                 'Czech',
 211             ],
 212             [
 213                 '',
 214                 'cs',
 215                 '',
 216                 '',
 217                 '',
 218                 '',
 219                 '',
 220                 'Czech',
 221             ],
 222             [
 223                 '',
 224                 'cs',
 225                 'en',
 226                 '',
 227                 '',
 228                 '',
 229                 '',
 230                 'Czech',
 231             ],
 232             [
 233                 '',
 234                 '',
 235                 'cs',
 236                 '',
 237                 '',
 238                 '',
 239                 '',
 240                 'Czech',
 241             ],
 242             [
 243                 '',
 244                 '',
 245                 '',
 246                 'cs',
 247                 '',
 248                 '',
 249                 '',
 250                 'Czech',
 251             ],
 252             [
 253                 '',
 254                 '',
 255                 '',
 256                 '',
 257                 'cs,en-US;q=0.7,en;q=0.3',
 258                 '',
 259                 '',
 260                 'Czech',
 261             ],
 262             [
 263                 '',
 264                 '',
 265                 '',
 266                 '',
 267                 '',
 268                 'Mozilla/5.0 (Linux; U; Android 2.2.2; tr-tr; GM FOX)',
 269                 '',
 270                 'Turkish',
 271             ],
 272             [
 273                 '',
 274                 '',
 275                 '',
 276                 '',
 277                 '',
 278                 '',
 279                 'cs',
 280                 'Czech',
 281             ],
 282             [
 283                 '',
 284                 '',
 285                 '',
 286                 '',
 287                 '',
 288                 '',
 289                 '',
 290                 'English',
 291             ],
 292         ];
 293     }
 294
 295     /**
 296      * Test for setting and parsing locales
 297      *
 298      * @param string $locale locale name
 299      *
 300      * @return void
 301      *
 302      * @group large
 303      * @dataProvider listLocales
 304      */
 305     public function testGettext($locale): void
 306     {
 307         $GLOBALS['PMA_Config']->set('FilterLanguages', '');
 308         /* We should be able to set the language */
 309         $this->manager->getLanguage($locale)->activate();
 310
 311         /* Grab some texts */
 312         $this->assertStringContainsString('%s', _ngettext('%s table', '%s tables', 10));
 313         $this->assertStringContainsString('%s', _ngettext('%s table', '%s tables', 1));
 314
 315         $this->assertEquals(
 316             $locale,
 317             $this->manager->getCurrentLanguage()->getCode()
 318         );
 319     }
 320
 321     /**
 322      * Data provider to generate list of available locales.
 323      *
 324      * @return array with arrays of available locales
 325      */
 326     public function listLocales()
 327     {
 328         $ret = [];
 329         foreach (LanguageManager::getInstance()->availableLanguages() as $language) {
 330             $ret[] = [$language->getCode()];
 331         }
 332         return $ret;
 333     }
 334 }