WorkspaceCRUDTest.php

<?php

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

use Drupal\Core\Entity\EntityStorageException;
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 CRUD operations for workspaces.
 *
 * @group workspaces
 */
class WorkspaceCRUDTest extends KernelTestBase {
  use UserCreationTrait;
  use NodeCreationTrait;
  use ContentTypeCreationTrait;
  use WorkspaceTestTrait;
  
  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;
  
  /**
   * The state service.
   *
   * @var \Drupal\Core\State\StateInterface
   */
  protected $state;
  
  /**
   * The workspace replication manager.
   *
   * @var \Drupal\workspaces\WorkspaceManagerInterface
   */
  protected $workspaceManager;
  
  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'user',
    'system',
    'workspaces',
    'field',
    'filter',
    'node',
    'text',
  ];
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->setUpCurrentUser();
    $this->installSchema('node', [
      'node_access',
    ]);
    $this->installEntitySchema('workspace');
    $this->installSchema('workspaces', [
      'workspace_association',
    ]);
    $this->installEntitySchema('node');
    $this->installConfig([
      'filter',
      'node',
      'system',
    ]);
    $this->createContentType([
      'type' => 'page',
    ]);
    $this->entityTypeManager = \Drupal::entityTypeManager();
    $this->state = \Drupal::state();
    $this->workspaceManager = \Drupal::service('workspaces.manager');
  }
  
  /**
   * Tests the deletion of workspaces.
   */
  public function testDeletingWorkspaces() : void {
    $admin = $this->createUser([
      'administer nodes',
      'create workspace',
      'view any workspace',
      'edit any workspace',
      'delete any workspace',
    ]);
    $this->setCurrentUser($admin);
    /** @var \Drupal\workspaces\WorkspaceAssociationInterface $workspace_association */
    $workspace_association = \Drupal::service('workspaces.association');
    // Create a workspace with a very small number of associated node revisions.
    $workspace_1 = Workspace::create([
      'id' => 'gibbon',
      'label' => 'Gibbon',
    ]);
    $workspace_1->save();
    $this->workspaceManager
      ->setActiveWorkspace($workspace_1);
    $workspace_1_node_1 = $this->createNode([
      'status' => FALSE,
    ]);
    $workspace_1_node_2 = $this->createNode([
      'status' => FALSE,
    ]);
    // Check that the workspace tracks the initial revisions for both nodes.
    $initial_revisions = $workspace_association->getAssociatedInitialRevisions($workspace_1->id(), 'node');
    $this->assertCount(2, $initial_revisions);
    for ($i = 0; $i < 4; $i++) {
      $workspace_1_node_1->setNewRevision(TRUE);
      $workspace_1_node_1->save();
      $workspace_1_node_2->setNewRevision(TRUE);
      $workspace_1_node_2->save();
    }
    // The workspace should now track 2 nodes.
    $tracked_entities = $workspace_association->getTrackedEntities($workspace_1->id());
    $this->assertCount(2, $tracked_entities['node']);
    // Since all the revisions were created inside a workspace, including the
    // default one, 'workspace_1' should be tracking all 10 revisions.
    $associated_revisions = $workspace_association->getAssociatedRevisions($workspace_1->id(), 'node');
    $this->assertCount(10, $associated_revisions);
    // Check that we are allowed to delete the workspace.
    $this->assertTrue($workspace_1->access('delete', $admin));
    // Delete the workspace and check that all the workspace_association
    // entities and all the node revisions have been deleted as well.
    $workspace_1->delete();
    // There are no more tracked entities in 'workspace_1'.
    $tracked_entities = $workspace_association->getTrackedEntities($workspace_1->id());
    $this->assertEmpty($tracked_entities);
    // There are no more revisions associated with 'workspace_1'.
    $associated_revisions = $workspace_association->getAssociatedRevisions($workspace_1->id(), 'node');
    $this->assertCount(0, $associated_revisions);
    // Create another workspace, this time with a larger number of associated
    // node revisions so we can test the batch purge process.
    $workspace_2 = Workspace::create([
      'id' => 'baboon',
      'label' => 'Baboon',
    ]);
    $workspace_2->save();
    $this->workspaceManager
      ->setActiveWorkspace($workspace_2);
    $workspace_2_node_1 = $this->createNode([
      'status' => FALSE,
    ]);
    for ($i = 0; $i < 59; $i++) {
      $workspace_2_node_1->setNewRevision(TRUE);
      $workspace_2_node_1->save();
    }
    // Now there is one entity tracked in 'workspace_2'.
    $tracked_entities = $workspace_association->getTrackedEntities($workspace_2->id());
    $this->assertCount(1, $tracked_entities['node']);
    // All 60 are associated with 'workspace_2'.
    $associated_revisions = $workspace_association->getAssociatedRevisions($workspace_2->id(), 'node', [
      $workspace_2_node_1->id(),
    ]);
    $this->assertCount(60, $associated_revisions);
    // Delete the workspace and check that we still have 10 revision left to
    // delete.
    $workspace_2->delete();
    $associated_revisions = $workspace_association->getAssociatedRevisions($workspace_2->id(), 'node', [
      $workspace_2_node_1->id(),
    ]);
    $this->assertCount(10, $associated_revisions);
    $workspace_deleted = \Drupal::state()->get('workspace.deleted');
    $this->assertCount(1, $workspace_deleted);
    // Check that we can not create another workspace with the same ID while its
    // data purging is not finished.
    $workspace_3 = Workspace::create([
      'id' => 'baboon',
      'label' => 'Baboon',
    ]);
    $violations = $workspace_3->validate();
    $this->assertCount(1, $violations);
    $this->assertEquals('A workspace with this ID has been deleted but data still exists for it.', $violations[0]->getMessage());
    // Running cron should delete the remaining data as well as the workspace ID
    // from the "workspace.delete" state entry.
    \Drupal::service('cron')->run();
    // Check that the actual node revisions were deleted as well.
    $node_storage = $this->entityTypeManager
      ->getStorage('node');
    $this->assertEmpty($node_storage->loadMultipleRevisions(array_keys($associated_revisions)));
    // 'workspace_2 'is empty now.
    $associated_revisions = $workspace_association->getAssociatedRevisions($workspace_2->id(), 'node', [
      $workspace_2_node_1->id(),
    ]);
    $this->assertCount(0, $associated_revisions);
    $tracked_entities = $workspace_association->getTrackedEntities($workspace_2->id());
    $this->assertCount(0, $tracked_entities);
    $workspace_deleted = \Drupal::state()->get('workspace.deleted');
    $this->assertCount(0, $workspace_deleted);
    // Check that the deleted workspace is no longer active.
    $this->assertFalse($this->workspaceManager
      ->hasActiveWorkspace());
  }
  
  /**
   * Tests that deleting a workspace keeps its already published content.
   */
  public function testDeletingPublishedWorkspace() : void {
    $admin = $this->createUser([
      'administer nodes',
      'create workspace',
      'view own workspace',
      'edit own workspace',
      'delete own workspace',
    ]);
    $this->setCurrentUser($admin);
    $live_workspace = Workspace::create([
      'id' => 'live',
      'label' => 'Live',
    ]);
    $live_workspace->save();
    $workspace = Workspace::create([
      'id' => 'stage',
      'label' => 'Stage',
    ]);
    $workspace->save();
    $this->workspaceManager
      ->setActiveWorkspace($workspace);
    // Create a new node in the 'stage' workspace
    $node = $this->createNode([
      'status' => TRUE,
    ]);
    // Create an additional workspace-specific revision for the node.
    $node->setNewRevision(TRUE);
    $node->save();
    // The node should have 3 revisions now: a default and 2 pending ones.
    $revisions = $this->entityTypeManager
      ->getStorage('node')
      ->loadMultipleRevisions([
      1,
      2,
      3,
    ]);
    $this->assertCount(3, $revisions);
    $this->assertTrue($revisions[1]->isDefaultRevision());
    $this->assertFalse($revisions[2]->isDefaultRevision());
    $this->assertFalse($revisions[3]->isDefaultRevision());
    // Publish the workspace, which should mark revision 3 as the default one
    // and keep revision 2 as a 'source' draft revision.
    $workspace->publish();
    $revisions = $this->entityTypeManager
      ->getStorage('node')
      ->loadMultipleRevisions([
      1,
      2,
      3,
    ]);
    $this->assertFalse($revisions[1]->isDefaultRevision());
    $this->assertFalse($revisions[2]->isDefaultRevision());
    $this->assertTrue($revisions[3]->isDefaultRevision());
    // Create two new workspace-revisions for the node.
    $node->setNewRevision(TRUE);
    $node->save();
    $node->setNewRevision(TRUE);
    $node->save();
    // The node should now have 5 revisions.
    $revisions = $this->entityTypeManager
      ->getStorage('node')
      ->loadMultipleRevisions([
      1,
      2,
      3,
      4,
      5,
    ]);
    $this->assertFalse($revisions[1]->isDefaultRevision());
    $this->assertFalse($revisions[2]->isDefaultRevision());
    $this->assertTrue($revisions[3]->isDefaultRevision());
    $this->assertFalse($revisions[4]->isDefaultRevision());
    $this->assertFalse($revisions[5]->isDefaultRevision());
    // Delete the workspace and check that only the two new pending revisions
    // were deleted by the workspace purging process.
    $workspace->delete();
    $revisions = $this->entityTypeManager
      ->getStorage('node')
      ->loadMultipleRevisions([
      1,
      2,
      3,
      4,
      5,
    ]);
    $this->assertCount(3, $revisions);
    $this->assertFalse($revisions[1]->isDefaultRevision());
    $this->assertFalse($revisions[2]->isDefaultRevision());
    $this->assertTrue($revisions[3]->isDefaultRevision());
    $this->assertFalse(isset($revisions[4]));
    $this->assertFalse(isset($revisions[5]));
  }
  
  /**
   * Tests that a workspace with children can not be deleted.
   */
  public function testDeletingWorkspaceWithChildren() : void {
    $stage = Workspace::create([
      'id' => 'stage',
      'label' => 'Stage',
    ]);
    $stage->save();
    $dev = Workspace::create([
      'id' => 'dev',
      'label' => 'Dev',
      'parent' => 'stage',
    ]);
    $dev->save();
    // Check that a workspace which has children can not be deleted.
    try {
      $stage->delete();
      $this->fail('The Stage workspace has children and should not be deletable.');
    } catch (EntityStorageException $e) {
      $this->assertEquals('The Stage workspace can not be deleted because it has child workspaces.', $e->getMessage());
      $this->assertNotNull(Workspace::load('stage'));
    }
    // Check that if we delete its child first, the parent workspace can also be
    // deleted.
    $dev->delete();
    $stage->delete();
    $this->assertNull(Workspace::load('dev'));
    $this->assertNull(Workspace::load('stage'));
  }
  
  /**
   * Tests loading the workspace tree when there are no workspaces available.
   */
  public function testEmptyWorkspaceTree() : void {
    $tree = \Drupal::service('workspaces.repository')->loadTree();
    $this->assertSame([], $tree);
  }

}