TaxonomyTermContentModerationTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\taxonomy\Functional;

use Drupal\Core\Url;
use Drupal\Tests\content_moderation\Traits\ContentModerationTestTrait;
use Drupal\workflows\Entity\Workflow;

/**
 * Tests taxonomy terms with Content Moderation.
 *
 * @group content_moderation
 * @group taxonomy
 */
class TaxonomyTermContentModerationTest extends TaxonomyTestBase {
    use ContentModerationTestTrait;
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'stark';
    
    /**
     * The vocabulary used for creating terms.
     *
     * @var \Drupal\taxonomy\VocabularyInterface
     */
    protected $vocabulary;
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'content_moderation',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->createEditorialWorkflow();
        $this->drupalLogin($this->drupalCreateUser([
            'administer taxonomy',
            'use editorial transition create_new_draft',
            'use editorial transition publish',
            'view any unpublished content',
            'view latest version',
        ]));
        $this->vocabulary = $this->createVocabulary();
        // Set the vocabulary as moderated.
        $workflow = Workflow::load('editorial');
        $workflow->getTypePlugin()
            ->addEntityTypeAndBundle('taxonomy_term', $this->vocabulary
            ->id());
        $workflow->save();
    }
    
    /**
     * Tests taxonomy term parents on a moderated vocabulary.
     */
    public function testTaxonomyTermParents() : void {
        $assert_session = $this->assertSession();
        // Create a simple hierarchy in the vocabulary, a root term and three parent
        // terms.
        $root = $this->createTerm($this->vocabulary, [
            'langcode' => 'en',
            'moderation_state' => 'published',
        ]);
        $parent_1 = $this->createTerm($this->vocabulary, [
            'langcode' => 'en',
            'moderation_state' => 'published',
            'parent' => $root->id(),
        ]);
        $parent_2 = $this->createTerm($this->vocabulary, [
            'langcode' => 'en',
            'moderation_state' => 'published',
            'parent' => $root->id(),
        ]);
        $parent_3 = $this->createTerm($this->vocabulary, [
            'langcode' => 'en',
            'moderation_state' => 'published',
            'parent' => $root->id(),
        ]);
        // Create a child term and assign one of the parents above.
        $child = $this->createTerm($this->vocabulary, [
            'langcode' => 'en',
            'moderation_state' => 'published',
            'parent' => $parent_1->id(),
        ]);
        
        /** @var \Drupal\taxonomy\TermStorageInterface $taxonomy_storage */
        $taxonomy_storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
        $validation_message = 'You can only change the hierarchy for the published version of this term.';
        // Add a pending revision without changing the term parent.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        $assert_session->pageTextNotContains($validation_message);
        // Add a pending revision and change the parent.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'parent[]' => [
                $parent_2->id(),
            ],
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        // Check that parents were not changed.
        $assert_session->pageTextContains($validation_message);
        $taxonomy_storage->resetCache();
        $this->assertEquals([
            $parent_1->id(),
        ], array_keys($taxonomy_storage->loadParents($child->id())));
        // Add a pending revision and add a new parent.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'parent[]' => [
                $parent_1->id(),
                $parent_3->id(),
            ],
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        // Check that parents were not changed.
        $assert_session->pageTextContains($validation_message);
        $taxonomy_storage->resetCache();
        $this->assertEquals([
            $parent_1->id(),
        ], array_keys($taxonomy_storage->loadParents($child->id())));
        // Add a pending revision and use the root term as a parent.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'parent[]' => [
                $root->id(),
            ],
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        // Check that parents were not changed.
        $assert_session->pageTextContains($validation_message);
        $taxonomy_storage->resetCache();
        $this->assertEquals([
            $parent_1->id(),
        ], array_keys($taxonomy_storage->loadParents($child->id())));
        // Add a pending revision and remove the parent.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'parent[]' => [],
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        // Check that parents were not changed.
        $assert_session->pageTextContains($validation_message);
        $taxonomy_storage->resetCache();
        $this->assertEquals([
            $parent_1->id(),
        ], array_keys($taxonomy_storage->loadParents($child->id())));
        // Add a published revision.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'moderation_state[0][state]' => 'published',
        ], 'Save');
        // Change the parents.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'parent[]' => [
                $parent_2->id(),
            ],
        ], 'Save');
        // Check that parents were changed.
        $assert_session->pageTextNotContains($validation_message);
        $taxonomy_storage->resetCache();
        $this->assertNotEquals([
            $parent_1->id(),
        ], array_keys($taxonomy_storage->loadParents($child->id())));
        // Add a pending revision and change the weight.
        $this->drupalGet($child->toUrl('edit-form'));
        $this->submitForm([
            'weight' => 10,
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        // Check that weight was not changed.
        $assert_session->pageTextContains($validation_message);
        // Add a new term without any parent and publish it.
        $edit = [
            'name[0][value]' => $this->randomMachineName(),
            'moderation_state[0][state]' => 'published',
        ];
        $this->drupalGet(Url::fromRoute('entity.taxonomy_term.add_form', [
            'taxonomy_vocabulary' => $this->vocabulary
                ->id(),
        ]));
        $this->submitForm($edit, 'Save');
        // Add a pending revision without any changes.
        $terms = \Drupal::entityTypeManager()->getStorage('taxonomy_term')
            ->loadByProperties([
            'name' => $edit['name[0][value]'],
        ]);
        $term = reset($terms);
        $this->drupalGet($term->toUrl('edit-form'));
        $this->submitForm([
            'moderation_state[0][state]' => 'draft',
        ], 'Save');
        $assert_session->pageTextNotContains($validation_message);
    }
    
    /**
     * Tests changing field values in pending revisions of taxonomy terms.
     */
    public function testTaxonomyTermPendingRevisions() : void {
        $assert_session = $this->assertSession();
        $default_term_name = 'term - default revision';
        $default_term_description = 'The default revision of a term.';
        $term = $this->createTerm($this->vocabulary, [
            'name' => $default_term_name,
            'description' => $default_term_description,
            'langcode' => 'en',
            'moderation_state' => 'published',
        ]);
        // Add a pending revision without changing the term parent.
        $this->drupalGet($term->toUrl('edit-form'));
        $assert_session->pageTextContains($default_term_name);
        $assert_session->pageTextContains($default_term_description);
        // Check the revision log message field appears on the term edit page.
        $this->drupalGet($term->toUrl('edit-form'));
        $assert_session->fieldExists('revision_log_message[0][value]');
        $pending_term_name = 'term - pending revision';
        $pending_term_description = 'The pending revision of a term.';
        $edit = [
            'name[0][value]' => $pending_term_name,
            'description[0][value]' => $pending_term_description,
            'moderation_state[0][state]' => 'draft',
        ];
        $this->drupalGet($term->toUrl('edit-form'));
        $this->submitForm($edit, 'Save');
        $assert_session->pageTextContains($pending_term_name);
        $assert_session->pageTextContains($pending_term_description);
        $assert_session->pageTextNotContains($default_term_description);
        // Check that the default revision of the term contains the correct values.
        $this->drupalGet('taxonomy/term/' . $term->id());
        $assert_session->pageTextContains($default_term_name);
        $assert_session->pageTextContains($default_term_description);
    }

}