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());
    }

}