class ConfigMapperManagerTest in Drupal 8

Tests the functionality provided by configuration translation mapper manager.

@group config_translation

Hierarchy

• class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses PhpunitCompatibilityTrait
  • class \Drupal\Tests\config_translation\Unit\ConfigMapperManagerTest

File

core/modules/config_translation/tests/src/Unit/ConfigMapperManagerTest.php, line 17

Namespace

Drupal\Tests\config_translation\Unit

class ConfigMapperManagerTest extends UnitTestCase {

  /**
   * The configuration mapper manager to test.
   *
   * @var \Drupal\config_translation\ConfigMapperManager
   */
  protected $configMapperManager;

  /**
   * The typed configuration manager used for testing.
   *
   * @var \Drupal\Core\Config\TypedConfigManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $typedConfigManager;
  protected function setUp() {
    $language = new Language([
      'id' => 'en',
    ]);
    $language_manager = $this
      ->createMock('Drupal\\Core\\Language\\LanguageManagerInterface');
    $language_manager
      ->expects($this
      ->once())
      ->method('getCurrentLanguage')
      ->with(LanguageInterface::TYPE_INTERFACE)
      ->will($this
      ->returnValue($language));
    $this->typedConfigManager = $this
      ->getMockBuilder('Drupal\\Core\\Config\\TypedConfigManagerInterface')
      ->getMock();
    $module_handler = $this
      ->createMock('Drupal\\Core\\Extension\\ModuleHandlerInterface');
    $theme_handler = $this
      ->createMock('Drupal\\Core\\Extension\\ThemeHandlerInterface');
    $this->configMapperManager = new ConfigMapperManager($this
      ->createMock('Drupal\\Core\\Cache\\CacheBackendInterface'), $language_manager, $module_handler, $this->typedConfigManager, $theme_handler);
  }

  /**
   * Tests ConfigMapperManager::hasTranslatable().
   *
   * @param \Drupal\Core\TypedData\TypedDataInterface $element
   *   The schema element to test.
   * @param bool $expected
   *   The expected return value of ConfigMapperManager::hasTranslatable().
   *
   * @dataProvider providerTestHasTranslatable
   */
  public function testHasTranslatable(TypedDataInterface $element, $expected) {
    $this->typedConfigManager
      ->expects($this
      ->once())
      ->method('get')
      ->with('test')
      ->will($this
      ->returnValue($element));
    $result = $this->configMapperManager
      ->hasTranslatable('test');
    $this
      ->assertSame($expected, $result);
  }

  /**
   * Provides data for ConfigMapperManager::testHasTranslatable()
   *
   * @return array
   *   An array of arrays, where each inner array contains the schema element
   *   to test as the first key and the expected result of
   *   ConfigMapperManager::hasTranslatable() as the second key.
   */
  public function providerTestHasTranslatable() {
    return [
      [
        $this
          ->getElement([]),
        FALSE,
      ],
      [
        $this
          ->getElement([
          'aaa' => 'bbb',
        ]),
        FALSE,
      ],
      [
        $this
          ->getElement([
          'translatable' => FALSE,
        ]),
        FALSE,
      ],
      [
        $this
          ->getElement([
          'translatable' => TRUE,
        ]),
        TRUE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([]),
        ]),
        FALSE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([
            'translatable' => TRUE,
          ]),
        ]),
        TRUE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([
            'aaa' => 'bbb',
          ]),
          $this
            ->getElement([
            'ccc' => 'ddd',
          ]),
          $this
            ->getElement([
            'eee' => 'fff',
          ]),
        ]),
        FALSE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([
            'aaa' => 'bbb',
          ]),
          $this
            ->getElement([
            'ccc' => 'ddd',
          ]),
          $this
            ->getElement([
            'translatable' => TRUE,
          ]),
        ]),
        TRUE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([
            'aaa' => 'bbb',
          ]),
          $this
            ->getNestedElement([
            $this
              ->getElement([
              'ccc' => 'ddd',
            ]),
            $this
              ->getElement([
              'eee' => 'fff',
            ]),
          ]),
          $this
            ->getNestedElement([
            $this
              ->getElement([
              'ggg' => 'hhh',
            ]),
            $this
              ->getElement([
              'iii' => 'jjj',
            ]),
          ]),
        ]),
        FALSE,
      ],
      [
        $this
          ->getNestedElement([
          $this
            ->getElement([
            'aaa' => 'bbb',
          ]),
          $this
            ->getNestedElement([
            $this
              ->getElement([
              'ccc' => 'ddd',
            ]),
            $this
              ->getElement([
              'eee' => 'fff',
            ]),
          ]),
          $this
            ->getNestedElement([
            $this
              ->getElement([
              'ggg' => 'hhh',
            ]),
            $this
              ->getElement([
              'translatable' => TRUE,
            ]),
          ]),
        ]),
        TRUE,
      ],
    ];
  }

  /**
   * Returns a mocked schema element.
   *
   * @param array $definition
   *   The definition of the schema element.
   *
   * @return \Drupal\Core\Config\Schema\Element
   *   The mocked schema element.
   */
  protected function getElement(array $definition) {
    $data_definition = new DataDefinition($definition);
    $element = $this
      ->createMock('Drupal\\Core\\TypedData\\TypedDataInterface');
    $element
      ->expects($this
      ->any())
      ->method('getDataDefinition')
      ->will($this
      ->returnValue($data_definition));
    return $element;
  }

  /**
   * Returns a mocked nested schema element.
   *
   * @param array $elements
   *   An array of simple schema elements.
   *
   * @return \Drupal\Core\Config\Schema\Mapping
   *   A nested schema element, containing the passed-in elements.
   */
  protected function getNestedElement(array $elements) {

    // ConfigMapperManager::findTranslatable() checks for
    // \Drupal\Core\TypedData\TraversableTypedDataInterface, but mocking that
    // directly does not work, because we need to implement \IteratorAggregate
    // in order for getIterator() to be called. Therefore we need to mock
    // \Drupal\Core\Config\Schema\ArrayElement, but that is abstract, so we
    // need to mock one of the subclasses of it.
    $nested_element = $this
      ->getMockBuilder('Drupal\\Core\\Config\\Schema\\Mapping')
      ->disableOriginalConstructor()
      ->getMock();
    $nested_element
      ->expects($this
      ->once())
      ->method('getIterator')
      ->will($this
      ->returnValue(new \ArrayIterator($elements)));
    return $nested_element;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ConfigMapperManagerTest::$configMapperManager	protected	property	The configuration mapper manager to test.
ConfigMapperManagerTest::$typedConfigManager	protected	property	The typed configuration manager used for testing.
ConfigMapperManagerTest::getElement	protected	function	Returns a mocked schema element.
ConfigMapperManagerTest::getNestedElement	protected	function	Returns a mocked nested schema element.
ConfigMapperManagerTest::providerTestHasTranslatable	public	function	Provides data for ConfigMapperManager::testHasTranslatable()
ConfigMapperManagerTest::setUp	protected	function	Overrides UnitTestCase::setUp
ConfigMapperManagerTest::testHasTranslatable	public	function	Tests ConfigMapperManager::hasTranslatable().
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.