WorkspaceEntityDeleteTest.php

<?php

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

use Drupal\KernelTests\KernelTestBase;
use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
use Drupal\Tests\node\Traits\NodeCreationTrait;
use Drupal\Tests\user\Traits\UserCreationTrait;
use Drupal\workspaces\Entity\Workspace;

/**
 * Tests entity deletions with workspaces.
 *
 * @group workspaces
 */
class WorkspaceEntityDeleteTest extends KernelTestBase {
  use UserCreationTrait;
  use NodeCreationTrait;
  use ContentTypeCreationTrait;
  use WorkspaceTestTrait;
  
  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'field',
    'filter',
    'node',
    'system',
    'text',
    'user',
    'workspaces',
  ];
  
  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->entityTypeManager = \Drupal::entityTypeManager();
    $this->workspaceManager = \Drupal::service('workspaces.manager');
    $this->installEntitySchema('node');
    $this->installEntitySchema('workspace');
    $this->installSchema('node', [
      'node_access',
    ]);
    $this->installSchema('workspaces', [
      'workspace_association',
    ]);
    $this->installConfig([
      'filter',
      'node',
      'system',
    ]);
    $this->createContentType([
      'type' => 'page',
    ]);
    $this->setUpCurrentUser([], [
      'access content',
      'create page content',
      'edit any page content',
      'delete any page content',
      'create workspace',
      'view any workspace',
      'edit any workspace',
      'delete any workspace',
    ]);
  }
  
  /**
   * Test entity deletion in a workspace.
   */
  public function testEntityDeletion() : void {
    /** @var \Drupal\workspaces\WorkspaceAssociationInterface $workspace_association */
    $workspace_association = \Drupal::service('workspaces.association');
    $storage = $this->entityTypeManager
      ->getStorage('node');
    $published_live = $this->createNode([
      'title' => 'Test 1 published - live',
      'type' => 'page',
    ]);
    $unpublished_live = $this->createNode([
      'title' => 'Test 2 unpublished - live',
      'type' => 'page',
      'status' => FALSE,
    ]);
    // Create a published and an unpublished node in Stage.
    Workspace::create([
      'id' => 'stage',
      'label' => 'Stage',
    ])->save();
    $this->switchToWorkspace('stage');
    $published_stage = $this->createNode([
      'title' => 'Test 3 published - stage',
      'type' => 'page',
    ]);
    $unpublished_stage = $this->createNode([
      'title' => 'Test 4 unpublished - stage',
      'type' => 'page',
      'status' => FALSE,
    ]);
    $this->assertEquals([
      'node' => [
        4 => 3,
        5 => 4,
      ],
    ], $workspace_association->getTrackedEntities('stage', 'node'));
    $this->assertTrue($published_stage->access('delete'));
    $this->assertTrue($unpublished_stage->access('delete'));
    // While the Stage workspace is active, check that the nodes created in
    // Stage can be deleted, while the ones created in Live can not be deleted.
    $published_stage->delete();
    $this->assertEquals([
      'node' => [
        5 => 4,
      ],
    ], $workspace_association->getTrackedEntities('stage', 'node'));
    $unpublished_stage->delete();
    $this->assertEmpty($workspace_association->getTrackedEntities('stage', 'node'));
    $this->assertEmpty($storage->loadMultiple([
      $published_stage->id(),
      $unpublished_stage->id(),
    ]));
    $this->expectExceptionMessage('This content item can only be deleted in the Live workspace.');
    $this->assertFalse($published_live->access('delete'));
    $this->assertFalse($unpublished_live->access('delete'));
    $published_live->delete();
    $unpublished_live->delete();
    $this->assertNotEmpty($storage->loadMultiple([
      $published_live->id(),
      $unpublished_live->id(),
    ]));
  }

}