OverridesSectionStorageTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\layout_builder\Kernel;

use Drupal\Core\Plugin\Context\Context;
use Drupal\Core\Plugin\Context\ContextDefinition;
use Drupal\Core\Plugin\Context\EntityContext;
use Drupal\entity_test\Entity\EntityTest;
use Drupal\KernelTests\KernelTestBase;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\layout_builder\DefaultsSectionStorageInterface;
use Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay;
use Drupal\layout_builder\Plugin\SectionStorage\OverridesSectionStorage;
use Drupal\layout_builder\Section;
use Drupal\layout_builder\SectionComponent;
use Drupal\Tests\user\Traits\UserCreationTrait;

/**
 * @coversDefaultClass \Drupal\layout_builder\Plugin\SectionStorage\OverridesSectionStorage
 *
 * @group layout_builder
 */
class OverridesSectionStorageTest extends KernelTestBase {
    use UserCreationTrait;
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'layout_discovery',
        'layout_builder',
        'entity_test',
        'field',
        'system',
        'user',
        'language',
    ];
    
    /**
     * The plugin.
     *
     * @var \Drupal\layout_builder\Plugin\SectionStorage\OverridesSectionStorage
     */
    protected $plugin;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->setUpCurrentUser();
        $this->installEntitySchema('entity_test');
        $definition = $this->container
            ->get('plugin.manager.layout_builder.section_storage')
            ->getDefinition('overrides');
        $this->plugin = OverridesSectionStorage::create($this->container, [], 'overrides', $definition);
    }
    
    /**
     * @covers ::access
     * @dataProvider providerTestAccess
     *
     * @param bool $expected
     *   The expected outcome of ::access().
     * @param bool $is_enabled
     *   Whether Layout Builder is enabled for this display.
     * @param array $section_data
     *   Data to store as the sections value for Layout Builder.
     * @param string[] $permissions
     *   An array of permissions to grant to the user.
     */
    public function testAccess($expected, $is_enabled, array $section_data, array $permissions) : void {
        $display = LayoutBuilderEntityViewDisplay::create([
            'targetEntityType' => 'entity_test',
            'bundle' => 'entity_test',
            'mode' => 'default',
            'status' => TRUE,
        ]);
        if ($is_enabled) {
            $display->enableLayoutBuilder();
        }
        $display->setOverridable()
            ->save();
        $entity = EntityTest::create([
            OverridesSectionStorage::FIELD_NAME => $section_data,
        ]);
        $entity->save();
        $account = $this->setUpCurrentUser([], $permissions);
        $this->plugin
            ->setContext('entity', EntityContext::fromEntity($entity));
        $this->plugin
            ->setContext('view_mode', new Context(new ContextDefinition('string'), 'default'));
        // Check access with both the global current user as well as passing one in.
        $result = $this->plugin
            ->access('view');
        $this->assertSame($expected, $result);
        $result = $this->plugin
            ->access('view', $account);
        $this->assertSame($expected, $result);
        // Create a translation.
        ConfigurableLanguage::createFromLangcode('es')->save();
        $entity = EntityTest::load($entity->id());
        $translation = $entity->addTranslation('es');
        $translation->save();
        $this->plugin
            ->setContext('entity', EntityContext::fromEntity($translation));
        // Perform the same checks again but with a non default translation which
        // should always deny access.
        $result = $this->plugin
            ->access('view');
        $this->assertFalse($result);
        $result = $this->plugin
            ->access('view', $account);
        $this->assertFalse($result);
    }
    
    /**
     * Provides test data for ::testAccess().
     */
    public static function providerTestAccess() {
        $section_data = [
            new Section('layout_onecol', [], [
                '10000000-0000-1000-a000-000000000000' => new SectionComponent('10000000-0000-1000-a000-000000000000', 'content', [
                    'id' => 'foo',
                ]),
            ]),
        ];
        // Data provider values are:
        // - the expected outcome of the call to ::access()
        // - whether Layout Builder has been enabled for this display
        // - any section data
        // - any permissions to grant to the user.
        $data = [];
        $data['disabled, no data, no permissions'] = [
            FALSE,
            FALSE,
            [],
            [],
        ];
        $data['disabled, data, no permissions'] = [
            FALSE,
            FALSE,
            $section_data,
            [],
        ];
        $data['enabled, no data, no permissions'] = [
            FALSE,
            TRUE,
            [],
            [],
        ];
        $data['enabled, data, no permissions'] = [
            FALSE,
            TRUE,
            $section_data,
            [],
        ];
        $data['enabled, no data, configure any layout'] = [
            TRUE,
            TRUE,
            [],
            [
                'configure any layout',
            ],
        ];
        $data['enabled, data, configure any layout'] = [
            TRUE,
            TRUE,
            $section_data,
            [
                'configure any layout',
            ],
        ];
        $data['enabled, no data, bundle overrides'] = [
            TRUE,
            TRUE,
            [],
            [
                'configure all entity_test entity_test layout overrides',
            ],
        ];
        $data['enabled, data, bundle overrides'] = [
            TRUE,
            TRUE,
            $section_data,
            [
                'configure all entity_test entity_test layout overrides',
            ],
        ];
        $data['enabled, no data, bundle edit overrides, no edit access'] = [
            FALSE,
            TRUE,
            [],
            [
                'configure editable entity_test entity_test layout overrides',
            ],
        ];
        $data['enabled, data, bundle edit overrides, no edit access'] = [
            FALSE,
            TRUE,
            $section_data,
            [
                'configure editable entity_test entity_test layout overrides',
            ],
        ];
        $data['enabled, no data, bundle edit overrides, edit access'] = [
            TRUE,
            TRUE,
            [],
            [
                'configure editable entity_test entity_test layout overrides',
                'administer entity_test content',
            ],
        ];
        $data['enabled, data, bundle edit overrides, edit access'] = [
            TRUE,
            TRUE,
            $section_data,
            [
                'configure editable entity_test entity_test layout overrides',
                'administer entity_test content',
            ],
        ];
        return $data;
    }
    
    /**
     * @covers ::getContexts
     */
    public function testGetContexts() : void {
        $entity = EntityTest::create();
        $entity->save();
        $context = EntityContext::fromEntity($entity);
        $this->plugin
            ->setContext('entity', $context);
        $expected = [
            'entity',
            'view_mode',
        ];
        $result = $this->plugin
            ->getContexts();
        $this->assertEquals($expected, array_keys($result));
        $this->assertSame($context, $result['entity']);
    }
    
    /**
     * @covers ::getContextsDuringPreview
     */
    public function testGetContextsDuringPreview() : void {
        $entity = EntityTest::create();
        $entity->save();
        $context = EntityContext::fromEntity($entity);
        $this->plugin
            ->setContext('entity', $context);
        $expected = [
            'view_mode',
            'layout_builder.entity',
        ];
        $result = $this->plugin
            ->getContextsDuringPreview();
        $this->assertEquals($expected, array_keys($result));
        $this->assertSame($context, $result['layout_builder.entity']);
    }
    
    /**
     * @covers ::getDefaultSectionStorage
     */
    public function testGetDefaultSectionStorage() : void {
        $entity = EntityTest::create();
        $entity->save();
        $this->plugin
            ->setContext('entity', EntityContext::fromEntity($entity));
        $this->plugin
            ->setContext('view_mode', new Context(ContextDefinition::create('string'), 'default'));
        $this->assertInstanceOf(DefaultsSectionStorageInterface::class, $this->plugin
            ->getDefaultSectionStorage());
    }
    
    /**
     * @covers ::getTempstoreKey
     */
    public function testGetTempstoreKey() : void {
        $entity = EntityTest::create();
        $entity->save();
        $this->plugin
            ->setContext('entity', EntityContext::fromEntity($entity));
        $this->plugin
            ->setContext('view_mode', new Context(new ContextDefinition('string'), 'default'));
        $result = $this->plugin
            ->getTempstoreKey();
        $this->assertSame('entity_test.1.default.en', $result);
    }
    
    /**
     * @covers ::deriveContextsFromRoute
     */
    public function testDeriveContextsFromRoute() : void {
        $display = LayoutBuilderEntityViewDisplay::create([
            'targetEntityType' => 'entity_test',
            'bundle' => 'entity_test',
            'mode' => 'default',
            'status' => TRUE,
        ]);
        $display->enableLayoutBuilder()
            ->setOverridable()
            ->save();
        $entity = EntityTest::create();
        $entity->save();
        $entity = EntityTest::load($entity->id());
        $result = $this->plugin
            ->deriveContextsFromRoute('entity_test.1', [], '', []);
        $this->assertSame([
            'entity',
            'view_mode',
        ], array_keys($result));
        $this->assertSame($entity, $result['entity']->getContextValue());
        $this->assertSame('default', $result['view_mode']->getContextValue());
    }
    
    /**
     * @covers ::isOverridden
     */
    public function testIsOverridden() : void {
        $display = LayoutBuilderEntityViewDisplay::create([
            'targetEntityType' => 'entity_test',
            'bundle' => 'entity_test',
            'mode' => 'default',
            'status' => TRUE,
        ]);
        $display->enableLayoutBuilder()
            ->setOverridable()
            ->save();
        $entity = EntityTest::create();
        $entity->set(OverridesSectionStorage::FIELD_NAME, [
            new Section('layout_onecol'),
        ]);
        $entity->save();
        $entity = EntityTest::load($entity->id());
        $context = EntityContext::fromEntity($entity);
        $this->plugin
            ->setContext('entity', $context);
        $this->assertTrue($this->plugin
            ->isOverridden());
        $this->plugin
            ->removeSection(0);
        $this->assertTrue($this->plugin
            ->isOverridden());
        $this->plugin
            ->removeAllSections(TRUE);
        $this->assertTrue($this->plugin
            ->isOverridden());
        $this->plugin
            ->removeAllSections();
        $this->assertFalse($this->plugin
            ->isOverridden());
    }

}