ConditionExpressionTest.php in Rules 8.3

Namespace

Drupal\Tests\rules\Unit

File

tests/src/Unit/ConditionExpressionTest.php

<?php

namespace Drupal\Tests\rules\Unit;

use Drupal\Core\Logger\LoggerChannelInterface;
use Drupal\Core\Plugin\Context\ContextDefinitionInterface;
use Drupal\Tests\UnitTestCase;
use Drupal\rules\Context\DataProcessorInterface;
use Drupal\rules\Context\ContextConfig;
use Drupal\rules\Context\DataProcessorManager;
use Drupal\rules\Context\ExecutionStateInterface;
use Drupal\rules\Core\ConditionManager;
use Drupal\rules\Core\RulesConditionInterface;
use Drupal\rules\Plugin\RulesExpression\ConditionExpression;
use Prophecy\Argument;

/**
 * @coversDefaultClass \Drupal\rules\Plugin\RulesExpression\ConditionExpression
 * @group Rules
 */
class ConditionExpressionTest extends UnitTestCase {

  /**
   * The mocked condition manager.
   *
   * @var \Drupal\rules\Core\ConditionManager|\Prophecy\Prophecy\ProphecyInterface
   */
  protected $conditionManager;

  /**
   * The mocked data processor manager.
   *
   * @var \Drupal\rules\Context\DataProcessorManager|\Prophecy\Prophecy\ProphecyInterface
   */
  protected $processorManager;

  /**
   * The condition object being tested.
   *
   * @var \Drupal\rules\Plugin\RulesExpression\ConditionExpression
   */
  protected $conditionExpression;

  /**
   * A condition plugin that always evaluates to TRUE.
   *
   * @var \Drupal\rules\Core\RulesConditionInterface|\Prophecy\Prophecy\ProphecyInterface
   */
  protected $trueCondition;

  /**
   * The mocked expression manager object.
   *
   * @var \Drupal\rules\src\Logger\|\Prophecy\Prophecy\ProphecyInterface
   */
  protected $rulesDebugLogger;

  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();

    // Create a test condition plugin that always evaluates to TRUE.
    $this->trueCondition = $this
      ->prophesize(RulesConditionInterface::class);
    $this->trueCondition
      ->execute()
      ->willReturn(TRUE);
    $this->trueCondition
      ->evaluate()
      ->willReturn(TRUE);
    $this->conditionManager = $this
      ->prophesize(ConditionManager::class);
    $this->processorManager = $this
      ->prophesize(DataProcessorManager::class);
    $this->rulesDebugLogger = $this
      ->prophesize(LoggerChannelInterface::class);
    $this->conditionExpression = new ConditionExpression([
      'condition_id' => 'test_condition',
    ], '', [
      'label' => 'Test Condition',
    ], $this->conditionManager
      ->reveal(), $this->processorManager
      ->reveal(), $this->rulesDebugLogger
      ->reveal());
  }

  /**
   * Tests that context values get data processed with processor mappings.
   */
  public function testDataProcessor() {
    $this->conditionManager
      ->createInstance('test_condition', [
      'negate' => FALSE,
    ])
      ->willReturn($this->trueCondition
      ->reveal())
      ->shouldBeCalledTimes(1);
    $this->conditionManager
      ->getDefinition('test_condition')
      ->willReturn([
      'label' => 'Test Condition',
    ])
      ->shouldBeCalledTimes(1);
    $condition = new ConditionExpression([
      'condition_id' => 'test_condition',
    ] + ContextConfig::create()
      ->process('test', 'foo', [])
      ->toArray(), '', [
      'label' => 'Test Condition',
    ], $this->conditionManager
      ->reveal(), $this->processorManager
      ->reveal(), $this->rulesDebugLogger
      ->reveal());
    $this->trueCondition
      ->getContextDefinitions()
      ->willReturn([
      'test' => $this
        ->prophesize(ContextDefinitionInterface::class)
        ->reveal(),
    ])
      ->shouldBeCalledTimes(1);
    $this->trueCondition
      ->getContextDefinition('test')
      ->willReturn($this
      ->prophesize(ContextDefinitionInterface::class)
      ->reveal())
      ->shouldBeCalledTimes(1);
    $this->trueCondition
      ->getProvidedContextDefinitions()
      ->willReturn([])
      ->shouldBeCalledTimes(1);

    // Mock some original old value that will be replaced by the data processor.
    $this->trueCondition
      ->getContextValue('test')
      ->willReturn('old_value')
      ->shouldBeCalled();

    // The outcome of the data processor needs to get set on the condition.
    $this->trueCondition
      ->setContextValue('test', 'new_value')
      ->shouldBeCalledTimes(1);
    $this->trueCondition
      ->refineContextDefinitions([])
      ->shouldBeCalledTimes(1);
    $data_processor = $this
      ->prophesize(DataProcessorInterface::class);
    $data_processor
      ->process('old_value', Argument::any())
      ->willReturn('new_value')
      ->shouldBeCalledTimes(1);
    $this->processorManager
      ->createInstance('foo', [])
      ->willReturn($data_processor
      ->reveal())
      ->shouldBeCalledTimes(1);

    // Build some mocked execution state.
    $state = $this
      ->prophesize(ExecutionStateInterface::class);
    $prophecy = $state
      ->getVariable('test');

    /** @var \Prophecy\Prophecy\MethodProphecy $prophecy */
    $prophecy
      ->willReturn('old_value');
    $this
      ->assertTrue($condition
      ->executeWithState($state
      ->reveal()));
  }

  /**
   * Tests that negating a condition works.
   */
  public function testNegation() {
    $this->trueCondition
      ->getContextDefinitions()
      ->willReturn([]);
    $this->trueCondition
      ->refineContextDefinitions([])
      ->shouldBeCalledTimes(1);
    $this->trueCondition
      ->getProvidedContextDefinitions()
      ->willReturn([])
      ->shouldBeCalledTimes(1);
    $this->conditionManager
      ->createInstance('test_condition', [
      'negate' => TRUE,
    ])
      ->willReturn($this->trueCondition
      ->reveal())
      ->shouldBeCalledTimes(1);
    $this->conditionManager
      ->getDefinition('test_condition')
      ->willReturn([
      'label' => 'Test Condition',
    ])
      ->shouldBeCalledTimes(1);

    // Create a condition which is negated.
    $condition_expression = new ConditionExpression([
      'condition_id' => 'test_condition',
      'negate' => TRUE,
    ], '', [
      'label' => 'Test Condition',
    ], $this->conditionManager
      ->reveal(), $this->processorManager
      ->reveal(), $this->rulesDebugLogger
      ->reveal());
    $condition_expression
      ->setStringTranslation($this
      ->getStringTranslationStub());
    $this
      ->assertFalse($condition_expression
      ->execute());
  }

}

Classes

Name	Description
ConditionExpressionTest	@coversDefaultClass \Drupal\rules\Plugin\RulesExpression\ConditionExpression @group Rules