You are here

Home » API reference » Drupal 8 » LocaleLookupTest.php

class LocaleLookupTest in Drupal 8

Same name and namespace in other branches
  1. 9 core/modules/locale/tests/src/Unit/LocaleLookupTest.php \Drupal\Tests\locale\Unit\LocaleLookupTest
  2. 10 core/modules/locale/tests/src/Unit/LocaleLookupTest.php \Drupal\Tests\locale\Unit\LocaleLookupTest

@coversDefaultClass \Drupal\locale\LocaleLookup @group locale

Hierarchy

Expanded class hierarchy of LocaleLookupTest

File

core/modules/locale/tests/src/Unit/LocaleLookupTest.php, line 16

Namespace

Drupal\Tests\locale\Unit
View source 
class LocaleLookupTest extends UnitTestCase {

  /**
   * A mocked storage to use when instantiating LocaleTranslation objects.
   *
   * @var \Drupal\locale\StringStorageInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $storage;

  /**
   * A mocked cache object.
   *
   * @var \Drupal\Core\Cache\CacheBackendInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $cache;

  /**
   * A mocked lock object.
   *
   * @var \Drupal\Core\Lock\LockBackendInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $lock;

  /**
   * A mocked user object built from AccountInterface.
   *
   * @var \Drupal\Core\Session\AccountInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $user;

  /**
   * A mocked config factory built with UnitTestCase::getConfigFactoryStub().
   *
   * @var \Drupal\Core\Config\ConfigFactory|\PHPUnit\Framework\MockObject\MockBuilder
   */
  protected $configFactory;

