VariantCollectionTraitTest.php

<?php

namespace Drupal\Tests\ctools\Unit;

use Prophecy\PhpUnit\ProphecyTrait;
use Drupal\Component\Plugin\PluginManagerInterface;
use Drupal\Component\Uuid\UuidInterface;
use Drupal\Core\DependencyInjection\ContainerBuilder;
use Drupal\Core\Display\VariantInterface;
use Drupal\ctools\Plugin\VariantCollectionTrait;
use Drupal\ctools\Plugin\VariantPluginCollection;
use Drupal\Tests\UnitTestCase;

/**
 * Tests the methods of a variant-aware class.
 *
 * @coversDefaultClass \Drupal\ctools\Plugin\VariantCollectionTrait
 *
 * @group Ctools
 */
class VariantCollectionTraitTest extends UnitTestCase {
  use ProphecyTrait;
  
  /**
   * @var \Drupal\Component\Plugin\PluginManagerInterface|\PHPUnit\Framework\MockObject\MockObject
   */
  protected $manager;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $container = new ContainerBuilder();
    $this->manager = $this->prophesize(PluginManagerInterface::class);
    $container->set('plugin.manager.display_variant', $this->manager
      ->reveal());
    \Drupal::setContainer($container);
  }
  
  /**
   * @covers ::getVariants
   */
  public function testGetVariantsEmpty() {
    $trait_object = new TestVariantCollectionTrait();
    $this->manager
      ->createInstance()
      ->shouldNotBeCalled();
    $variants = $trait_object->getVariants();
    $this->assertInstanceOf(VariantPluginCollection::class, $variants);
    $this->assertSame(0, count($variants));
  }
  
  /**
   * @covers ::getVariants
   */
  public function testGetVariants() {
    $trait_object = new TestVariantCollectionTrait();
    $config = [
      'foo' => [
        'id' => 'foo_plugin',
      ],
      'bar' => [
        'id' => 'bar_plugin',
      ],
    ];
    foreach ($config as $value) {
      $plugin = $this->prophesize(VariantInterface::class);
      $this->manager
        ->createInstance($value['id'], $value)
        ->willReturn($plugin->reveal());
    }
    $trait_object->setVariantConfig($config);
    $variants = $trait_object->getVariants();
    $this->assertInstanceOf(VariantPluginCollection::class, $variants);
    $this->assertSame(2, count($variants));
    return $variants;
  }
  
  /**
   * @covers ::getVariants
   *
   * @depends testGetVariants
   */
  public function testGetVariantsSort(VariantPluginCollection $variants) {
    $this->assertEquals([
      'bar' => 'bar',
      'foo' => 'foo',
    ], $variants->getInstanceIds());
  }
  
  /**
   * @covers ::addVariant
   */
  public function testAddVariant() {
    $config = [
      'id' => 'foo',
    ];
    $uuid = 'test-uuid';
    $expected_config = $config + [
      'uuid' => $uuid,
    ];
    $uuid_generator = $this->prophesize(UuidInterface::class);
    $uuid_generator->generate()
      ->willReturn($uuid)
      ->shouldBeCalledTimes(1);
    $trait_object = new TestVariantCollectionTrait();
    $trait_object->setUuidGenerator($uuid_generator->reveal());
    $plugin_prophecy = $this->prophesize(VariantInterface::class);
    $plugin_prophecy->getConfiguration()
      ->willReturn($expected_config)
      ->shouldBeCalled();
    $plugin_prophecy->setConfiguration($expected_config)
      ->willReturn($expected_config)
      ->shouldBeCalled();
    $this->manager
      ->createInstance('foo', $expected_config)
      ->willReturn($plugin_prophecy->reveal());
    $resulting_uuid = $trait_object->addVariant($config);
    $this->assertSame($uuid, $resulting_uuid);
    $variants = $trait_object->getVariants();
    $this->assertSame([
      $uuid => $uuid,
    ], $variants->getInstanceIds());
    $this->assertSame([
      $uuid => $expected_config,
    ], $variants->getConfiguration());
    $this->assertSame($plugin_prophecy->reveal(), $variants->get($uuid));
    return [
      $trait_object,
      $uuid,
      $plugin_prophecy->reveal(),
    ];
  }
  
  /**
   * @covers ::getVariant
   *
   * @depends testAddVariant
   */
  public function testGetVariant($data) {
    [$trait_object, $uuid, $plugin] = $data;
    $this->manager
      ->createInstance()
      ->shouldNotBeCalled();
    $this->assertSame($plugin, $trait_object->getVariant($uuid));
    return [
      $trait_object,
      $uuid,
    ];
  }
  
  /**
   * @covers ::removeVariant
   *
   * @depends testGetVariant
   */
  public function testRemoveVariant($data) {
    [$trait_object, $uuid] = $data;
    $this->assertSame($trait_object, $trait_object->removeVariant($uuid));
    $this->assertFalse($trait_object->getVariants()
      ->has($uuid));
    return [
      $trait_object,
      $uuid,
    ];
  }
  
  /**
   * @covers ::getVariant
   *
   * @depends testRemoveVariant
   */
  public function testGetVariantException($data) {
    [$trait_object, $uuid] = $data;
    // Attempt to retrieve a variant that has been removed.
    $this->expectException('\\Drupal\\Component\\Plugin\\Exception\\PluginNotFoundException');
    $this->expectExceptionMessage("Plugin ID 'test-uuid' was not found.");
    $this->assertNull($trait_object->getVariant($uuid));
  }

}

/**
 *
 */
class TestVariantCollectionTrait {
  use VariantCollectionTrait;
  
  /**
   * @var array
   */
  protected $variantConfig = [];
  
  /**
   * @var \Drupal\Component\Uuid\UuidInterface
   */
  protected $uuidGenerator;
  
  /**
   * @param \Drupal\Component\Uuid\UuidInterface $uuid_generator
   *
   * @return $this
   */
  public function setUuidGenerator(UuidInterface $uuid_generator) {
    $this->uuidGenerator = $uuid_generator;
    return $this;
  }
  
  /**
   * {@inheritdoc}
   */
  protected function uuidGenerator() {
    return $this->uuidGenerator;
  }
  
  /**
   * Sets the variant configuration.
   *
   * @param array $config
   *   The variant configuration.
   *
   * @return $this
   */
  public function setVariantConfig(array $config) {
    $this->variantConfig = $config;
    return $this;
  }
  
  /**
   * {@inheritdoc}
   */
  protected function getVariantConfig() {
    return $this->variantConfig;
  }

}