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

<?php

declare(strict_types=1);

namespace Drupal\Tests\reviewer\Kernel;

use Drupal\KernelTests\KernelTestBase;
use Drupal\reviewer\Reviewer\Action;
use Drupal\reviewer\Reviewer\Checklist\ChecklistInterface;
use Drupal\reviewer\Reviewer\Result\CollectionResultInterface;
use Drupal\reviewer\Reviewer\Result\IndividualResultInterface;
use Drupal\reviewer\Reviewer\Result\Result;
use Drupal\reviewer\Reviewer\Result\ResultInterface;
use Drupal\reviewer\Reviewer\Status\Status;
use Drupal\reviewer\Reviewer\Task\TaskBase;
use Drupal\reviewer_test\Plugin\reviewer\Task\TestFixableTask;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;

/**
 * Test task methods.
 */
#[Group('reviewer')]
#[CoversClass(TaskBase::class)]
final class TaskTest extends KernelTestBase {

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

  private readonly ResultInterface $pass;

  private readonly ResultInterface $fixed;

  private readonly ResultInterface $ignored;

  private readonly ResultInterface $fail;

  private readonly CollectionResultInterface $collection;

  /**
   * Task constructor arguments.
   *
   * @var object[]
   */
  private readonly array $taskConstructorArguments;

  /**
   * {@inheritdoc}
   *
   * @throws \Exception
   * @throws \PHPUnit\Framework\MockObject\Exception
   */
  protected function setUp(): void {
    parent::setUp();
    $this->pass = new Result('pass', Status::Pass, 'Pass');
    $this->fixed = new Result('fixed', Status::Fixed, 'Fixed');
    $this->ignored = new Result('ignored', Status::IgnoredFailure, 'Ignored');
    $this->fail = new Result('fail', Status::Fail, 'Fail');
    $this->collection = $this->container->get('reviewer.factory.result')->createCollection('collection', [
      'pass' => $this->pass,
      'ignored' => $this->ignored,
      'fail' => $this->fail,
    ]);
    $this->taskConstructorArguments = [
      $this->container->get('entity_display.repository'),
      $this->container->get('entity_field.manager'),
      $this->container->get('entity_type.manager'),
      $this->container->get('config.factory'),
      $this->container->get('module_handler'),
      $this->container->get('reviewer.factory.result'),
      $this->container->get('reviewer.evaluator.status'),
      $this->container->get('reviewer.factory.status'),
    ];
  }

