reviewer-1.2.x-dev/tests/src/Kernel/BundleEvaluatorTest.php

<?php

declare(strict_types=1);

namespace Drupal\Tests\reviewer\Kernel;

use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\KernelTests\KernelTestBase;
use Drupal\reviewer\Plugin\reviewer\Review\ReviewPluginInterface;
use Drupal\reviewer\Reviewer\BundleEvaluator;
use Drupal\reviewer\Reviewer\Review\ReviewInterface;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;

/**
 * Tests the bundle evaluator.
 */
#[Group('reviewer')]
#[CoversClass(BundleEvaluator::class)]
class BundleEvaluatorTest extends KernelTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'reviewer',
  ];

  /**
   * Test getting all available bundles from an entity review plugin.
   *
   * @throws \Drupal\Component\Plugin\Exception\InvalidPluginDefinitionException
   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
   * @throws \PHPUnit\Framework\MockObject\Exception
   */
  public function testAllBundlesOfReview(): void {
    $entity_type = $this->createMock(EntityTypeInterface::class);
    $entity_type->method('getBundleOf')->willReturn('review');
    $entity_storage = $this->createMock(EntityStorageInterface::class);
    $entity_storage->method('getEntityType')->willReturn($entity_type);
    $entity_type_manager = $this->createMock(EntityTypeManagerInterface::class);
    $entity_type_manager->method('getStorage')->willReturn($entity_storage);
    $entity_bundle_info = $this->createMock(EntityTypeBundleInfoInterface::class);
    $entity_bundle_info->method('getBundleInfo')->willReturn(['one' => [], 'two' => []], ['review' => []]);

    $evaluator = new BundleEvaluator($entity_bundle_info, $entity_type_manager);

    $review = $this->createMock(ReviewPluginInterface::class);
    $review->method('getPluginId')->willReturn('review');
    $review->method('getConfigEntityId')->willReturn('review');
    self::assertSame(['one', 'two'], $evaluator->allBundlesOfReview($review));
    self::assertSame(['review'], $evaluator->allBundlesOfReview($review));

    $bundle_review = $this->createMock(ReviewPluginInterface::class);
    $bundle_review->method('getPluginId')->willReturn('review');
    $bundle_review->method('getConfigEntityId')->willReturn('review');
    $bundle_review->method('getBundles')->willReturn(['one']);
    self::assertSame(['one'], $evaluator->allBundlesOfReview($bundle_review));
  }

  /**
   * Test checking that a review has a bundle.
   *
   * @throws \PHPUnit\Framework\MockObject\Exception
   */
  public function testReviewHasBundle(): void {
    $evaluator = new BundleEvaluator(
      $this->createMock(EntityTypeBundleInfoInterface::class),
      $this->createMock(EntityTypeManagerInterface::class),
    );

    $review = $this->createMock(ReviewInterface::class);
    $review->method('getId')->willReturn('review');
    $bundle = $this->createMock(ReviewInterface::class);
    $bundle->method('getId')->willReturn('review.one');

    self::assertFalse($evaluator->reviewHasBundle($review, []));
    self::assertFalse($evaluator->reviewHasBundle($review, ['two']));
    self::assertFalse($evaluator->reviewHasBundle($bundle, []));
    self::assertFalse($evaluator->reviewHasBundle($bundle, ['two']));
    self::assertFalse($evaluator->reviewHasBundle($bundle, ['two', 'three']));
    self::assertTrue($evaluator->reviewHasBundle($bundle, ['one', 'two']));
  }

  /**
   * Test getting that a reviews matching a set of bundles.
   *
   * @throws \PHPUnit\Framework\MockObject\Exception
   */
  public function testReviewsOfBundles(): void {
    $evaluator = new BundleEvaluator(
      $this->createMock(EntityTypeBundleInfoInterface::class),
      $this->createMock(EntityTypeManagerInterface::class),
    );

    $review = $this->createMock(ReviewInterface::class);
    $review->method('getId')->willReturn('review');
    $bundle_one = $this->createMock(ReviewInterface::class);
    $bundle_one->method('getId')->willReturn('review.one');
    $bundle_two = $this->createMock(ReviewInterface::class);
    $bundle_two->method('getId')->willReturn('review.two');
    $bundle_three = $this->createMock(ReviewInterface::class);
    $bundle_three->method('getId')->willReturn('review.three');

    $reviews = [
      $review->getId() => $review,
      $bundle_one->getId() => $bundle_one,
      $bundle_two->getId() => $bundle_two,
      $bundle_three->getId() => $bundle_three,
    ];

    self::assertSame(
      ['review.one' => $reviews['review.one'], 'review.two' => $reviews['review.two']],
      $evaluator->reviewsOfBundles($reviews, ['one', 'two']),
    );
    self::assertContainsOnlyInstancesOf(
      ReviewInterface::class,
      $evaluator->reviewsOfBundles($reviews, ['one', 'two']),
    );
    self::assertSame($reviews, $evaluator->reviewsOfBundles($reviews, []));
  }

}