RulesConditionContainerTest.php

<?php

namespace Drupal\Tests\rules\Unit;

use Drupal\Core\Logger\LoggerChannelInterface;
use Drupal\rules\Context\ExecutionStateInterface;
use Drupal\rules\Engine\ConditionExpressionContainer;
use Drupal\rules\Engine\ExpressionManagerInterface;

/**
 * @coversDefaultClass \Drupal\rules\Engine\ConditionExpressionContainer
 * @group Rules
 */
class RulesConditionContainerTest extends RulesUnitTestBase {
  
  /**
   * Creates a mocked condition container.
   *
   * @param array $methods
   *   The methods to mock.
   * @param string $class
   *   The name of the created mock class.
   *
   * @return \Drupal\rules\Engine\ConditionExpressionContainerInterface
   *   The mocked condition container.
   */
  protected function getMockConditionContainer(array $methods = [], $class = 'RulesConditionContainerMock') {
    return $this->getMockForAbstractClass(ConditionExpressionContainer::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], $class, TRUE, TRUE, TRUE, $methods);
  }
  
  /**
   * Tests adding conditions to the condition container.
   *
   * @covers ::addExpressionObject
   */
  public function testAddExpressionObject() {
    $container = $this->getMockConditionContainer();
    $container->addExpressionObject($this->trueConditionExpression
      ->reveal());
    $property = new \ReflectionProperty($container, 'conditions');
    $property->setAccessible(TRUE);
    $this->assertEquals([
      $this->trueConditionExpression
        ->reveal(),
    ], array_values($property->getValue($container)));
  }
  
  /**
   * Tests negating the result of the condition container.
   *
   * @covers ::negate
   * @covers ::isNegated
   */
  public function testNegate() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [], '', FALSE);
    $this->assertFalse($container->isNegated());
    $this->assertTrue($container->execute());
    $container->negate(TRUE);
    $this->assertTrue($container->isNegated());
    $this->assertFalse($container->execute());
  }
  
  /**
   * Tests executing the condition container.
   *
   * @covers ::execute
   */
  public function testExecute() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [], '', FALSE);
    $this->assertTrue($container->execute());
  }
  
  /**
   * Tests that an expression can be retrieved by UUID.
   */
  public function testLookupExpression() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $container->addExpressionObject($this->trueConditionExpression
      ->reveal());
    $uuid = $this->trueConditionExpression
      ->reveal()
      ->getUuid();
    $this->assertSame($this->trueConditionExpression
      ->reveal(), $container->getExpression($uuid));
    $this->assertFalse($container->getExpression('invalid UUID'));
  }
  
  /**
   * Tests that a nested expression can be retrieved by UUID.
   */
  public function testLookupNestedExpression() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $container->addExpressionObject($this->trueConditionExpression
      ->reveal());
    $nested_container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $nested_container->addExpressionObject($this->falseConditionExpression
      ->reveal());
    $container->addExpressionObject($nested_container);
    $uuid = $this->falseConditionExpression
      ->reveal()
      ->getUuid();
    $this->assertSame($this->falseConditionExpression
      ->reveal(), $container->getExpression($uuid));
  }
  
  /**
   * Tests deleting a condition from the container.
   */
  public function testDeletingCondition() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $container->addExpressionObject($this->trueConditionExpression
      ->reveal());
    $container->addExpressionObject($this->falseConditionExpression
      ->reveal());
    // Delete the first condition.
    $uuid = $this->trueConditionExpression
      ->reveal()
      ->getUuid();
    $this->assertTrue($container->deleteExpression($uuid));
    foreach ($container as $condition) {
      $this->assertSame($this->falseConditionExpression
        ->reveal(), $condition);
    }
    $this->assertFalse($container->deleteExpression('invalid UUID'));
  }
  
  /**
   * Tests deleting a nested condition from the container.
   */
  public function testDeletingNestedCondition() {
    $container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $container->addExpressionObject($this->trueConditionExpression
      ->reveal());
    $nested_container = $this->getMockForAbstractClass(RulesConditionContainerTestStub::class, [
      [],
      'test_id',
      [],
      $this->prophesize(ExpressionManagerInterface::class)
        ->reveal(),
      $this->prophesize(LoggerChannelInterface::class)
        ->reveal(),
    ], '', TRUE);
    $nested_container->addExpressionObject($this->falseConditionExpression
      ->reveal());
    $container->addExpressionObject($nested_container);
    $uuid = $this->falseConditionExpression
      ->reveal()
      ->getUuid();
    $this->assertTrue($container->deleteExpression($uuid));
    $this->assertCount(0, $nested_container->getIterator());
  }

}

/**
 * Class used for overriding evaluate() as this does not work with PHPunit.
 */
abstract class RulesConditionContainerTestStub extends ConditionExpressionContainer {
  
  /**
   * {@inheritdoc}
   */
  public function evaluate(ExecutionStateInterface $state) {
    return TRUE;
  }

}