  /**
   * A mocked language manager built from LanguageManagerInterface.
   *
   * @var \Drupal\Core\Language\LanguageManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $languageManager;

  /**
   * The request stack.
   *
   * @var \Symfony\Component\HttpFoundation\RequestStack
   */
  protected $requestStack;

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    $this->storage = $this
      ->createMock('Drupal\\locale\\StringStorageInterface');
    $this->cache = $this
      ->createMock('Drupal\\Core\\Cache\\CacheBackendInterface');
    $this->lock = $this
      ->createMock('Drupal\\Core\\Lock\\LockBackendInterface');
    $this->lock
      ->expects($this
      ->never())
      ->method($this
      ->anything());
    $this->user = $this
      ->createMock('Drupal\\Core\\Session\\AccountInterface');
    $this->user
      ->expects($this
      ->any())
      ->method('getRoles')
      ->will($this
      ->returnValue([
      'anonymous',
    ]));
    $this->configFactory = $this
      ->getConfigFactoryStub([
      'locale.settings' => [
        'cache_strings' => FALSE,
      ],
    ]);
    $this->languageManager = $this
      ->createMock('Drupal\\Core\\Language\\LanguageManagerInterface');
    $this->requestStack = new RequestStack();
    $container = new ContainerBuilder();
    $container
      ->set('current_user', $this->user);
    \Drupal::setContainer($container);
  }

  /**
   * Tests locale lookups without fallback.
   *
   * @covers ::resolveCacheMiss
   */
  public function testResolveCacheMissWithoutFallback() {
    $args = [
      'language' => 'en',
      'source' => 'test',
      'context' => 'irrelevant',
    ];
    $result = (object) [
      'translation' => 'test',
    ];
    $this->cache
      ->expects($this
      ->once())
      ->method('get')
      ->with('locale:en:irrelevant:anonymous', FALSE);
    $this->storage
      ->expects($this
      ->once())
      ->method('findTranslation')
      ->with($this
      ->equalTo($args))
      ->will($this
      ->returnValue($result));
    $locale_lookup = $this
      ->getMockBuilder('Drupal\\locale\\LocaleLookup')
      ->setConstructorArgs([
      'en',
      'irrelevant',
      $this->storage,
      $this->cache,
      $this->lock,
      $this->configFactory,
      $this->languageManager,
      $this->requestStack,
    ])
      ->setMethods([
      'persist',
    ])
      ->getMock();
    $locale_lookup
      ->expects($this
      ->never())
      ->method('persist');
    $this
      ->assertSame('test', $locale_lookup
      ->get('test'));
  }

  /**
   * Tests locale lookups with fallback.
   *
   * Note that context is irrelevant here. It is not used but it is required.
   *
   * @covers ::resolveCacheMiss
   *
   * @dataProvider resolveCacheMissWithFallbackProvider
   */
  public function testResolveCacheMissWithFallback($langcode, $string, $context, $expected) {

    // These are fake words!
    $translations = [
      'en' => [
        'test' => 'test',
        'fake' => 'fake',
        'missing pl' => 'missing pl',
        'missing cs' => 'missing cs',
        'missing both' => 'missing both',
      ],
      'pl' => [
        'test' => 'test po polsku',
        'fake' => 'ściema',
        'missing cs' => 'zaginiony czech',
      ],
      'cs' => [
        'test' => 'test v české',
        'fake' => 'falešný',
        'missing pl' => 'chybějící pl',
      ],
    ];
    $this->storage
      ->expects($this
      ->any())
      ->method('findTranslation')
      ->will($this
      ->returnCallback(function ($argument) use ($translations) {
      if (isset($translations[$argument['language']][$argument['source']])) {
        return (object) [
          'translation' => $translations[$argument['language']][$argument['source']],
        ];
      }
      return TRUE;
    }));
    $this->languageManager
      ->expects($this
      ->any())
      ->method('getFallbackCandidates')
      ->will($this
      ->returnCallback(function (array $context = []) {
      switch ($context['langcode']) {
        case 'pl':
          return [
            'cs',
            'en',
          ];
        case 'cs':
          return [
            'en',
          ];
        default:
          return [];
      }
    }));
    $this->cache
      ->expects($this
      ->once())
      ->method('get')
      ->with('locale:' . $langcode . ':' . $context . ':anonymous', FALSE);
    $locale_lookup = new LocaleLookup($langcode, $context, $this->storage, $this->cache, $this->lock, $this->configFactory, $this->languageManager, $this->requestStack);
    $this
      ->assertSame($expected, $locale_lookup
      ->get($string));
  }

  /**
   * Provides test data for testResolveCacheMissWithFallback().
   */
  public function resolveCacheMissWithFallbackProvider() {
    return [
      [
        'cs',
        'test',
        'irrelevant',
        'test v české',
      ],
      [
        'cs',
        'fake',
        'irrelevant',
        'falešný',
      ],
      [
        'cs',
        'missing pl',
        'irrelevant',
        'chybějící pl',
      ],
      [
        'cs',
        'missing cs',
        'irrelevant',
        'missing cs',
      ],
      [
        'cs',
        'missing both',
        'irrelevant',
        'missing both',
      ],
      // Testing PL with fallback to cs, en.
      [
        'pl',
        'test',
        'irrelevant',
        'test po polsku',
      ],
      [
        'pl',
        'fake',
        'irrelevant',
        'ściema',
      ],
      [
        'pl',
        'missing pl',
        'irrelevant',
        'chybějící pl',
      ],
      [
        'pl',
        'missing cs',
        'irrelevant',
        'zaginiony czech',
      ],
      [
        'pl',
        'missing both',
        'irrelevant',
        'missing both',
      ],
    ];
  }

  /**
   * Tests locale lookups with persistent tracking.
   *
   * @covers ::resolveCacheMiss
   */
  public function testResolveCacheMissWithPersist() {
    $args = [
      'language' => 'en',
      'source' => 'test',
      'context' => 'irrelevant',
    ];
    $result = (object) [
      'translation' => 'test',
    ];
    $this->storage
      ->expects($this
      ->once())
      ->method('findTranslation')
      ->with($this
      ->equalTo($args))
      ->will($this
      ->returnValue($result));
    $this->configFactory = $this
      ->getConfigFactoryStub([
      'locale.settings' => [
        'cache_strings' => TRUE,
      ],
    ]);
    $locale_lookup = $this
      ->getMockBuilder('Drupal\\locale\\LocaleLookup')
      ->setConstructorArgs([
      'en',
      'irrelevant',
      $this->storage,
      $this->cache,
      $this->lock,
      $this->configFactory,
      $this->languageManager,
      $this->requestStack,
    ])
      ->setMethods([
      'persist',
    ])
      ->getMock();
    $locale_lookup
      ->expects($this
      ->once())
      ->method('persist');
    $this
      ->assertSame('test', $locale_lookup
      ->get('test'));
  }

  /**
   * Tests locale lookups without a found translation.
   *
   * @covers ::resolveCacheMiss
   */
  public function testResolveCacheMissNoTranslation() {
    $string = $this
      ->createMock('Drupal\\locale\\StringInterface');
    $string
      ->expects($this
      ->once())
      ->method('addLocation')
      ->will($this
      ->returnSelf());
    $this->storage
      ->expects($this
      ->once())
      ->method('findTranslation')
      ->will($this
      ->returnValue(NULL));
    $this->storage
      ->expects($this
      ->once())
      ->method('createString')
      ->will($this
      ->returnValue($string));
    $request = Request::create('/test');
    $this->requestStack
      ->push($request);
    $locale_lookup = $this
      ->getMockBuilder('Drupal\\locale\\LocaleLookup')
      ->setConstructorArgs([
      'en',
      'irrelevant',
      $this->storage,
      $this->cache,
      $this->lock,
      $this->configFactory,
      $this->languageManager,
      $this->requestStack,
    ])
      ->setMethods([
      'persist',
    ])
      ->getMock();
    $locale_lookup
      ->expects($this
      ->never())
      ->method('persist');
    $this
      ->assertTrue($locale_lookup
      ->get('test'));
  }

  /**
   * Tests locale lookups with old plural style of translations.
   *
   * @param array $translations
   *   The source with translations.
   * @param string $langcode
   *   The language code of translation string.
   * @param string $string
   *   The string for translation.
   * @param bool $is_fix
   *   The flag about expected fix translation.
   *
   * @covers ::resolveCacheMiss
   * @dataProvider providerFixOldPluralTranslationProvider
   */
  public function testFixOldPluralStyleTranslations($translations, $langcode, $string, $is_fix) {
    $this->storage
      ->expects($this
      ->any())
      ->method('findTranslation')
      ->will($this
      ->returnCallback(function ($argument) use ($translations) {
      if (isset($translations[$argument['language']][$argument['source']])) {
        return (object) [
          'translation' => $translations[$argument['language']][$argument['source']],
        ];
      }
      return TRUE;
    }));
    $this->languageManager
      ->expects($this
      ->any())
      ->method('getFallbackCandidates')
      ->will($this
      ->returnCallback(function (array $context = []) {
      switch ($context['langcode']) {
        case 'by':
          return [
            'ru',
          ];
      }
    }));
    $this->cache
      ->expects($this
      ->once())
      ->method('get')
      ->with('locale:' . $langcode . '::anonymous', FALSE);
    $locale_lookup = new LocaleLookup($langcode, '', $this->storage, $this->cache, $this->lock, $this->configFactory, $this->languageManager, $this->requestStack);
    if ($is_fix) {
      $this
        ->assertStringNotContainsString('@count[2]', $locale_lookup
        ->get($string));
    }
    else {
      $this
        ->assertStringContainsString('@count[2]', $locale_lookup
        ->get($string));
    }
  }

  /**
   * Provides test data for testResolveCacheMissWithFallback().
   */
  public function providerFixOldPluralTranslationProvider() {
    $translations = [
      'by' => [
        'word1' => '@count[2] word-by',
        'word2' => implode(PoItem::DELIMITER, [
          'word-by',
          '@count[2] word-by',
        ]),
      ],
      'ru' => [
        'word3' => '@count[2] word-ru',
        'word4' => implode(PoItem::DELIMITER, [
          'word-ru',
          '@count[2] word-ru',
        ]),
      ],
    ];
    return [
      'no-plural' => [
        $translations,
        'by',
        'word1',
        FALSE,
      ],
      'no-plural from other language' => [
        $translations,
        'by',
        'word3',
        FALSE,
      ],
      'plural' => [
        $translations,
        'by',
        'word2',
        TRUE,
      ],
      'plural from other language' => [
        $translations,
        'by',
        'word4',
        TRUE,
      ],
    ];
  }

}

