class ConditionExpressionTest

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

}