  /**
   * Test running the task.
   *
   * @throws \Exception
   */
  public function testRun(): void {
    $met_dependency = $this
      ->getMockBuilder(TaskBase::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['getModuleDependencies', 'check', 'getId', 'resultId'])
      ->getMock();
    $met_dependency->method('getModuleDependencies')->willReturn(['reviewer']);
    $met_dependency->method('check')->willReturn($this->pass);
    $met_dependency->method('getId')->willReturn('met_dependency');
    $met_dependency->method('resultId')->willReturn('met_dependency');
    $met_dependency->run(Action::Check);
    self::assertCount(1, $met_dependency->getResults()->getAll());
    self::assertSame($met_dependency->getResults()->getStatus(), Status::Pass, 'Pass');

    $unmet_dependency = $this
      ->getMockBuilder(TaskBase::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['getModuleDependencies', 'check', 'getId', 'resultId'])
      ->getMock();
    $unmet_dependency->method('getModuleDependencies')->willReturn(['does_not_exist']);
    $unmet_dependency->method('check')->willReturn($this->pass);
    $unmet_dependency->method('getId')->willReturn('unmet_dependency');
    $unmet_dependency->method('resultId')->willReturn('unmet_dependency');
    $unmet_dependency->run(Action::Check);
    self::assertCount(1, $unmet_dependency->getResults()->getAll());
    self::assertSame($unmet_dependency->getResults()->getStatus(), Status::NotRun);

    $pass = $this
      ->getMockBuilder(TaskBase::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $pass->method('check')->willReturn($this->pass);
    $pass->method('getId')->willReturn('pass');
    $pass->method('resultId')->willReturn('pass');
    $pass->method('getModuleDependencies')->willReturn([]);
    $pass->run(Action::Check);
    self::assertSame($pass->getResults()->getId(), 'pass');
    self::assertCount(1, $pass->getResults()->getAll());
    self::assertSame($pass->getResults()->getStatus(), Status::Pass);

    $collection = $this
      ->getMockBuilder(TaskBase::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $collection->method('check')->willReturn($this->collection);
    $collection->method('getId')->willReturn('collection');
    $collection->method('resultId')->willReturn('collection');
    $collection->method('getModuleDependencies')->willReturn([]);
    $collection->run(Action::Check);
    self::assertSame($collection->getResults()->getId(), 'collection');
    self::assertCount(3, $collection->getResults()->getAll());
    self::assertSame($collection->getResults()->getStatus(), Status::Fail);

    $error = $this
      ->getMockBuilder(TaskBase::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $error->method('check')->willThrowException(new \Exception('Error'));
    $error->method('getId')->willReturn('error');
    $error->method('resultId')->willReturn('error');
    $error->method('getModuleDependencies')->willReturn([]);
    $error->run(Action::Check);
    self::assertSame($error->getResults()->getId(), 'error');
    self::assertCount(1, $error->getResults()->getAll());
    self::assertSame($error->getResults()->getStatus(), Status::Error);
    $error_result = $error->getResults()->get('error');
    self::assertInstanceOf(IndividualResultInterface::class, $error_result);
    self::assertSame('Error', $error_result->getMessage());

    $fixed = $this
      ->getMockBuilder(TestFixableTask::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'fix', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $fixed->method('check')->willReturn($this->fail);
    $fixed->method('fix')->willReturn($this->fixed);
    $fixed->method('getId')->willReturn('fixed');
    $fixed->method('resultId')->willReturn('fixed');
    $fixed->method('getModuleDependencies')->willReturn([]);
    $fixed->run(Action::Fix);
    self::assertSame($fixed->getResults()->getId(), 'fixed');
    self::assertCount(1, $pass->getResults()->getAll());
    self::assertSame($fixed->getResults()->getStatus(), Status::Fixed);

    $pass_fix = $this
      ->getMockBuilder(TestFixableTask::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'fix', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $pass_fix->method('check')->willReturn($this->pass);
    $pass_fix->method('fix')->willReturn($this->fixed);
    $pass_fix->method('getId')->willReturn('fixed');
    $pass_fix->method('resultId')->willReturn('fixed');
    $pass_fix->method('getModuleDependencies')->willReturn([]);
    $pass_fix->run(Action::Fix);
    self::assertCount(1, $pass_fix->getResults()->getAll());
    self::assertSame($pass_fix->getResults()->getStatus(), Status::Pass);

    $ignored_fix = $this
      ->getMockBuilder(TestFixableTask::class)
      ->enableOriginalConstructor()
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'fix', 'getId', 'resultId', 'getModuleDependencies'])
      ->getMock();
    $ignored_fix->method('check')->willReturn($this->ignored);
    $ignored_fix->method('fix')->willReturn($this->fixed);
    $ignored_fix->method('getId')->willReturn('fixed');
    $ignored_fix->method('resultId')->willReturn('fixed');
    $ignored_fix->method('getModuleDependencies')->willReturn([]);
    $ignored_fix->run(Action::Fix);
    self::assertCount(1, $ignored_fix->getResults()->getAll());
    self::assertSame($ignored_fix->getResults()->getStatus(), Status::IgnoredFailure);
  }

  /**
   * Test that the task ID is generated correctly.
   *
   * @throws \PHPUnit\Framework\MockObject\Exception
   * @throws \ReflectionException
   */
  public function testGetId(): void {
    $checklist = $this->createMock(ChecklistInterface::class);
    $checklist->method('getId')->willReturn('checklist');
    $task = $this
      ->getMockBuilder(TaskBase::class)
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'getAttributeId'])
      ->getMock();
    $task->method('check')->willReturn($this->createMock(ResultInterface::class));
    $task->method('getAttributeId')->willReturn('task');
    $reflection = (new \ReflectionClass($task))->getParentClass();
    if ($reflection) {
      $reflection->getProperty('checklist')->setValue($task, $checklist);
    }

    self::assertSame('checklist.task', $task->getId());
  }

  /**
   * Test result ID generation.
   *
   * @throws \PHPUnit\Framework\MockObject\Exception
   * @throws \ReflectionException
   */
  public function testResultId(): void {
    $task = $this
      ->getMockBuilder(TaskBase::class)
      ->setConstructorArgs($this->taskConstructorArguments)
      ->onlyMethods(['check', 'getAttributeId'])
      ->getMock();
    $task->method('check')->willReturn($this->createMock(ResultInterface::class));
    $task->method('getAttributeId')->willReturn('task');
    $checklist = $this->createMock(ChecklistInterface::class);
    $checklist->method('getId')->willReturn('checklist');
    $reflection = (new \ReflectionClass($task))->getParentClass();
    if ($reflection) {
      $reflection->getProperty('checklist')->setValue($task, $checklist);
    }

    self::assertSame('checklist.task', $task->resultId());
    self::assertSame('checklist.task.variant', $task->resultId('variant'));
  }

}