class LocalTasksTest

class LocalTasksTest extends BrowserTestBase {
    use TaxonomyTestTrait;
    
    /**
     * Modules to enable.
     *
     * @var string[]
     */
    protected static $modules = [
        'block',
        'menu_test',
        'entity_test',
        'node',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'starterkit_theme';
    
    /**
     * The local tasks block under testing.
     *
     * @var \Drupal\block\Entity\Block
     */
    protected $sut;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->sut = $this->drupalPlaceBlock('local_tasks_block', [
            'id' => 'tabs_block',
        ]);
    }
    
    /**
     * Asserts local tasks in the page output.
     *
     * @param array $routes
     *   A list of expected local tasks, prepared as an array of route names and
     *   their associated route parameters, to assert on the page (in the given
     *   order).
     * @param int $level
     *   (optional) The local tasks level to assert; 0 for primary, 1 for
     *   secondary. Defaults to 0.
     *
     * @internal
     */
    protected function assertLocalTasks(array $routes, int $level = 0) : void {
        $elements = $this->xpath('//*[contains(@class, :class)]//a', [
            ':class' => $level == 0 ? 'tabs primary' : 'tabs secondary',
        ]);
        $this->assertGreaterThan(0, count($elements), 'Local tasks found.');
        foreach ($routes as $index => $route_info) {
            [
                $route_name,
                $route_parameters,
            ] = $route_info;
            $expected = Url::fromRoute($route_name, $route_parameters)->toString();
            $this->assertEquals($expected, $elements[$index]->getAttribute('href'), "Task " . ($index + 1) . "number href " . $elements[$index]->getAttribute('href') . " equals {$expected}.");
        }
        $this->assertEquals(count($routes), count($elements), 'Only expected local tasks are found.');
    }
    
    /**
     * Ensures that some local task appears.
     *
     * @param string $title
     *   The expected title.
     *
     * @internal
     */
    protected function assertLocalTaskAppears(string $title) : void {
        // SimpleXML gives us the unescaped text, not the actual escaped markup,
        // so use a pattern instead to check the raw content.
        // This behavior is a bug in libxml, see
        // https://bugs.php.net/bug.php?id=49437.
        $this->assertSession()
            ->responseMatches('@<a [^>]*>' . preg_quote($title, '@') . '</a>@');
    }
    
    /**
     * Asserts that the local tasks on the specified level are not being printed.
     *
     * @param int $level
     *   (optional) The local tasks level to assert; 0 for primary, 1 for
     *   secondary. Defaults to 0.
     *
     * @internal
     */
    protected function assertNoLocalTasks(int $level = 0) : void {
        $this->assertSession()
            ->elementNotExists('xpath', '//*[contains(@class, "' . ($level == 0 ? 'tabs primary' : 'tabs secondary') . '")]//a');
    }
    
