abstract class LocalTaskIntegrationTestBase in Drupal 8

Defines a base unit test for testing existence of local tasks.

@todo Add tests for access checking and url building, https://www.drupal.org/node/2112245.

Hierarchy

• class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses PhpunitCompatibilityTrait
  • class \Drupal\Tests\Core\Menu\LocalTaskIntegrationTestBase

14 files declare their use of LocalTaskIntegrationTestBase

ActionLocalTasksTest.php in core/modules/action/tests/src/Unit/Menu/ActionLocalTasksTest.php

AggregatorLocalTasksTest.php in core/modules/aggregator/tests/src/Unit/Menu/AggregatorLocalTasksTest.php

BlockContentLocalTasksTest.php in core/modules/block_content/tests/src/Unit/Menu/BlockContentLocalTasksTest.php

BlockLocalTasksTest.php in core/modules/block/tests/src/Unit/Menu/BlockLocalTasksTest.php

BookLocalTasksTest.php in core/modules/book/tests/src/Unit/Menu/BookLocalTasksTest.php

... See full list

File

core/tests/Drupal/Tests/Core/Menu/LocalTaskIntegrationTestBase.php, line 17

Namespace

Drupal\Tests\Core\Menu

abstract class LocalTaskIntegrationTestBase extends UnitTestCase {

  /**
   * A list of module directories used for YAML searching.
   *
   * @var array
   */
  protected $directoryList;

  /**
   * The module handler.
   *
   * @var \Drupal\Core\Extension\ModuleHandlerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $moduleHandler;

  /**
   * The container.
   *
   * @var \Symfony\Component\DependencyInjection\ContainerBuilder
   */
  protected $container;

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();
    $container = new ContainerBuilder();
    $config_factory = $this
      ->getConfigFactoryStub([]);
    $container
      ->set('config.factory', $config_factory);
    $container
      ->set('app.root', $this->root);
    \Drupal::setContainer($container);
    $this->container = $container;
  }

  /**
   * Sets up the local task manager for the test.
   */
  protected function getLocalTaskManager($module_dirs, $route_name, $route_params) {
    $manager = $this
      ->getMockBuilder('Drupal\\Core\\Menu\\LocalTaskManager')
      ->disableOriginalConstructor()
      ->setMethods(NULL)
      ->getMock();
    $argumentResolver = $this
      ->createMock('Symfony\\Component\\HttpKernel\\Controller\\ArgumentResolverInterface');
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'argumentResolver');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $argumentResolver);

    // todo mock a request with a route.
    $request_stack = new RequestStack();
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'requestStack');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $request_stack);
    $accessManager = $this
      ->createMock('Drupal\\Core\\Access\\AccessManagerInterface');
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'accessManager');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $accessManager);
    $route_provider = $this
      ->createMock('Drupal\\Core\\Routing\\RouteProviderInterface');
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'routeProvider');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $route_provider);
    $module_handler = $this
      ->getMockBuilder('Drupal\\Core\\Extension\\ModuleHandlerInterface')
      ->disableOriginalConstructor()
      ->getMock();
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'moduleHandler');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $module_handler);

    // Set all the modules as being existent.
    $module_handler
      ->expects($this
      ->any())
      ->method('moduleExists')
      ->will($this
      ->returnCallback(function ($module) use ($module_dirs) {
      return isset($module_dirs[$module]);
    }));
    $pluginDiscovery = new YamlDiscovery('links.task', $module_dirs);
    $pluginDiscovery = new ContainerDerivativeDiscoveryDecorator($pluginDiscovery);
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'discovery');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $pluginDiscovery);
    $method = new \ReflectionMethod('Drupal\\Core\\Menu\\LocalTaskManager', 'alterInfo');
    $method
      ->setAccessible(TRUE);
    $method
      ->invoke($manager, 'local_tasks');
    $plugin_stub = $this
      ->createMock('Drupal\\Core\\Menu\\LocalTaskInterface');
    $factory = $this
      ->createMock('Drupal\\Component\\Plugin\\Factory\\FactoryInterface');
    $factory
      ->expects($this
      ->any())
      ->method('createInstance')
      ->will($this
      ->returnValue($plugin_stub));
    $property = new \ReflectionProperty('Drupal\\Core\\Menu\\LocalTaskManager', 'factory');
    $property
      ->setAccessible(TRUE);
    $property
      ->setValue($manager, $factory);
    $cache_backend = $this
      ->createMock('Drupal\\Core\\Cache\\CacheBackendInterface');
    $manager
      ->setCacheBackend($cache_backend, 'local_task.en', [
      'local_task',
    ]);
    return $manager;
  }

  /**
   * Tests integration for local tasks.
   *
   * @param $route_name
   *   Route name to base task building on.
   * @param $expected_tasks
   *   A list of tasks groups by level expected at the given route
   * @param array $route_params
   *   (optional) A list of route parameters used to resolve tasks.
   */
  protected function assertLocalTasks($route_name, $expected_tasks, $route_params = []) {
    $directory_list = [];
    foreach ($this->directoryList as $key => $value) {
      $directory_list[$key] = $this->root . '/' . $value;
    }
    $manager = $this
      ->getLocalTaskManager($directory_list, $route_name, $route_params);
    $tmp_tasks = $manager
      ->getLocalTasksForRoute($route_name);

    // At this point we're just testing existence so pull out keys and then
    // compare.
    //
    // Deeper testing would require a functioning factory which because we are
    // using the DefaultPluginManager base means we get into dependency soup
    // because its factories create method and pulling services off the \Drupal
    // container.
    $tasks = [];
    foreach ($tmp_tasks as $level => $level_tasks) {
      $tasks[$level] = array_keys($level_tasks);
    }
    $this
      ->assertEquals($expected_tasks, $tasks);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
LocalTaskIntegrationTestBase::$container	protected	property	The container.
LocalTaskIntegrationTestBase::$directoryList	protected	property	A list of module directories used for YAML searching.
LocalTaskIntegrationTestBase::$moduleHandler	protected	property	The module handler.
LocalTaskIntegrationTestBase::assertLocalTasks	protected	function	Tests integration for local tasks.
LocalTaskIntegrationTestBase::getLocalTaskManager	protected	function	Sets up the local task manager for the test.
LocalTaskIntegrationTestBase::setUp	protected	function	Overrides UnitTestCase::setUp	14
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.