RulesEngineTest.php

<?php

namespace Drupal\Tests\rules\Kernel;

use Drupal\rules\Core\ConditionManager;
use Drupal\rules\Context\ContextConfig;
use Drupal\rules\Context\ContextDefinition;
use Drupal\rules\Context\ExecutionState;
use Drupal\rules\Engine\RulesComponent;
// cspell:ignore valuetest

/**
 * Test using the Rules API to create and evaluate rules.
 *
 * @group Rules
 */
class RulesEngineTest extends RulesKernelTestBase {
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->installEntitySchema('user');
    // The global CurrentUserContext doesn't work properly without a
    // fully-installed user module.
    // @see https://www.drupal.org/project/rules/issues/2989417
    $this->container
      ->get('module_handler')
      ->loadInclude('user', 'install');
    user_install();
  }
  
  /**
   * Tests creating a rule and iterating over the rule elements.
   */
  public function testRuleCreation() {
    // Create an 'and' condition container and add conditions to it.
    $and = $this->expressionManager
      ->createAnd()
      ->addCondition('rules_test_false')
      ->addCondition('rules_test_true', ContextConfig::create()->negateResult())
      ->negate();
    // Test that the 'and' condition container evaluates to TRUE.
    $this->assertTrue($and->execute());
    // Create an 'or' condition container and add conditions to it, including
    // the previously created 'and' condition container.
    $or = $this->expressionManager
      ->createOr()
      ->addCondition('rules_test_true', ContextConfig::create()->negateResult())
      ->addCondition('rules_test_false')
      ->addExpressionObject($and);
    // Test that the 'or' condition container evaluates to TRUE.
    $this->assertTrue($or->execute());
    // Create a rule and add conditions to it, including the previously created
    // 'or' condition container.
    $rule = $this->expressionManager
      ->createRule();
    $rule->addCondition('rules_test_true')
      ->addCondition('rules_test_true')
      ->addExpressionObject($or);
    // Test that the rule's condition container evaluates to TRUE.
    $this->assertTrue($rule->getConditions()
      ->execute());
    // Add an action to it and execute the rule.
    $rule->addAction('rules_test_debug_log');
    $rule->execute();
    // Test that the action logged something.
    $this->assertRulesDebugLogEntryExists('action called');
  }
  
  /**
   * Tests passing a string context to a condition.
   */
  public function testContextPassing() {
    $rule = $this->expressionManager
      ->createRule();
    $rule->addCondition('rules_test_string_condition', ContextConfig::create()->map('text', 'test'));
    $rule->addAction('rules_test_debug_log');
    RulesComponent::create($rule)->addContextDefinition('test', ContextDefinition::create('string'))
      ->setContextValue('test', 'test value')
      ->execute();
    // Test that the action logged something.
    $this->assertRulesDebugLogEntryExists('action called');
  }
  
  /**
   * Tests that a condition can provide a value and another one can consume it.
   */
  public function testProvidedVariables() {
    $rule = $this->expressionManager
      ->createRule();
    // The first condition provides a "provided_text" variable.
    $rule->addCondition('rules_test_provider');
    // The second condition consumes the variable.
    $rule->addCondition('rules_test_string_condition', ContextConfig::create()->map('text', 'provided_text'));
    $rule->addAction('rules_test_debug_log');
    $component = RulesComponent::create($rule);
    $violations = $component->checkIntegrity();
    $this->assertCount(0, $violations);
    $component->execute();
    // Test that the action logged something.
    $this->assertRulesDebugLogEntryExists('action called');
  }
  
  /**
   * Tests that provided variables can be renamed with configuration.
   */
  public function testRenamingOfProvidedVariables() {
    $rule = $this->expressionManager
      ->createRule();
    // The condition provides a "provided_text" variable.
    $rule->addCondition('rules_test_provider', ContextConfig::create()->provideAs('provided_text', 'newname'));
    $state = ExecutionState::create();
    $rule->executeWithState($state);
    // Check that the newly named variable exists and has the provided value.
    $variable = $state->getVariable('newname');
    $this->assertEquals($variable->getValue(), 'test value');
  }
  
  /**
   * Tests that multiple actions can consume and provide context variables.
   */
  public function testActionProvidedContext() {
    // @todo Convert the test to make use of actions instead of conditions.
    $rule = $this->expressionManager
      ->createRule();
    // The condition provides a "provided_text" variable.
    $rule->addCondition('rules_test_provider');
    // The action provides a "concatenated" variable.
    $rule->addAction('rules_test_string', ContextConfig::create()->map('text', 'provided_text'));
    // Add the same action again which will provide a "concatenated2" variable
    // now.
    $rule->addAction('rules_test_string', ContextConfig::create()->map('text', 'concatenated')
      ->provideAs('concatenated', 'concatenated2'));
    $state = ExecutionState::create();
    $rule->executeWithState($state);
    // Check that the created variables exists and have the provided values.
    $concatenated = $state->getVariable('concatenated');
    $this->assertEquals($concatenated->getValue(), 'test valuetest value');
    $concatenated2 = $state->getVariable('concatenated2');
    $this->assertEquals($concatenated2->getValue(), 'test valuetest valuetest valuetest value');
  }
  
  /**
   * Verifies swapping out core services works.
   */
  public function testSwappedCoreServices() {
    $condition_manager = $this->container
      ->get('plugin.manager.condition');
    $this->assertInstanceOf(ConditionManager::class, $condition_manager);
  }

}