    /**
     * Tests the plugin based local tasks.
     */
    public function testPluginLocalTask() : void {
        // Verify local tasks defined in the hook.
        $this->drupalGet(Url::fromRoute('menu_test.tasks_default'));
        $this->assertLocalTasks([
            [
                'menu_test.tasks_default',
                [],
            ],
            [
                'menu_test.router_test1',
                [
                    'bar' => 'unsafe',
                ],
            ],
            [
                'menu_test.router_test1',
                [
                    'bar' => '1',
                ],
            ],
            [
                'menu_test.router_test2',
                [
                    'bar' => '2',
                ],
            ],
        ]);
        // Verify that script tags are escaped on output.
        $title = Html::escape("Task 1 <script>alert('Welcome to the jungle!')</script>");
        $this->assertLocalTaskAppears($title);
        $title = Html::escape("<script>alert('Welcome to the derived jungle!')</script>");
        $this->assertLocalTaskAppears($title);
        // Verify that local tasks appear as defined in the router.
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_view'));
        $this->assertLocalTasks([
            [
                'menu_test.local_task_test_tasks_view',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_edit',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_dynamic',
                [],
            ],
        ]);
        $title = Html::escape("<script>alert('Welcome to the jungle!')</script>");
        $this->assertLocalTaskAppears($title);
        // Ensure the view tab is active.
        $this->assertSession()
            ->elementsCount('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]/a', 1);
        $this->assertSession()
            ->elementTextEquals('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]/a', 'View');
        // Verify that local tasks in the second level appear.
        $sub_tasks = [
            [
                'menu_test.local_task_test_tasks_settings_sub1',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_sub2',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_sub3',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_derived',
                [
                    'placeholder' => 'derive1',
                ],
            ],
            [
                'menu_test.local_task_test_tasks_settings_derived',
                [
                    'placeholder' => 'derive2',
                ],
            ],
        ];
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_settings'));
        $this->assertLocalTasks($sub_tasks, 1);
        $this->assertSession()
            ->elementsCount('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]/a', 1);
        $this->assertSession()
            ->elementTextEquals('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]/a', 'Settings');
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_settings_sub1'));
        $this->assertLocalTasks($sub_tasks, 1);
        $xpath = '//ul[contains(@class, "tabs")]//a[contains(@class, "active")]';
        $this->assertSession()
            ->elementsCount('xpath', $xpath, 2);
        $links = $this->xpath($xpath);
        $this->assertEquals('Settings', $links[0]->getText(), 'The settings tab is active.');
        $this->assertEquals('Dynamic title for TestTasksSettingsSub1', $links[1]->getText(), 'The sub1 tab is active.');
        $this->assertSession()
            ->responseHeaderContains('X-Drupal-Cache-Tags', 'kittens:ragdoll');
        $this->assertSession()
            ->responseHeaderContains('X-Drupal-Cache-Tags', 'kittens:dwarf-cat');
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_settings_derived', [
            'placeholder' => 'derive1',
        ]));
        $this->assertLocalTasks($sub_tasks, 1);
        $result = $this->xpath('//ul[contains(@class, "tabs")]//li[contains(@class, "active")]');
        $this->assertCount(2, $result, 'There are tabs active on both levels.');
        $this->assertEquals('Settings', $result[0]->getText(), 'The settings tab is active.');
        $this->assertEquals('Derive 1', $result[1]->getText(), 'The derive1 tab is active.');
        // Ensures that the local tasks contains the proper 'provider key'
        $definitions = $this->container
            ->get('plugin.manager.menu.local_task')
            ->getDefinitions();
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_view']['provider']);
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_edit']['provider']);
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_settings']['provider']);
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_settings_sub1']['provider']);
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_settings_sub2']['provider']);
        $this->assertEquals('menu_test', $definitions['menu_test.local_task_test_tasks_settings_sub3']['provider']);
        // Test that we correctly apply the active class to tabs where one of the
        // request attributes is upcast to an entity object.
        $entity = \Drupal::entityTypeManager()->getStorage('entity_test')
            ->create([
            'bundle' => 'test',
        ]);
        $entity->save();
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_upcasting_sub1', [
            'entity_test' => '1',
        ]));
        $tasks = [
            [
                'menu_test.local_task_test_upcasting_sub1',
                [
                    'entity_test' => '1',
                ],
            ],
            [
                'menu_test.local_task_test_upcasting_sub2',
                [
                    'entity_test' => '1',
                ],
            ],
        ];
        $this->assertLocalTasks($tasks, 0);
        $this->assertSession()
            ->elementsCount('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]', 1);
        $this->assertSession()
            ->elementTextEquals('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]', 'upcasting sub1');
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_upcasting_sub2', [
            'entity_test' => '1',
        ]));
        $tasks = [
            [
                'menu_test.local_task_test_upcasting_sub1',
                [
                    'entity_test' => '1',
                ],
            ],
            [
                'menu_test.local_task_test_upcasting_sub2',
                [
                    'entity_test' => '1',
                ],
            ],
        ];
        $this->assertLocalTasks($tasks, 0);
        $this->assertSession()
            ->elementsCount('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]', 1);
        $this->assertSession()
            ->elementTextEquals('xpath', '//ul[contains(@class, "tabs")]//li[contains(@class, "active")]', 'upcasting sub2');
    }
    
    /**
     * Tests that local task blocks are configurable to show a specific level.
     */
    public function testLocalTaskBlock() : void {
        // Remove the default block and create a new one.
        $this->sut
            ->delete();
        $this->sut = $this->drupalPlaceBlock('local_tasks_block', [
            'id' => 'tabs_block',
            'primary' => TRUE,
            'secondary' => FALSE,
        ]);
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_settings'));
        // Verify that local tasks in the first level appear.
        $this->assertLocalTasks([
            [
                'menu_test.local_task_test_tasks_view',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_edit',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_dynamic',
                [],
            ],
        ]);
        // Verify that local tasks in the second level doesn't appear.
        $this->assertNoLocalTasks(1);
        $this->sut
            ->delete();
        $this->sut = $this->drupalPlaceBlock('local_tasks_block', [
            'id' => 'tabs_block',
            'primary' => FALSE,
            'secondary' => TRUE,
        ]);
        $this->drupalGet(Url::fromRoute('menu_test.local_task_test_tasks_settings'));
        // Verify that local tasks in the first level doesn't appear.
        $this->assertNoLocalTasks(0);
        // Verify that local tasks in the second level appear.
        $sub_tasks = [
            [
                'menu_test.local_task_test_tasks_settings_sub1',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_sub2',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_sub3',
                [],
            ],
            [
                'menu_test.local_task_test_tasks_settings_derived',
                [
                    'placeholder' => 'derive1',
                ],
            ],
            [
                'menu_test.local_task_test_tasks_settings_derived',
                [
                    'placeholder' => 'derive2',
                ],
            ],
        ];
        $this->assertLocalTasks($sub_tasks, 1);
    }
    
    /**
     * Tests that local tasks blocks cache is invalidated correctly.
     */
    public function testLocalTaskBlockCache() : void {
        $this->drupalLogin($this->drupalCreateUser([
            'administer content types',
            'administer permissions',
            'administer account settings',
        ]));
        $this->drupalCreateContentType([
            'type' => 'page',
        ]);
        // Only the Edit task. The block avoids showing a single tab.
        $this->drupalGet('/admin/config/people/accounts');
        $this->assertSession()
            ->statusCodeEquals(200);
        $this->assertNoLocalTasks();
        // Only the Edit and Manage permission tabs.
        $this->drupalGet('/admin/structure/types/manage/page');
        $this->assertLocalTasks([
            [
                'entity.node_type.edit_form',
                [
                    'node_type' => 'page',
                ],
            ],
            [
                'entity.node_type.entity_permissions_form',
                [
                    'node_type' => 'page',
                ],
            ],
        ]);
        // Field UI adds the usual Manage fields etc tabs.
        \Drupal::service('module_installer')->install([
            'field_ui',
        ]);
        $this->drupalLogin($this->drupalCreateUser([
            'administer content types',
            'administer permissions',
            'administer account settings',
            'administer display modes',
            'administer node display',
            'administer node fields',
            'administer node form display',
        ]));
        $this->drupalGet('/admin/structure/types/manage/page');
        $this->assertLocalTasks([
            [
                'entity.node_type.edit_form',
                [
                    'node_type' => 'page',
                ],
            ],
            [
                'entity.node.field_ui_fields',
                [
                    'node_type' => 'page',
                ],
            ],
            [
                'entity.entity_form_display.node.default',
                [
                    'node_type' => 'page',
                ],
            ],
            [
                'entity.entity_view_display.node.default',
                [
                    'node_type' => 'page',
                ],
            ],
            [
                'entity.node_type.entity_permissions_form',
                [
                    'node_type' => 'page',
                ],
            ],
        ]);
    }
    
    /**
     * Tests local task block URLs for entities with path aliases.
     */
    public function testLocalTaskBlockUrl() : void {
        // Install the necessary modules for the test.
        \Drupal::service('module_installer')->install([
            'path',
            'taxonomy',
        ]);
        $this->drupalCreateContentType([
            'type' => 'article',
        ]);
        $vocab = $this->createVocabulary([
            'vid' => 'tags',
        ]);
        $web_user = $this->drupalCreateUser([
            'create article content',
            'edit own article content',
            'create url aliases',
            'create terms in tags',
            'edit terms in tags',
        ]);
        // Create node and taxonomy term entities with path aliases.
        $entities = [
            'node' => $this->drupalCreateNode([
                'type' => 'article',
                'path' => [
                    'alias' => '/original-node-alias',
                ],
                'uid' => $web_user->id(),
            ]),
            'term' => $this->createTerm($vocab, [
                'path' => [
                    'alias' => '/original-term-alias',
                ],
                'uid' => $web_user->id(),
            ]),
        ];
        $this->drupalLogin($web_user);
        // Test the local task block URLs for both node and term entities.
        foreach ($entities as $entity_type => $entity) {
            $this->drupalGet($entity->toUrl());
            $this->assertSameLocalTaskUrl('/original-' . $entity_type . '-alias');
            $this->drupalGet($entity->toUrl('edit-form'));
            $new_alias = '/original-' . $entity_type . '-alias-updated';
            $edit = [
                'path[0][alias]' => $new_alias,
            ];
            $this->submitForm($edit, 'Save');
            $this->assertSameLocalTaskUrl($new_alias);
            $this->drupalGet($entity->toUrl('edit-form'));
            $this->assertSameLocalTaskUrl($new_alias);
        }
    }
    
    /**
     * Asserts that the local task URL matches the expected alias.
     *
     * @param string $alias
     *   The expected path alias.
     */
    protected function assertSameLocalTaskUrl(string $alias) : void {
        // Assert that the href attribute of the 'View' link contains the expected
        // alias.
        $link = $this->assertSession()
            ->elementExists('xpath', '//a[text()="View"]');
        $this->assertStringContainsString($alias, $link->getAttribute('href'));
    }

}