Club Drupal

 * Rules tests.

 */

class RulesTestCase extends DrupalWebTestCase {

    return array(

      'name' => 'Rules Engine tests',

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

    );

  }

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

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

  }

  /**

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

   */

    $placeholders = array();

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

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

    return strtr($text, $placeholders);

  }

  protected function createTestRule() {

    $rule = rule();

    $rule->condition('rules_test_condition_true')

  /**

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

   */

    $rule = $this->createTestRule();

    $rule->integrityCheck();

    $rule->execute();

  }

  /**

   */

    $action = rules_action('rules_node_publish_action');

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

  }

  /**

   */

    $action = rules_action('rules_node_publish_action');

    $s = serialize($action);

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

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

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

    // Inspect the cache

  }

  /**

   */

    $action = rules_action('rules_node_publish_action');

    try {

      $action->execute();

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

    }

    catch (RulesEvaluationException $e) {

    }

  }

  /**

   */

    $rule = rule(array(

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

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

  /**

   * Tests making use of class based actions.

   */

    $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');

  /**

   * Tests CRUD functionality.

   */

    $rule = $this->createTestRule();

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

  }

  /**

   */

    // 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.');

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

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

  }

  /**

   */

    $node = $this->drupalCreateNode();

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

    $rule->condition('rules_test_condition_true')

    $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')));

  }

  /**

   */

    // Create a normal user.

    $normal_user = $this->drupalCreateUser();

    // Create a role for granting access to 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.');

    $user = user_load(0);

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

  }

  /**

   */

    // Keeping references of variables is unsupported, though the

    // EntityMetadataArrayObject may be used to achieve that.

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

  }

  /**

   */

    $rule = $this->createTestRule();

    $conditions = $rule->conditions();

    $conditions[0]->weight = 10;

  /**

   * Tests using data selectors.

   */

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

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

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

    }

    catch (RulesIntegrityException $e) {

    }

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

  /**

   * Tests making use of rule sets.

   */

    $set = rules_rule_set(array(

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

    ));

  /**

   * Tests invoking components from the action.

   */

    $set = rules_rule_set(array(

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

    ));

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

  }

  /**

   */

    $action = rules_action('rules_node_make_sticky_action');

    // Test failing integrity check.

    // Test asserting additional metadata.

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

    // Customize action info using the settings.

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

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

    $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'))

  }

  /**

   */

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

    // generally for plugin container too.

    drupal_get_messages(NULL, TRUE);

      '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 = 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.

  }

  /**

   */

    $node = $this->drupalCreateNode();

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

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

  /**

   * Tests using input evaluators.

   */

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

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

  }

  /**

   */

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

    $rule->name = "rules_export_test";

    $rule->action('rules_action_load_node')

  }

  /**

   */

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

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

    $rule->integrityCheck();

  }

  /**

   */

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

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

    $rule->integrityCheck();

    $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.');

  }

}

/**

 */

class RulesTestDataCase extends DrupalWebTestCase {

    return array(

      'name' => 'Rules Data tests',

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

    );

  }

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

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

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

  }

  /**

   * Tests intelligently saving data.

   */

    $node = $this->drupalCreateNode();

    $state = new RulesState(rule());

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

  }

  /**

   */

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

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

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

  /**

   * Tests making use of custom wrapper classes.

   */

    // 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'));

  /**

   * Makes sure the RulesIdentifiableDataWrapper is working correctly.

   */

    $node = $this->drupalCreateNode();

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

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

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

    }

    catch (EntityMetadataWrapperException $e) {

    }

    // Test saving a savable custom, identifiable wrapper.

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

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

  }

}

/**

 */

class RulesTriggerTestCase extends DrupalWebTestCase {

    return array(

      'name' => 'Reaction Rules',

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

    );

  }

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

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

  }

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

    $rule = rules_reaction_rule();

    $rule->event($event)

  /**

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

   */

    $rule = $this->createTestRule();

    $rule->save();

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

  /**

   * Tests creating and triggering a basic reaction rule.

   */

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

    $rule = $this->createTestRule();

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

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

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

  }

  /**

   */

    $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'));

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

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

    $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.");

  }

  /**

   */

    $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));

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

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

  }

  /**

   */

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

    $rule->action('rules_node_make_sticky_action');

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

    node_save($node);

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

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

  }

  /**

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

   */

    // Create rule1 - which might recurse.

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

    $rule->action('rules_node_make_sticky_action');

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

    node_save($node);

    $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;

  /**

   * Tests the provided default rule 'rules_test_default_1'.

   */

    $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.');

    // Enable.

    $rule->active = TRUE;

    $rule->save();

  /**

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

   */

    $rule = rules_reaction_rule();

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

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

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

    }

  }

}

/**

 */

class RulesIntegrationTestCase extends DrupalWebTestCase {

