Club Drupal

<?php

/**

 * @file

 * Rules tests.

 */

/**

 * Rules test cases.

 */

class RulesTestCase extends DrupalWebTestCase {

  /**

   * Declares test metadata.

   */

  public static function getInfo() {

    return array(

      'name' => 'Rules Engine tests',

      'description' => 'Test using the rules API to create and evaluate rules.',

      'group' => 'Rules',

    );

  }

  /**

   * Overrides DrupalWebTestCase::setUp().

   */

  protected function setUp() {

    parent::setUp('rules', 'rules_test');

    RulesLog::logger()->clear();

    variable_set('rules_debug_log', TRUE);

  }

  /**

   * Calculates the output of t() given an array of placeholders to replace.

   */

  public static function t($text, $strings) {

    $placeholders = array();

    foreach ($strings as $key => $string) {

      $key = !is_numeric($key) ? $key : $string;

      $placeholders['%' . $key] = drupal_placeholder($string);

    }

    return strtr($text, $placeholders);

  }

  /**

   * Helper function to create a test Rule.

   */

  protected function createTestRule() {

    $rule = rule();

    $rule->condition('rules_test_condition_true')

         ->condition('rules_test_condition_true')

         ->condition(rules_or()

           ->condition(rules_condition('rules_test_condition_true')->negate())

           ->condition('rules_test_condition_false')

           ->condition(rules_and()

             ->condition('rules_test_condition_false')

             ->condition('rules_test_condition_true')

             ->negate()

           )

         );

    $rule->action('rules_test_action');

    return $rule;

  }

  /**

   * Tests creating a rule and iterating over the rule elements.

   */

  public function testRuleCreation() {

    $rule = $this->createTestRule();

    $rule->integrityCheck();

    $rule->execute();

    $log = RulesLog::logger()->get();

    $last = array_pop($log);

    $last = array_pop($log);

    $last = array_pop($log);

    $this->assertEqual($last[0], 'action called', 'Action called');

    RulesLog::logger()->checkLog();

    // Make sure condition and action iterators are working.

    $it = new RecursiveIteratorIterator($rule->conditions(), RecursiveIteratorIterator::SELF_FIRST);

    $this->assertEqual(iterator_count($it), 8, 'Iterated over all conditions and condition containers');

    $it = new RecursiveIteratorIterator($rule->conditions());

    $this->assertEqual(iterator_count($it), 6, 'Iterated over all conditions');

    $this->assertEqual(iterator_count($rule->actions()), 1, 'Iterated over all actions');

    $this->assertEqual(iterator_count($rule->elements()), 10, 'Iterated over all rule elements.');

    // Test getting dependencies and the integrity check.

    $rule->integrityCheck();

    $this->assertTrue($rule->dependencies() === array('rules_test'), 'Dependencies correctly returned.');

  }

  /**

   * Tests handling dependencies.

   */

  public function testDependencies() {

    $action = rules_action('rules_node_publish_action');

    $this->assertEqual($action->dependencies(), array('rules_test'), 'Providing module is returned as dependency.');

    $container = new RulesTestContainer();

    $this->assertEqual($container->dependencies(), array('rules_test'), 'Providing module for container plugin is returned as dependency.');

    // Test handling unmet dependencies.

    $rule = rules_config_load('rules_export_test');

    $this->assertTrue(in_array('comment', $rule->dependencies) && !$rule->dirty, 'Dependencies have been imported.');

    // Remove the required comment module and make sure the rule is dirty then.

    module_disable(array('comment'));

    rules_clear_cache();

    $rule = rules_config_load('rules_export_test');

    $this->assertTrue($rule->dirty, 'Rule has been marked as dirty');

    // Now try re-enabling.

    module_enable(array('comment'));

    rules_clear_cache();

    $rule = rules_config_load('rules_export_test');

    $this->assertTrue(!$rule->dirty, 'Rule has been marked as not dirty again.');

    // Test it with components.

    module_enable(array('path'));

    $action_set = rules_action_set(array('node' => array('type' => 'node')));

    $action_set->action('node_path_alias');

    $action_set->save('rules_test_alias');

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->action('component_rules_test_alias');

    $rule->integrityCheck();

    $rule->save('rules_test_rule');

    $rule = rules_config_load('rules_test_rule');

    $component = rules_config_load('rules_test_alias');

    $this->assertTrue(in_array('path', $component->dependencies) && !$rule->dirty && !$component->dirty, 'Component has path module dependency.');

    // Now disable path module and make sure both configs are marked as dirty.

    module_disable(array('path'));

    rules_clear_cache();

    $rule = rules_config_load('rules_test_rule');

    $component = rules_config_load('rules_test_alias');

    $this->assertTrue($component->dirty, 'Component has been marked as dirty');

    $node = $this->drupalCreateNode();

    $result = rules_invoke_component('rules_test_alias', $node);

    $this->assertTrue($result === FALSE, 'Unable to execute a dirty component.');

    // When the rule is evaluated, the broken component is detected and the

    // rule should be marked as dirty too.

    $rule->execute($node);

    $this->assertTrue($rule->dirty, 'Rule has been marked as dirty');

    module_enable(array('path'));

    rules_clear_cache();

    // Trigger rebuilding the cache, so configs are checked again.

    rules_get_cache();

    $rule = rules_config_load('rules_test_rule');

    $component = rules_config_load('rules_test_alias');

    $this->assertTrue(!$component->dirty, 'Component has been marked as not dirty again.');

    $this->assertTrue(!$rule->dirty, 'Rule has been marked as not dirty again.');

  }

  /**

   * Tests setting up an action, serializing, and executing it.

   */