Members

Namesort descending Modifiers Type Description Overrides
LocaleLookupTest::$cache protected property A mocked cache object.
LocaleLookupTest::$configFactory protected property A mocked config factory built with UnitTestCase::getConfigFactoryStub().
LocaleLookupTest::$languageManager protected property A mocked language manager built from LanguageManagerInterface.
LocaleLookupTest::$lock protected property A mocked lock object.
LocaleLookupTest::$requestStack protected property The request stack.
LocaleLookupTest::$storage protected property A mocked storage to use when instantiating LocaleTranslation objects.
LocaleLookupTest::$user protected property A mocked user object built from AccountInterface.
LocaleLookupTest::providerFixOldPluralTranslationProvider public function Provides test data for testResolveCacheMissWithFallback().
LocaleLookupTest::resolveCacheMissWithFallbackProvider public function Provides test data for testResolveCacheMissWithFallback().
LocaleLookupTest::setUp protected function Overrides UnitTestCase::setUp
LocaleLookupTest::testFixOldPluralStyleTranslations public function Tests locale lookups with old plural style of translations.
LocaleLookupTest::testResolveCacheMissNoTranslation public function Tests locale lookups without a found translation.
LocaleLookupTest::testResolveCacheMissWithFallback public function Tests locale lookups with fallback.
LocaleLookupTest::testResolveCacheMissWithoutFallback public function Tests locale lookups without fallback.
LocaleLookupTest::testResolveCacheMissWithPersist public function Tests locale lookups with persistent tracking.
PhpunitCompatibilityTrait::getMock Deprecated public function Returns a mock object for the specified class using the available method.
PhpunitCompatibilityTrait::setExpectedException Deprecated public function Compatibility layer for PHPUnit 6 to support PHPUnit 4 code.
UnitTestCase::$randomGenerator protected property The random generator.
UnitTestCase::$root protected property The app root. 1
UnitTestCase::assertArrayEquals protected function Asserts if two arrays are equal by sorting them first.
UnitTestCase::getBlockMockWithMachineName Deprecated protected function Mocks a block with a block plugin. 1
UnitTestCase::getClassResolverStub protected function Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub public function Returns a stub config factory that behaves according to the passed array.
UnitTestCase::getConfigStorageStub public function Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator protected function Sets up a container with a cache tags invalidator.
UnitTestCase::getRandomGenerator protected function Gets the random generator for the utility methods.
UnitTestCase::getStringTranslationStub public function Returns a stub translation manager that just returns the passed string.
UnitTestCase::randomMachineName public function Generates a unique random string containing letters and numbers.