    return array(

      'name' => 'Rules Core Integration',

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

    );

  }

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

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

  }

  /**

   */

    $cache = rules_get_cache();

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

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

  }

  /**

   */

    // Test data_create action.

    $action = rules_action('data_create', array(

      'type' => 'log_entry',

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

    $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'));

    $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');

    // Test data_is condition with IN operation.

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

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

    $rule->execute($node);

    // Test Condition: Data is empty.

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

    $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');

    $set = rules_action_set(array(

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

  /**

   * Tests entity related integration.

   */

    global $user;

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

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

    $this->assertTrue($result);

    $result = rules_condition('entity_is_of_bundle', array(

      'type' => 'node',

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

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

    $pos = ($pos !== FALSE) ? strpos($text, RulesTestCase::t('Evaluating the action %entity_delete.', array('entity_delete')), $pos) : FALSE;

    $this->assertTrue($pos !== FALSE, 'Data has been fetched, saved and deleted.');

    $node = entity_property_values_create_entity('node', array(

      'type' => 'article',

    $this->assertEqual(entity_metadata_wrapper('node', $node->nid)->title->value(), 'bar', 'Entity is of type condition correctly asserts the entity type.');

    // Test the entity_query action.

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

    $rule = rule();

  }

  /**

   */

    $term = entity_property_values_create_entity('taxonomy_term', array(

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

      'vocabulary' => 1,

  }

  /**

   */

    $tests = array(

      array('node_unpublish', 'node_is_published', 'node_publish', 'status'),

      array('node_make_unsticky', 'node_is_sticky', 'node_make_sticky', 'sticky'),

      rules_action($action1)->execute($node);

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

      $return = rules_condition($condition)->execute($node);

      rules_action($action2)->execute($node);

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

      $return = rules_condition($condition)->execute($node);

    }

    $return = rules_condition('node_is_of_type', array('type' => array('page', 'article')))->execute($node);

    $return = rules_condition('node_is_of_type', array('type' => array('article')))->execute($node);

    $this->assertFalse($return, 'Condition determines node is not of type article.');

    // Test auto saving of a new node after it has been inserted into the DB.

    $rule = rules_reaction_rule();

    $rand = $this->randomName();

  }

  /**

   */

    $rid = $this->drupalCreateRole(array('administer nodes'), 'foo');

    $user = $this->drupalCreateUser();

  }

  /**

   */

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

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

    $rule->condition('php_eval', array('code' => 'return TRUE;'))

    $this->assertEqual(array_pop($msg['status']), "Title: foo Token: foo", 'PHP input evaluation has been applied.');

    $this->assertEqual(array_pop($msg['status']), "Executed-foo", 'PHP code condition and action have been evaluated.');

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

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

      'message:select' => 'var_name:title',

      'message:process' => array(

      ),

    ));

    $rule->execute($node);

  }

  /**

   */

    // Make sure the date input evaluator evaluates properly using strtotime().

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

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

  }

  /**

   */

    // Test using the 'site' variable.

    $condition = rules_condition('data_is', array('data:select' => 'site:current-user:name', 'value' => $GLOBALS['user']->name));

    $this->assertTrue($condition->execute(), 'Retrieved the current user\'s name.');

    $this->drupalGet('node/' . $node->nid);

    $this->assertEqual($this->getUrl(), url('user', array('absolute' => TRUE, 'fragment' => 'fragment')), 'Redirect has been issued.');

    // Test sending mail.

    $settings = array('to' => 'mail@example.com', 'subject' => 'subject', 'message' => 'hello.');

    rules_action('mail', $settings)->execute();

    rules_action('mail', $settings + array('from' => 'sender@example.com'))->execute();

    $this->assertMail('from', 'sender@example.com', 'Specified from address has been used');

    // drupalCreateUser().

    unset($roles[DRUPAL_AUTHENTICATED_RID]);

    rules_action('mail_to_users_of_role', $settings + array('roles' => array_keys($roles)))->execute();

    // Test reacting on new log entries and make sure the log entry is usable.

    $rule = rules_reaction_rule();

  /**

   * Tests the path module integration.

   */

    rules_action('path_alias')->execute('foo', 'bar');

    $path = path_load('foo');

    $this->assertTrue($path['alias'] == 'bar', 'URL alias has been created.');

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

  }

}

/**

 */

class RulesEventDispatcherTestCase extends DrupalWebTestCase {

    return array(

      'name' => 'Rules event dispatchers',

      'description' => 'Tests event dispatcher functionality.',

    );

  }

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

  }

      $this->assertEqual($key !== 5, $handler->isWatching());

    }

  }

}

/**

class RulesInvocationEnabledTestCase extends DrupalWebTestCase {

  /**

   */

  public static function getInfo() {

    return array(

  }

  /**

   */

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

  }