  public function testActionSetup() {

    $action = rules_action('rules_node_publish_action');

    $s = serialize($action);

    $action2 = unserialize($s);

    $node = (object) array('status' => 0, 'type' => 'page');

    $node->title = 'test';

    $action2->execute($node);

    $this->assertEqual($node->status, 1, 'Action executed correctly');

    $this->assertTrue(in_array('node', array_keys($action2->parameterInfo())), 'Parameter info returned.');

    $node->status = 0;

    $action2->integrityCheck();

    $action2->executeByArgs(array('node' => $node));

    $this->assertEqual($node->status, 1, 'Action executed correctly');

    // Test calling an extended + overridden method.

    $this->assertEqual($action2->help(), 'custom', 'Using custom help callback.');

    // Inspect the cache

    //$this->pass(serialize(rules_get_cache()));

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests executing with wrong arguments.

   */

  public function testActionExecutionFails() {

    $action = rules_action('rules_node_publish_action');

    try {

      $action->execute();

      $this->fail("Execution hasn't created an exception.");

    }

    catch (RulesEvaluationException $e) {

      $this->pass("RulesEvaluationException was thrown: " . $e);

    }

  }

  /**

   * Tests setting up a rule and mapping variables.

   */

  public function testVariableMapping() {

    $rule = rule(array(

      'node' => array('type' => 'node'),

      'node_unchanged' => array('type' => 'node'),

    ));

    $rule->condition(rules_condition('rules_condition_content_is_published')->negate())

         ->condition('rules_condition_content_is_type', array('type' => array('page', 'story')))

         ->action('rules_node_publish_action', array('node:select' => 'node_unchanged'));

    $node1 = $this->drupalCreateNode(array('status' => 0, 'type' => 'page'));

    $node2 = $this->drupalCreateNode(array('status' => 0, 'type' => 'page'));

    $rule->integrityCheck();

    $rule->execute($node1, $node2);

    $this->assertEqual($node2->status, 1, 'Action executed correctly on node2.');

    $this->assertEqual($node1->status, 0, 'Action not executed on node1.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests making use of class based actions.

   */

  public function testClassBasedActions() {

    $cache = rules_get_cache();

    $this->assertTrue(!empty($cache['action_info']['rules_test_class_action']), 'Action has been discovered.');

    $action = rules_action('rules_test_class_action');

    $parameters = $action->parameterInfo();

    $this->assertTrue($parameters['node'], 'Action parameter needs a value.');

    $node = $this->drupalCreateNode();

    $action->execute($node);

    $log = RulesLog::logger()->get();

    $last = array_pop($log);

    $last = array_pop($log);

    $this->assertEqual($last[0], 'Action called with node ' . $node->nid, 'Action called');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests CRUD functionality.

   */

  public function testRulesCRUD() {

    $rule = $this->createTestRule();

    $rule->integrityCheck()->save('test');

    $this->assertEqual(TRUE, $rule->active, 'Rule is active.');

    $this->assertEqual(0, $rule->weight, 'Rule weight is zero.');

    $results = entity_load('rules_config', array('test'));

    $rule2 = array_pop($results);

    $this->assertEqual($rule->id, $rule2->id, 'Rule created and loaded');

    $this->assertEqual(get_class($rule2), get_class($rule), 'Class properly instantiated.');

    $rule2->execute();

    // Update.

    $rule2->save();

    // Make sure all rule elements are still here.

    $it = new RecursiveIteratorIterator($rule2->conditions(), RecursiveIteratorIterator::SELF_FIRST);

    $this->assertEqual(iterator_count($it), 8, 'Iterated over all conditions and condition containers');

    $it = new RecursiveIteratorIterator($rule2->conditions());

    $this->assertEqual(iterator_count($it), 6, 'Iterated over all conditions');

    $this->assertEqual(iterator_count($rule2->actions()), 1, 'Iterated over all actions');

    // Delete.

    $rule2->delete();

    $this->assertEqual(entity_load('rules_config', FALSE, array('id' => $rule->id)), array(), 'Deleted.');

    // Tests CRUD for tags - making sure the tags are stored properly..

    $rule = $this->createTestRule();

    $tag = $this->randomString();

    $rule->tags = array($tag);

    $rule->save();

    $result = db_select('rules_tags')

      ->fields('rules_tags', array('tag'))

      ->condition('id', $rule->id)

      ->execute();

    $this->assertEqual($result->fetchField(), $tag, 'Associated tag has been saved.');

    // Try updating.

    $rule->tags = array($this->randomName(), $this->randomName());

    $rule->integrityCheck()->save();

    $result = db_select('rules_tags')

      ->fields('rules_tags', array('tag'))

      ->condition('id', $rule->id)

      ->execute()

      ->fetchCol();

    $this->assertTrue(in_array($rule->tags[0], $result) && in_array($rule->tags[1], $result), 'Updated associated tags.');

    // Try loading multiple rules by tags.

    $rule2 = $this->createTestRule();

    $rule2->tags = array($this->randomName());

    $rule2->save();

    $loaded = entity_load('rules_config', FALSE, array('tags' => array($rule->tags[0], $rule2->tags[0])));

    $this->assertTrue($loaded[$rule->id]->id == $rule->id && $loaded[$rule2->id]->id == $rule2->id, 'Loading configs by tags');

    // Try deleting.

    $rule->delete();

    $result = db_select('rules_tags')

      ->fields('rules_tags', array('tag'))

      ->condition('id', $rule->id)

      ->execute();

    $this->assertEqual($result->fetchField(), FALSE, 'Deleted associated tags.');

  }

  /**

   * Tests automatic saving of variables.

   */

  public function testActionSaving() {

    // Test saving a parameter.

    $action = rules_action('rules_node_publish_action_save');

    $node = $this->drupalCreateNode(array('status' => 0, 'type' => 'page'));

    $action->executeByArgs(array('node' => $node));

    $this->assertEqual($node->status, 1, 'Action executed correctly on node.');

    // Sync node_load cache with node_save.

    entity_get_controller('node')->resetCache();

    $node = node_load($node->nid);

    $this->assertEqual($node->status, 1, 'Node has been saved.');

    // Now test saving a provided variable, which is renamed and modified before

    // it is saved.

    $title = $this->randomName();

    $rule = rule();

    $rule->action('entity_create', array(

      'type' => 'node',

      'param_type' => 'article',

      'param_author:select' => 'site:current-user',

      'param_title' => $title,

      'entity_created:var' => 'node',

    ));

    $rule->action('data_set', array(

      'data:select' => 'node:body',

      'value' => array('value' => 'body'),

    ));

    $rule->integrityCheck();

    $rule->execute();

    $node = $this->drupalGetNodeByTitle($title);

    $this->assertTrue(!empty($node) && $node->body[LANGUAGE_NONE][0]['value'] == 'body', 'Saved a provided variable');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests adding a variable and optional parameters.

   */

  public function testVariableAdding() {

    $node = $this->drupalCreateNode();

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->condition('rules_test_condition_true')

         ->action('rules_action_load_node')

         ->action('rules_action_delete_node', array('node:select' => 'node_loaded'))

         ->execute($node->nid);

    $this->assertEqual(FALSE, node_load($node->nid), 'Variable added and skipped optional parameter.');

    RulesLog::logger()->checkLog();

    $vars = $rule->conditions()->offsetGet(0)->availableVariables();

    $this->assertEqual(!isset($vars['node_loaded']), 'Loaded variable is not available to conditions.');

    // Test adding a variable with a custom variable name.

    $node = $this->drupalCreateNode();

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->action('rules_action_load_node', array('node_loaded:var' => 'node'))

         ->action('rules_action_delete_node')

         ->execute($node->nid);

    $this->assertEqual(FALSE, node_load($node->nid), 'Variable with custom name added.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests custom access for using component actions/conditions.

   */

  public function testRuleComponentAccess() {

    // Create a normal user.

    $normal_user = $this->drupalCreateUser();

    // Create a role for granting access to the rule component.

    $this->normal_role = $this->drupalCreateRole(array(), 'test_role');

    $normal_user->roles[$this->normal_role] = 'test_role';

    user_save($normal_user, array('roles' => $normal_user->roles));

    // Create an 'action set' rule component making use of a permission.

    $action_set = rules_action_set(array('node' => array('type' => 'node')));

    $action_set->access_exposed = TRUE;

    $action_set->save('rules_test_roles');

    // Set the global user to be the current one as access is checked for the

    // global user.

    global $user;

    $user = user_load($normal_user->uid);

    $this->assertFalse(rules_action('component_rules_test_roles')->access(), 'Authenticated user without the correct role can\'t use the rule component.');

    // Assign the role that will have permissions for the rule component.

    user_role_change_permissions($this->normal_role, array('use Rules component rules_test_roles' => TRUE));

    $this->assertTrue(rules_action('component_rules_test_roles')->access(), 'Authenticated user with the correct role can use the rule component.');

    // Reset global user to anonymous.

    $user = user_load(0);

    $this->assertFalse(rules_action('component_rules_test_roles')->access(), 'Anonymous user can\'t use the rule component.');

  }

  /**

   * Tests passing arguments by reference to an action.

   */

  public function testPassingByReference() {

    // Keeping references of variables is unsupported, though the

    // EntityMetadataArrayObject may be used to achieve that.

    $array = array('foo' => 'bar');

    $data = new EntityMetadataArrayObject($array);

    rules_action('rules_action_test_reference')->execute($data);

    $this->assertTrue($data['changed'], 'Parameter has been passed by reference');

  }

  /**

   * Tests sorting rule elements.

   */

  public function testSorting() {

    $rule = $this->createTestRule();

    $conditions = $rule->conditions();

    $conditions[0]->weight = 10;

    $conditions[2]->weight = 10;

    $id[0] = $conditions[0]->elementId();

    $id[1] = $conditions[1]->elementId();

    $id[2] = $conditions[2]->elementId();

    // For testing use a deep sort, even if not necessary here.

    $rule->sortChildren(TRUE);

    $conditions = $rule->conditions();

    $this->assertEqual($conditions[0]->elementId(), $id[1], 'Condition sorted correctly.');

    $this->assertEqual($conditions[1]->elementId(), $id[0], 'Condition sorted correctly.');

    $this->assertEqual($conditions[2]->elementId(), $id[2], 'Condition sorted correctly.');

  }

  /**

   * Tests using data selectors.

   */

  public function testDataSelectors() {

    $body[LANGUAGE_NONE][0] = array('value' => '<b>The body & nothing.</b>');

    $node = $this->drupalCreateNode(array('body' => $body, 'type' => 'page', 'summary' => ''));

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->action('rules_action_load_node')

         ->action('drupal_message', array('message:select' => 'node_loaded:body:value'))

         ->execute($node->nid);

    RulesLog::logger()->checkLog();

    $msg = drupal_get_messages('status');

    $last_msg = array_pop($msg['status']);

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertEqual($last_msg, $wrapper->body->value->value(array('sanitize' => TRUE)), 'Data selector for getting parameter applied.');

    // Get a "reference" on the same object as returned by node_load().

    $node = node_load($node->nid);

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->action('rules_action_load_node')

         ->action('data_set', array('data:select' => 'node_loaded:title', 'value' => 'Test title'))

         // Use two actions and make sure the node get saved only once.

         ->action('data_set', array('data:select' => 'node_loaded:title', 'value' => 'Test title2'))

         ->execute($node->nid);

    $wrapper = entity_metadata_wrapper('node', $node);

    $this->assertEqual('Test title2', $wrapper->title->value(), 'Data has been modified and saved.');

    RulesLog::logger()->checkLog();

    $text = RulesLog::logger()->render();

    $msg = RulesTestCase::t('Saved %node_loaded of type %node.', array('node_loaded', 'node'));

    if ($pos1 = strpos($text, $msg)) {

      $pos2 = strpos($text, $msg, $pos1 + 1);

    }

    $this->assertTrue($pos1 && $pos2 === FALSE, 'Data has been saved only once.');

    // Test validation.

    try {

      rules_action('data_set', array('data' => 'no-selector', 'value' => ''))->integrityCheck();

      $this->fail("Validation hasn't created an exception.");

    }

    catch (RulesIntegrityException $e) {

      $this->pass("Validation error correctly detected: " . $e);

    }

    // Test auto creation of nested data structures, like the node body field.

    // I.e. if $node->body is not set, it is automatically initialized to an

    // empty array, so that the nested value can be set and the wrappers do not

    // complain about missing parent data structures.

    $rule = rule();

    $rule->action('entity_create', array(

      'type' => 'node',

      'param_type' => 'page',

      'param_title' => 'foo',

      'param_author' => $GLOBALS['user'],

    ));

    $rule->action('data_set', array('data:select' => 'entity_created:body:value', 'value' => 'test content'))

         ->execute();

    try {

      RulesLog::logger()->checkLog();

      $this->pass('Auto creation of nested data structures.');

    }

    catch (Exception $e) {

      $this->fail('Auto creation of nested data structures.');

    }

    // Make sure variables that are passed wrapped work.

    $result = rules_condition('rules_test_condition_node_wrapped')->execute($node->nid);

    $this->assertTrue($result, 'Condition receiving wrapped parameter.');

    // Make sure wrapped parameters are checked for containing NULL values.

    $rule = rule(array('node' => array('type' => 'node', 'optional' => TRUE)));

    $rule->condition('rules_test_condition_node_wrapped', array('node:select' => 'node'));

    $rule->execute(entity_metadata_wrapper('node'));

    $text = RulesLog::logger()->render();

    $msg = RulesTestCase::t('The variable or parameter %node is empty.', array('node'));

    $this->assertTrue(strpos($text, $msg) !== FALSE, 'Evaluation aborted due to an empty argument value.');

  }

  /**

   * Tests making use of rule sets.

   */

  public function testRuleSets() {

    $set = rules_rule_set(array(

      'node' => array('type' => 'node', 'label' => 'node'),

    ));

    $set->rule(rule()->action('drupal_message', array('message:select' => 'node:title')))

        ->rule(rule()->condition('rules_condition_content_is_published')

                     ->action('drupal_message', array('message' => 'Node is published.'))

               );

    $set->integrityCheck()->save('rules_test_set_1');

    $node = $this->drupalCreateNode(array('title' => 'The title.', 'status' => 1));

    // Execute.

    rules_invoke_component('rules_test_set_1', $node);

    $msg = drupal_get_messages();

    $this->assertEqual($msg['status'][0], 'The title.', 'First rule evaluated.');

    $this->assertEqual($msg['status'][1], 'Node is published.', 'Second rule evaluated.');

    // Test a condition set.

    $set = rules_or(array(

      'node' => array('type' => 'node', 'label' => 'node'),

    ));

    $set->condition('data_is', array('data:select' => 'node:author:name', 'value' => 'notthename'))

        ->condition('data_is', array('data:select' => 'node:nid', 'value' => $node->nid))

        ->integrityCheck()

        ->save('test', 'rules_test');

    // Load and execute condition set.

    $set = rules_config_load('test');

    $this->assertTrue($set->execute($node), 'Set has been correctly evaluated.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests invoking components from the action.

   */

  public function testComponentInvocations() {

    $set = rules_rule_set(array(

      'node1' => array('type' => 'node', 'label' => 'node'),

    ));

    $set->rule(rule()->condition('node_is_published', array('node:select' => 'node1'))

                     ->action('node_unpublish', array('node:select' => 'node1'))

               );

    $set->integrityCheck()->save('rules_test_set_2');

    // Use different names for the variables to ensure they are properly mapped

    // when taking over the variables to be saved.

    $rule = rule(array(

      'node2' => array('type' => 'node', 'label' => 'node'),

    ));

    $rule->action('component_rules_test_set_2', array('node1:select' => 'node2'));

    $rule->action('node_make_sticky', array('node:select' => 'node2'));

    $node = $this->drupalCreateNode(array('title' => 'The title.', 'status' => 1, 'sticky' => 0));

    $rule->execute($node);

    $node = node_load($node->nid, NULL, TRUE);

    $this->assertFalse($node->status, 'The component changes have been saved correctly.');

    $this->assertTrue($node->sticky, 'The action changes have been saved correctly.');

    // Check that we have saved the changes only once.

    $text = RulesLog::logger()->render();

    // Make sure both saves are handled in one save operation.

    $this->assertEqual(substr_count($text, 'Saved'), 1, 'Changes have been saved in one save operation.');

    RulesLog::logger()->checkLog();

    // Test recursion prevention on components by invoking the component from

    // itself, what should be prevented.

    $set->action('component_rules_test_set_2', array('node1:select' => 'node1'))

        ->save();

    $rule->execute($node);

    $text1 = RulesLog::logger()->render();

    $text2 = RulesTestCase::t('Not evaluating rule set %rules_test_set_2 to prevent recursion.', array('rules_test_set_2'));

    $this->assertTrue((strpos($text1, $text2) !== FALSE), "Recursion of component invocation prevented.");

    // Test executing the component provided in code via the action. This makes

    // sure the component in code has been properly picked up.

    $node->status = 0;

    node_save($node);

    rules_action('component_rules_test_action_set')->execute($node);

    $this->assertTrue($node->status == 1, 'Component provided in code has been executed.');

  }

  /**

   * Tests asserting metadata.

   *

   * Customizes action info and makes sure integrity is checked.

   */

  public function testMetadataAssertion() {

    $action = rules_action('rules_node_make_sticky_action');

    // Test failing integrity check.

    try {

      $rule = rule(array('node' => array('type' => 'entity')));

      $rule->action($action);

      // Fails due to the 'node' variable not matching the node type.

      $rule->integrityCheck();

      $this->fail('Integrity check has not thrown an exception.');

    }

    catch (RulesIntegrityException $e) {

      $this->pass('Integrity check has thrown exception: ' . $e->getMessage());

    }

    // Test asserting additional metadata.

    $rule = rule(array('node' => array('type' => 'node')));

    // Customize action info using the settings.

    $rule->condition('data_is', array('data:select' => 'node:type', 'value' => 'page'))

         // Configure an condition using the body. As the body is a field,

         // this requires the bundle to be correctly asserted.

         ->condition(rules_condition('data_is', array('data:select' => 'node:body:value', 'value' => 'foo'))->negate())

         // The action also requires the page bundle in order to work.

         ->action($action);

    // Make sure the integrity check doesn't throw an exception.

    $rule->integrityCheck();

    // Test the rule.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0));

    $rule->execute($node);

    $this->assertTrue($node->sticky, 'Rule with asserted metadata executed.');

    // Test asserting metadata on a derived property, i.e. not a variable.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('entity_is_of_type', array('entity:select' => 'node:reference', 'type' => 'node'))

         ->condition('data_is', array('data:select' => 'node:reference:type', 'value' => 'page'))

         ->action('rules_node_page_make_sticky_action', array('node:select' => 'node:reference'));

    $rule->integrityCheck();

    $rule->execute($node);

    // Test asserting an entity field.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('entity_has_field', array('entity:select' => 'node:reference', 'field' => 'field_tags'))

         ->action('data_set', array('data:select' => 'node:reference:field-tags', 'value' => array()));

    $rule->integrityCheck();

    $rule->execute($node);

    // Make sure an asserted bundle can be used as argument.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('entity_is_of_type', array('entity:select' => 'node:reference', 'type' => 'node'))

         ->condition('node_is_of_type', array('node:select' => 'node:reference', 'type' => array('page')))

         ->action('rules_node_page_make_sticky_action', array('node:select' => 'node:reference'));

    $rule->integrityCheck();

    $rule->execute($node);

    // Test asserting metadata on a derived property being a list item.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('node_is_of_type', array('node:select' => 'node:ref-nodes:0', 'type' => array('article')))

         ->action('data_set', array('data:select' => 'node:ref-nodes:0:field-tags', 'value' => array()));

    $rule->integrityCheck();

    $rule->execute($node);

    // Give green lights if there were no exceptions and check rules-log errors.

    $this->pass('Rules asserting metadata on a derived property pass integrity checks.');

    RulesLog::logger()->checkLog();

    // Make sure assertions of a one list item are not valid for another item.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('node_is_of_type', array('node:select' => 'node:ref-nodes:0', 'type' => array('article')))

         ->action('data_set', array('data:select' => 'node:ref-nodes:1:field-tags', 'value' => array()));

    try {

      $rule->integrityCheck();

      $this->fail('Assertion of a list item is not valid for another item.');

    }

    catch (RulesException $e) {

      $this->pass('Assertion of a list item is not valid for another item.');

    }

  }

  /**

   * Tests using loops.

   */

  public function testLoops() {

    // Test passing the list parameter as argument to ensure that is working

    // generally for plugin container too.

    drupal_get_messages(NULL, TRUE);

    $loop = rules_loop();

    $loop->action('drupal_message', array('message' => 'test'));

    $arg_info = $loop->parameterInfo();

    $this->assert($arg_info['list']['type'] == 'list', 'Argument info contains list.');

    $loop->execute(array(1, 2));

    // Ensure the action has been executed twice, once for each list item.

    $msg = drupal_get_messages();

    $this->assert($msg['status'][0] == 'test' && $msg['status'][1], 'Loop has been properly executed');

    // Now test looping over nodes.

    $node1 = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0));

    $node2 = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0));

    $node3 = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0));

    $rule = rule(array(

      'list' => array(

        'type' => 'list<node>',

        'label' => 'A list of nodes',

      ),

    ));

    $loop = rules_loop(array('list:select' => 'list', 'item:var' => 'node'));

    $loop->action('data_set', array('data:select' => 'node:sticky', 'value' => TRUE));

    $rule->action($loop);

    // Test using a list with data selectors, just output the last nodes type.

    $rule->action('drupal_message', array('message:select' => 'list:2:type'));

    $rule->execute(array($node1->nid, $node2->nid, $node3->nid));

    $text = RulesLog::logger()->render();

    $save_msg = RulesTestCase::t('Saved %node of type %node.', array('node', 'node'));

    $this->assertTrue(substr_count($text, $save_msg) == 3, 'List item variables have been saved.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Tests access checks.

   */

  public function testAccessCheck() {

    $rule = rule();

    // Try to set a property which is provided by the test module and is not

    // accessible, so the access check has to return FALSE.

    $rule->action('data_set', array('data:select' => 'site:no-access-user', 'value' => 'foo'));

    $this->assertTrue($rule->access() === FALSE, 'Access check is working.');

  }

  /**

   * Tests returning provided variables.

   */

  public function testReturningVariables() {

    $node = $this->drupalCreateNode();

    $action = rules_action('entity_fetch', array('type' => 'node', 'id' => $node->nid));

    list($node2) = $action->execute();

    $this->assertTrue($node2->nid == $node->nid, 'Action returned a variable.');

    // Create a simple set that just passed through the given node.

    $set = rules_rule_set(array('node' => array('type' => 'node')), array('node'));

    $set->integrityCheck()->save('rules_test_set_1');

    $provides = $set->providesVariables();

    $this->assertTrue($provides['node']['type'] == 'node', 'Rule set correctly passed through the node.');

    list($node2) = $set->execute($node);

    $this->assertTrue($node2->nid == $node->nid, 'Rule set returned a variable.');

    // Create an action set returning a variable that is no parameter.

    $set = rules_action_set(array(

      'node' => array(

        'type' => 'node',

        'parameter' => FALSE,

      )), array('node'));

    $set->action('entity_fetch', array('type' => 'node', 'id' => $node->nid))

        ->action('data_set', array('data:select' => 'node', 'value:select' => 'entity_fetched'));

    $set->integrityCheck();

    list($node3) = $set->execute();

    $this->assertTrue($node3->nid == $node->nid, 'Action set returned a variable that has not been passed as parameter.');

    // Test the same again with a variable holding a not wrapped data type.

    $set = rules_action_set(array(

      'number' => array(

        'type' => 'integer',

        'parameter' => FALSE,

      )), array('number'));

    $set->action('data_set', array('data:select' => 'number', 'value' => 3));

    $set->integrityCheck();

    list($number) = $set->execute();

    $this->assertTrue($number == 3, 'Actions set returned a number.');

  }

  /**

   * Tests using input evaluators.

   */

  public function testInputEvaluators() {

    $node = $this->drupalCreateNode(array('title' => '<b>The body & nothing.</b>', 'type' => 'page'));

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->action('rules_action_load_node')

         ->action('drupal_message', array('message' => 'Title: [node_loaded:title]'))

         ->execute($node->nid);

    RulesLog::logger()->checkLog();

    $msg = drupal_get_messages();

    $this->assertEqual(array_pop($msg['status']), 'Title: ' . check_plain('<b>The body & nothing.</b>'), 'Token input evaluator applied.');

    // Test token replacements on a list of text values.

    $component = rules_action_set(array('var' => array('type' => 'list<text>', 'label' => 'var')), array('var'));

    $component->save('rules_test_input');

    $action = rules_action('component_rules_test_input', array('var' => array('uid: [site:current-user:uid]')));

    list($var) = $action->execute();

    $uid = $GLOBALS['user']->uid;

    $this->assertEqual(array("uid: $uid"), $var, 'Token replacements on a list of values applied.');

  }

  /**

   * Tests importing and exporting a rule.

   */

  public function testRuleImportExport() {

    $rule = rule(array('nid' => array('type' => 'integer')));

    $rule->name = "rules_export_test";

    $rule->action('rules_action_load_node')

         ->action('drupal_message', array('message' => 'Title: [node_loaded:title]'));

    $export =

'{ "rules_export_test" : {

    "PLUGIN" : "rule",

    "REQUIRES" : [ "rules_test", "rules" ],

    "USES VARIABLES" : { "nid" : { "type" : "integer" } },

    "DO" : [

      { "rules_action_load_node" : { "PROVIDE" : { "node_loaded" : { "node_loaded" : "Loaded content" } } } },

      { "drupal_message" : { "message" : "Title: [node_loaded:title]" } }

    ]

  }

}';

    $this->assertEqual($export, $rule->export(), 'Rule has been exported correctly.');

    // Test importing a rule which makes use of almost all features.

    $export = _rules_export_get_test_export();

    $rule = rules_import($export);

    $this->assertTrue(!empty($rule) && $rule->integrityCheck(), 'Rule has been imported.');

    // Test loading the same export provided as default rule.

    $rule = rules_config_load('rules_export_test');

    $this->assertTrue(!empty($rule) && $rule->integrityCheck(), 'Export has been provided in code.');

    // Export it and make sure the same export is generated again.

    $this->assertEqual($export, $rule->export(), 'Export of imported rule equals original export.');

    // Now try importing a rule set.

    $export =

'{ "rules_test_set" : {

    "LABEL" : "Test set",

    "PLUGIN" : "rule set",

    "REQUIRES" : [ "rules" ],

    "USES VARIABLES" : { "node" : { "label" : "Test node", "type" : "node" } },

    "RULES" : [

      { "RULE" : {

          "IF" : [ { "NOT data_is" : { "data" : [ "node:title" ], "value" : "test" } } ],

          "DO" : [ { "data_set" : { "data" : [ "node:title" ], "value" : "test" } } ],

          "LABEL" : "Test Rule"

        }

      },

      { "RULE" : {

          "DO" : [ { "drupal_message" : { "message" : "hi" } } ],

          "LABEL" : "Test Rule 2"

        }

      }

    ]

  }

}';

    $set = rules_import($export);

    $this->assertTrue(!empty($set) && $set->integrityCheck(), 'Rule set has been imported.');

    // Export it and make sure the same export is generated again.

    $this->assertEqual($export, $set->export(), 'Export of imported rule set equals original export.');

    // Try executing the imported rule set.

    $node = $this->drupalCreateNode();

    $set->execute($node);

    $this->assertEqual($node->title, 'test', 'Imported rule set has been executed.');

    RulesLog::logger()->checkLog();

    // Try import / export for a rule component providing a variable.

    $rule = rule(array(

      'number' => array(

        'type' => 'integer',

        'label' => 'Number',

        'parameter' => FALSE,

      )), array('number'));

    $rule->action('data_set', array('data:select' => 'number', 'value' => 3));

    $rule->name = 'rules_test_provides';

    $export = '{ "rules_test_provides" : {

    "PLUGIN" : "rule",

    "REQUIRES" : [ "rules" ],

    "USES VARIABLES" : { "number" : { "type" : "integer", "label" : "Number", "parameter" : false } },

    "DO" : [ { "data_set" : { "data" : [ "number" ], "value" : 3 } } ],

    "PROVIDES VARIABLES" : [ "number" ]

  }

}';

    $this->assertEqual($export, $rule->export(), 'Rule 2 has been exported correctly.');

    $imported_rule = rules_import($rule->export());

    $this->assertTrue(!empty($imported_rule) && $imported_rule->integrityCheck(), 'Rule 2 has been imported.');

    $this->assertEqual($export, $imported_rule->export(), 'Export of imported rule 2 equals original export.');

    // Test importing a negated condition component.

    $export = '{ "rules_negated_component" : {

    "LABEL" : "negated_component",

    "PLUGIN" : "or",

    "REQUIRES" : [ "rules" ],

    "NOT OR" : [ { "data_is_empty" : { "data" : [ "site:slogan" ] } } ]

  }

}';

    $or = rules_import($export);

    $this->assertTrue($or->integrityCheck() && $or->isNegated(), 'Negated condition component imported.');

  }

  /**

   * Tests the named parameter mode.

   */

  public function testNamedParameters() {

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->action('rules_action_node_set_title', array('title' => 'foo'));

    $rule->integrityCheck();

    // Test the rule.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0));

    $rule->execute($node);

    $this->assertTrue($node->title == 'foo', 'Action with named parameters has been correctly executed.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Makes sure Rules aborts when NULL values are used.

   */

  public function testAbortOnNULLValues() {

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->action('drupal_message', array('message:select' => 'node:log'));

    $rule->integrityCheck();

    // Test the rule.

    $node = $this->drupalCreateNode();

    $node->log = NULL;

    $rule->execute($node);

    $text = RulesLog::logger()->render();

    $msg = RulesTestCase::t('The variable or parameter %message is empty.', array('message'));

    $this->assertTrue(strpos($text, $msg) !== FALSE, 'Evaluation aborted due to an empty argument value.');

  }

}

/**

 * Test rules data wrappers.

 */

class RulesTestDataCase extends DrupalWebTestCase {

  /**

   * Declares test metadata.

   */

  public static function getInfo() {

    return array(

      'name' => 'Rules Data tests',

      'description' => 'Tests rules data saving and type matching.',

      'group' => 'Rules',

    );

  }

  /**

   * Overrides DrupalWebTestCase::setUp().

   */

  protected function setUp() {

    parent::setUp('rules', 'rules_test');

    variable_set('rules_debug_log', TRUE);

    // Make sure we don't ran over issues with the node_load static cache.

    entity_get_controller('node')->resetCache();

  }

  /**

   * Tests intelligently saving data.

   */

  public function testDataSaving() {

    $node = $this->drupalCreateNode();

    $state = new RulesState(rule());

    $state->addVariable('node', $node, array('type' => 'node'));

    $wrapper = $state->get('node');

    $node->title = 'test';

    $wrapper->set($node);

    $state->saveChanges('node', $wrapper, FALSE);

    $this->assertFalse($this->drupalGetNodeByTitle('test'), 'Changes have not been saved.');

    $state->saveChanges('node', $wrapper, TRUE);

    $this->assertTrue($this->drupalGetNodeByTitle('test'), 'Changes have been saved.');

    // Test skipping saving.

    $state->addVariable('node2', $node, array(

      'type' => 'node',

      'skip save' => TRUE,

    ));

    $wrapper = $state->get('node2');

    $node->title = 'test2';

    $wrapper->set($node);

    $state->saveChanges('node2', $wrapper, TRUE);

    $this->assertFalse($this->drupalGetNodeByTitle('test2'), 'Changes have not been saved.');

    // Try saving a non-entity wrapper, which should result in saving the

    // parent entity containing the property.

    $wrapper = $state->get('node');

    $wrapper->title->set('test3');

    $state->saveChanges('node:title', $wrapper, TRUE);

    $this->assertTrue($this->drupalGetNodeByTitle('test3'), 'Parent entity has been saved.');

  }

  /**

   * Tests type matching.

   */

  public function testTypeMatching() {

    $entity = array('type' => 'entity');

    $node = array('type' => 'node');

    $this->assertTrue(RulesData::typesMatch($node, $entity), 'Types match.');

    $this->assertFalse(RulesData::typesMatch($entity, $node), 'Types don\'t match.');

    $this->assertTrue(RulesData::typesMatch($node + array('bundle' => 'page'), $node), 'Types match.');

    $this->assertTrue(RulesData::typesMatch($node + array('bundle' => 'page'), $entity), 'Types match.');

    $this->assertTrue(RulesData::typesMatch(array('type' => 'list<node>'), array('type' => 'list')), 'Types match.');

    $this->assertTrue(RulesData::typesMatch($node + array('bundle' => 'page'), $node + array('bundles' => array('page', 'story'))), 'Types match.');

    $this->assertFalse(RulesData::typesMatch($node, $node + array('bundles' => array('page', 'story'))), 'Types don\'t match.');

    // Test that a type matches its grand-parent type (text > decimal > integer)

    $this->assertTrue(RulesData::typesMatch(array('type' => 'integer'), array('type' => 'text')), 'Types match.');

    $this->assertFalse(RulesData::typesMatch(array('type' => 'text'), array('type' => 'integer')), 'Types don\'t match.');

  }

  /**

   * Tests making use of custom wrapper classes.

   */

  public function testCustomWrapperClasses() {

    // Test loading a vocabulary by name, which is done by a custom wrapper.

    $set = rules_action_set(array('vocab' => array('type' => 'taxonomy_vocabulary')), array('vocab'));

    $set->action('drupal_message', array('message:select' => 'vocab:name'));

    $set->integrityCheck();

    list($vocab) = $set->execute('tags');

    $this->assertTrue($vocab->machine_name == 'tags', 'Loaded vocabulary by name.');

    // Now test wrapper creation for a direct input argument value.

    $set = rules_action_set(array('term' => array('type' => 'taxonomy_term')));

    $set->action('data_set', array('data:select' => 'term:vocabulary', 'value' => 'tags'));

    $set->integrityCheck();

    $vocab = entity_create('taxonomy_vocabulary', array(

      'name' => 'foo',

      'machine_name' => 'foo',

    ));

    entity_save('taxonomy_vocabulary', $vocab);

    $term_wrapped = entity_property_values_create_entity('taxonomy_term', array(

      'name' => $this->randomName(),

      'vocabulary' => $vocab,

    ))->save();

    $set->execute($term_wrapped);

    $this->assertEqual($term_wrapped->vocabulary->machine_name->value(), 'tags', 'Vocabulary name used as direct input value.');

    RulesLog::logger()->checkLog();

  }

  /**

   * Makes sure the RulesIdentifiableDataWrapper is working correctly.

   */

  public function testRulesIdentifiableDataWrapper() {

    $node = $this->drupalCreateNode();

    $wrapper = new RulesTestTypeWrapper('rules_test_type', $node);

    $this->assertTrue($wrapper->value() == $node, 'Data correctly wrapped.');

    // Test serializing and make sure only the id is stored.

    $this->assertTrue(strpos(serialize($wrapper), $node->title) === FALSE, 'Data has been correctly serialized.');

    $this->assertEqual(unserialize(serialize($wrapper))->value()->title, $node->title, 'Serializing works right.');

    $wrapper2 = unserialize(serialize($wrapper));

    // Test serializing the unloaded wrapper.

    $this->assertEqual(unserialize(serialize($wrapper2))->value()->title, $node->title, 'Serializing works right.');

    // Test loading a not more existing node.

    $s = serialize($wrapper2);

    node_delete($node->nid);

    $this->assertFalse(node_load($node->nid), 'Node deleted.');

    try {

      unserialize($s)->value();

      $this->fail("Loading hasn't created an exception.");

    }

    catch (EntityMetadataWrapperException $e) {

      $this->pass("Exception was thrown: " . $e->getMessage());

    }

    // Test saving a savable custom, identifiable wrapper.

    $action = rules_action('test_type_save');

    $node = $this->drupalCreateNode(array('status' => 0, 'type' => 'page'));

    $node->status = 1;

    $action->execute($node);

    // Load the node fresh from the db.

    $node = node_load($node->nid, NULL, TRUE);

    $this->assertEqual($node->status, 1, 'Savable non-entity has been saved.');

  }

}

/**

 * Test triggering rules.

 */

class RulesTriggerTestCase extends DrupalWebTestCase {

  /**

   * Declares test metadata.

   */

  public static function getInfo() {

    return array(

      'name' => 'Reaction Rules',

      'description' => 'Tests triggering reactive rules.',

      'group' => 'Rules',

    );

  }

  /**

   * Overrides DrupalWebTestCase::setUp().

   */

  protected function setUp() {

    parent::setUp('rules', 'rules_test');

    RulesLog::logger()->clear();

    variable_set('rules_debug_log', TRUE);

  }

  /**

   * Helper function to create a test Rule.

   */

  protected function createTestRule($action = TRUE, $event = 'node_presave') {

    $rule = rules_reaction_rule();

    $rule->event($event)

         ->condition(rules_condition('data_is', array('data:select' => 'node:status', 'value' => TRUE))->negate())

         ->condition('data_is', array('data:select' => 'node:type', 'value' => 'page'));

    if ($action) {

      $rule->action('rules_action_delete_node');

    }

    return $rule;

  }

  /**

   * Tests CRUD for reaction rules - making sure the events are stored properly.

   */

  public function testReactiveRuleCreation() {

    $rule = $this->createTestRule();

    $rule->save();

    $result = db_query("SELECT event FROM {rules_trigger} WHERE id = :id", array(':id' => $rule->id));

    $this->assertEqual($result->fetchField(), 'node_presave', 'Associated event has been saved.');

    // Try updating.

    $rule->removeEvent('node_presave');

    $rule->event('node_insert');

    $rule->event('node_update');

    $rule->active = FALSE;

    $rule->integrityCheck()->save();

    $result = db_query("SELECT event FROM {rules_trigger} WHERE id = :id", array(':id' => $rule->id));

    $this->assertEqual($result->fetchCol(), array_values($rule->events()), 'Updated associated events.');

    // Try deleting.

    $rule->delete();

    $result = db_query("SELECT event FROM {rules_trigger} WHERE id = :id", array(':id' => $rule->id));

    $this->assertEqual($result->fetchField(), FALSE, 'Deleted associated events.');

  }

  /**

   * Tests creating and triggering a basic reaction rule.

   */

  public function testBasicReactionRule() {

    $node = $this->drupalCreateNode(array('type' => 'page'));

    $rule = $this->createTestRule();

    $rule->integrityCheck()->save();

    // Test the basics of the event set work right.

    $event = rules_get_cache('event_node_presave');

    $this->assertEqual(array_keys($event->parameterInfo()), array('node'), 'EventSet returns correct argument info.');

    // Trigger the rule by updating the node.

    $nid = $node->nid;

    $node->status = 0;

    node_save($node);

    RulesLog::logger()->checkLog();

    $this->assertFalse(node_load($nid), 'Rule successfully triggered and executed');

    // debug(RulesLog::logger()->render());

  }

  /**

   * Tests a rule using a handler to load a variable.

   */

  public function testVariableHandler() {

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    $rule = $this->createTestRule(FALSE, 'node_update');

    $rule->action('rules_node_publish_action_save', array('node:select' => 'node_unchanged'));

    // Test without recursion prevention to make sure recursive invocations

    // work right too. This rule won't ran in an infinite loop anyway.

    $rule->recursion = TRUE;

    $rule->label = 'rule 1';

    $rule->integrityCheck()->save();

    $node->status = 0;

    $node->sticky = 1;

    node_save($node);

    RulesLog::logger()->checkLog();

    entity_get_controller('node')->resetCache();

    $node = node_load($node->nid);

    $this->assertFalse($node->sticky, 'Parameter has been loaded and saved.');

    $this->assertTrue($node->status, 'Action has been executed.');

    // Ensure the rule was evaluated a second time.

    $text = RulesLog::logger()->render();

    $msg = RulesTestCase::t('Evaluating conditions of rule %rule 1', array('rule 1'));

    $pos = strpos($text, $msg);

    $pos = ($pos !== FALSE) ? strpos($text, $msg, $pos) : FALSE;

    $this->assertTrue($pos !== FALSE, "Recursion prevented.");

    // debug(RulesLog::logger()->render());

  }

  /**

   * Tests aborting silently when handlers are not able to load.

   */

  public function testVariableHandlerFailing() {

    $rule = $this->createTestRule(FALSE, 'node_presave');

    $rule->action('rules_node_publish_action_save', array('node:select' => 'node_unchanged'));

    $rule->integrityCheck()->save();

    // On insert it's not possible to get the unchanged node during presave.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    // debug(RulesLog::logger()->render());

    $text = RulesTestCase::t('Unable to load variable %node_unchanged, aborting.', array('node_unchanged'));

    $this->assertTrue(strpos(RulesLog::logger()->render(), $text) !== FALSE, "Aborted evaluation.");

  }

  /**

   * Tests preventing recursive rule invocations.

   *

   * Creates a rule that reacts on node-update then generates a node update

   * that would trigger it itself.

   */

  public function testRecursionPrevention() {

    $rule = $this->createTestRule(FALSE, 'node_update');

    $rule->action('rules_node_make_sticky_action');

    $rule->integrityCheck()->save();

    // Now trigger the rule.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    node_save($node);

    $text = RulesTestCase::t('Not evaluating reaction rule %label to prevent recursion.', array('label' => $rule->name));

    // debug(RulesLog::logger()->render());

    $this->assertTrue((strpos(RulesLog::logger()->render(), $text) !== FALSE), "Recursion prevented.");

    // debug(RulesLog::logger()->render());

  }

  /**

   * Tests recursion prevention with altered arguments.

   *

   * Ensure the recursion prevention still allows the rule to trigger again

   * during evaluation of the same event set, if the event isn't caused by the

   * rule itself - thus we won't run in an infinite loop.

   */

  public function testRecursionOnDifferentArguments() {

    // Create rule1 - which might recurse.

    $rule = $this->createTestRule(FALSE, 'node_update');

    $rule->action('rules_node_make_sticky_action');

    $rule->label = 'rule 1';

    $rule->integrityCheck()->save();

    // Create rule2 - which triggers rule1 on another node.

    $node2 = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    $rule2 = $this->createTestRule(FALSE, 'node_update');

    $rule2->action('rules_action_load_node', array('nid' => $node2->nid))

          ->action('rules_node_make_sticky_action', array('node:select' => 'node_loaded'));

    $rule2->label = 'rule 2';

    $rule2->save();

    // Now trigger both rules by generating the event.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    node_save($node);

    // debug(RulesLog::logger()->render());

    $text = RulesLog::logger()->render();

    $pos = strpos($text, RulesTestCase::t('Evaluating conditions of rule %rule 1', array('rule 1')));

    $pos = ($pos !== FALSE) ? strpos($text, RulesTestCase::t('Evaluating conditions of rule %rule 2', array('rule 2')), $pos) : FALSE;

    $pos = ($pos !== FALSE) ? strpos($text, RulesTestCase::t('Saved %node_loaded of type %node.', array('node_loaded', 'node')), $pos) : FALSE;

    $pos = ($pos !== FALSE) ? strpos($text, RulesTestCase::t('Evaluating conditions of rule %rule 1', array('rule 1')), $pos) : FALSE;

    $pos = ($pos !== FALSE) ? strpos($text, RulesTestCase::t('Not evaluating reaction rule %rule 2 to prevent recursion', array('rule 2')), $pos) : FALSE;

    $this->assertTrue($pos !== FALSE, 'Rule1 was triggered on the event caused by Rule2.');

  }

  /**

   * Tests the provided default rule 'rules_test_default_1'.

   */

  public function testDefaultRule() {

    $rule = rules_config_load('rules_test_default_1');

    $this->assertTrue($rule->status & ENTITY_IN_CODE && !($rule->status & ENTITY_IN_DB), 'Default rule can be loaded and has the right status.');

    $this->assertTrue($rule->tags == array('Admin', 'Tag2'), 'Default rule has correct tags.');

    // Enable.

    $rule->active = TRUE;

    $rule->save();

    // Create a node that triggers the rule.

    $node = $this->drupalCreateNode(array('type' => 'page', 'sticky' => 0, 'status' => 0));

    // Clear messages.

    drupal_get_messages();

    // Let event node_update occur.

    node_save($node);

    $msg = drupal_get_messages();

    $this->assertEqual($msg['status'][0], 'A node has been updated.', 'Default rule has been triggered.');

  }

  /**

   * Tests creating and triggering a reaction rule with event settings.

   */

  public function testEventSettings() {

    $rule = rules_reaction_rule();

    $rule->event('node_presave', array('bundle' => 'article'))

      ->condition('data_is_empty', array('data:select' => 'node:field-tags'))

      ->action('node_publish', array('node:select' => 'node'));

    $rule->integrityCheck()->save();

    $node = $this->drupalCreateNode(array('type' => 'page', 'status' => 0));

    $this->assertEqual($node->status, 0, 'Rule has not been triggered.');

    $node = $this->drupalCreateNode(array('type' => 'article', 'status' => 0));

    $this->assertEqual($node->status, 1, 'Rule has been triggered.');

    RulesLog::logger()->checkLog();

    // Make sure an invalid bundle raises integrity problems.

    $rule->event('node_presave', array('bundle' => 'invalid'));

    try {

      $rule->integrityCheck();

      $this->fail('Integrity check failed.');

    }

    catch (RulesIntegrityException $e) {

      $this->pass('Integrity check failed: ' . $e);

    }

  }

}

/**

 * Tests provided module integration.

 */

class RulesIntegrationTestCase extends DrupalWebTestCase {

  /**

   * Declares test metadata.

   */

  public static function getInfo() {

    return array(

      'name' => 'Rules Core Integration',

      'description' => 'Tests provided integration for drupal core.',

      'group' => 'Rules',

    );

  }

  /**

   * Overrides DrupalWebTestCase::setUp().

   */

  protected function setUp() {

    parent::setUp('rules', 'rules_test', 'php', 'path');

    RulesLog::logger()->clear();

    variable_set('rules_debug_log', TRUE);

  }

  /**

   * Just makes sure the access callback run without errors.

   */

  public function testAccessCallbacks() {

    $cache = rules_get_cache();

    foreach (array('action', 'condition', 'event') as $type) {

      foreach (rules_fetch_data($type . '_info') as $name => $info) {

        if (isset($info['access callback'])) {

          $info['access callback']($type, $name);

        }

      }

    }

  }

  /**

   * Tests data integration.

   */

  public function testDataIntegration() {

    // Test data_create action.

    $action = rules_action('data_create', array(

      'type' => 'log_entry',

      'param_type' => 'rules_test',

      'param_message' => 'Rules test log message',

      'param_severity' => WATCHDOG_WARNING,

      'param_request_uri' => 'http://example.com',

      'param_link' => '',

    ));

    $action->access();

    $action->execute();

    $text = RulesLog::logger()->render();

    $pos = strpos($text, RulesTestCase::t('Added the provided variable %data_created of type %log_entry', array('data_created', 'log_entry')));

    $this->assertTrue($pos !== FALSE, 'Data of type log entry has been created.');

    // Test variable_add action.

    $action = rules_action('variable_add', array(

      'type' => 'text_formatted',

      'value' => array(

        'value' => 'test text',

        'format' => 1,

      ),

    ));

    $action->access();

    $action->execute();

    $text = RulesLog::logger()->render();

    $pos = strpos($text, RulesTestCase::t('Added the provided variable %variable_added of type %text_formatted', array('variable_added', 'text_formatted')));

    $this->assertTrue($pos !== FALSE, 'Data of type text formatted has been created.');

    // Test using the list actions.

    $rule = rule(array(

      'list' => array(

        'type' => 'list<text>',

        'label' => 'A list of text',

      ),

    ));

    $rule->action('list_add', array('list:select' => 'list', 'item' => 'bar2'));

    $rule->action('list_add', array('list:select' => 'list', 'item' => 'bar', 'pos' => 'start'));

    $rule->action('list_add', array('list:select' => 'list', 'item' => 'bar', 'unique' => TRUE));

    $rule->action('list_remove', array('list:select' => 'list', 'item' => 'bar2'));

    $list = entity_metadata_wrapper('list', array('foo', 'foo2'));

    $rule->execute($list);

    RulesLog::logger()->checkLog();

    $this->assertEqual($list->value(), array('bar', 'foo', 'foo2'), 'List items removed and added.');

    $this->assertFalse(rules_condition('list_contains')->execute($list, 'foo-bar'), 'Condition "List item contains" evaluates to FALSE');

    $this->assertTrue(rules_condition('list_contains')->execute($list, 'foo'), 'Condition "List item contains" evaluates to TRUE');

    // debug(RulesLog::logger()->render());

    // Test data_is condition with IN operation.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('data_is', array('data:select' => 'node:title', 'op' => 'IN', 'value' => array('foo', 'bar')));

    $rule->action('data_set', array('data:select' => 'node:title', 'value' => 'bar'));

    $rule->integrityCheck();

    $node = $this->drupalCreateNode(array('title' => 'foo'));

    $rule->execute($node);

    $this->assertEqual($node->title, 'bar', "Data comparison using IN operation evaluates to TRUE.");

    // Test Condition: Data is empty.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('data_is_empty', array('data:select' => 'node:title'));

    $rule->action('data_set', array('data:select' => 'node:title', 'value' => 'bar'));

    $rule->integrityCheck();

    // Data is empty condition evaluates to TRUE

    // for node with empty title, action sets title to 'bar'.

    $node = $this->drupalCreateNode(array('title' => '', 'type' => 'article'));

    $rule->execute($node);

    $this->assertEqual($node->title, 'bar', "Data is empty condition evaluates to TRUE for node with empty title, action sets title to 'bar'.");

    // Data is empty condition evaluates to FALSE

    // for node with title 'foo', action is not executed.

    $node = $this->drupalCreateNode(array('title' => 'foo', 'type' => 'article'));

    $rule->execute($node);

    $this->assertEqual($node->title, 'foo', "Data is empty condition evaluates to FALSE for node with title 'foo', action is not executed.");

    // Data is empty condition evaluates to TRUE for the parent of a

    // not existing term in the tags field of the node.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->condition('node_is_of_type', array('type' => array('article')));

    $rule->condition('data_is_empty', array('data:select' => 'node:field-tags:0:parent'));

    $rule->action('data_set', array('data:select' => 'node:title', 'value' => 'bar'));

    $rule->integrityCheck();

    $node = $this->drupalCreateNode(array('title' => 'foo', 'type' => 'article'));

    $rule->execute($node);

    $this->assertEqual($node->title, 'bar', "Data is empty condition evaluates to TRUE for not existing data structures");

    // Test Action: Calculate a value.

    $rule = rule(array('node' => array('type' => 'node')));

    $rule->action('data_calc', array('input_1:select' => 'node:nid', 'op' => '*', 'input_2' => 2));

    $rule->action('data_set', array('data:select' => 'node:title', 'value:select' => 'result'));

    $rule->integrityCheck();

    $rule->execute($node);

    $this->assertEqual($node->title, $node->nid * 2, "Value has been calculated.");

    // Test moving a date.

    $action_set = rules_action_set(array('date' => array('type' => 'date')), array('date'));

    $action_set->action('data_calc', array('input_1:select' => 'date', 'op' => '+', 'input_2' => 3600))

               ->action('data_set', array('data:select' => 'date', 'value:select' => 'result'));

    $action_set->integrityCheck();

    list($result) = $action_set->execute(REQUEST_TIME);

    $this->assertEqual($result, REQUEST_TIME + 3600, 'Used data calculation action to move a date by an hour.');

    // Test data type conversion action.

    $set = rules_action_set(array('result' => array('type' => 'text', 'parameter' => FALSE)), array('result'));

    $set->action('data_convert', array('type' => 'text', 'value:select' => 'site:login-url'));

    $set->action('data_set', array('data:select' => 'result', 'value:select' => 'conversion_result'));

    list($result) = $set->execute();

    $set->integrityCheck();

    $this->assertEqual($result, url('user', array('absolute' => TRUE)), 'Converted URI to text.');

    $set = rules_action_set(array(

      'result' => array('type' => 'integer', 'parameter' => FALSE),

      'source' => array('type' => 'text'),

    ), array('result'));

    $set->action('data_convert', array('type' => 'integer', 'value:select' => 'source'));

    $set->action('data_set', array('data:select' => 'result', 'value:select' => 'conversion_result'));

    list($result) = $set->execute('9.4');

    $this->assertEqual($result, 9, 'Converted decimal to integer using rounding.');

    $set = rules_action_set(array(

      'result' => array('type' => 'integer', 'parameter' => FALSE),

      'source' => array('type' => 'text'),

    ), array('result'));

    $set->action('data_convert', array('type' => 'integer', 'value:select' => 'source', 'rounding_behavior' => 'down'));

    $set->action('data_set', array('data:select' => 'result', 'value:select' => 'conversion_result'));

    list($result) = $set->execute('9.6');

    $this->assertEqual($result, 9, 'Converted decimal to integer using rounding behavior down.');

    $set = rules_action_set(array(

      'result' => array('type' => 'integer', 'parameter' => FALSE),

      'source' => array('type' => 'text'),

    ), array('result'));

    $set->action('data_convert', array('type' => 'integer', 'value:select' => 'source', 'rounding_behavior' => 'up'));

    $set->action('data_set', array('data:select' => 'result', 'value:select' => 'conversion_result'));

    list($result) = $set->execute('9.4');

    $this->assertEqual($result, 10, 'Converted decimal to integer using rounding behavior up.');

    // Test text matching condition.

    $result = rules_condition('text_matches')->execute('my-text', 'text', 'contains');

    $result2 = rules_condition('text_matches')->execute('my-text', 'tex2t', 'contains');

    $this->assertTrue($result && !$result2, 'Text matching condition using operation contain evaluated.');

    $result = rules_condition('text_matches')->execute('my-text', 'my', 'starts');

    $result2 = rules_condition('text_matches')->execute('my-text', 'text', 'starts');

    $this->assertTrue($result && !$result2, 'Text matching condition using operation starts evaluated.');

    $result = rules_condition('text_matches')->execute('my-text', 'text', 'ends');

    $result2 = rules_condition('text_matches')->execute('my-text', 'my', 'ends');

    $this->assertTrue($result && !$result2, 'Text matching condition using operation ends evaluated.');

    $result = rules_condition('text_matches')->execute('my-text', 'me?y-texx?t', 'regex');

    $result2 = rules_condition('text_matches')->execute('my-text', 'me+y-texx?t', 'regex');

    $this->assertTrue($result && !$result2, 'Text matching condition using operation regex evaluated.');

  }

  /**

   * Tests entity related integration.

   */

  public function testEntityIntegration() {

    global $user;

    $page = $this->drupalCreateNode(array('type' => 'page'));

    $article = $this->drupalCreateNode(array('type' => 'article'));

    $result = rules_condition('entity_field_access')

      ->execute(entity_metadata_wrapper('node', $article), 'field_tags');

    $this->assertTrue($result);

    // Test entity_is_of_bundle condition.

    $result = rules_condition('entity_is_of_bundle', array(

      'type' => 'node',

      'bundle' => array('article'),

    ))->execute(entity_metadata_wrapper('node', $page));

    $this->assertFalse($result, 'Entity is of bundle condition has not been met.');

    $result = rules_condition('entity_is_of_bundle', array(

      'type' => 'node',

      'bundle' => array('article'),

    ))->execute(entity_metadata_wrapper('node', $article));

    $this->assertTrue($result, 'Entity is of bundle condition has been met.');

    // Also test a full rule so the integrity check must work.

    $term_wrapped = entity_property_values_create_entity('taxonomy_term', array(

      'name' => $this->randomName(),

      'vocabulary' => 1,

    ))->save();

    $rule = rule(array(

      'node' => array('type' => 'node'),

    ));

    $rule->condition('entity_is_of_bundle', array(

      'entity:select' => 'node',

      'bundle' => array('article'),

    ));

    $rule->action('data_set', array('data:select' => 'node:field_tags', 'value' => array($term_wrapped->getIdentifier())));

    $rule->integrityCheck();

    $rule->execute($article);