rules_test_case.test

<?php


/**
 * @file
 * Rules 7.x tests.
 *
 * This files is here for keeping track which tests have been ported to Drupal
 * 8 and which not. Any tests covered can be removed, so everything that's
 * left in this file still needs to be ported.
 */
// @codingStandardsIgnoreStart
class RulesTestCase extends DrupalWebTestCase {
    static function getInfo() {
        return array(
            'name' => 'Rules Engine tests',
            'description' => 'Test using the rules API to create and evaluate rules.',
            'group' => 'Rules',
        );
    }
    function setUp() {
        parent::setUp('rules', 'rules_test');
        RulesLog::logger()->clear();
        variable_set('rules_debug_log', 1);
    }
    
    /**
     * Calculates the output of t() given an array of placeholders to replace.
     */
    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);
    }
    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;
    }
    
    /**
     * Test handling dependencies.
     */
    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.');
    }
    
    /**
     * Test setting up an action with some action_info and serializing and
     * executing it.
     */
    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();
    }
    
    /**
     * Test executing with wrong arguments.
     */
    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);
        }
    }
    
    /**
     * Test setting up a rule and mapping variables.
     */
    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.
     */
    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.
     */
    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.');
    }
    
    /**
     * Test automatic saving of variables.
     */
    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();
    }
    
    /**
     * Test adding a variable and optional parameters.
     */
    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();
    }
    
    /**
     * Test custom access for using component actions/conditions.
     */
    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 anonyous.
        $user = user_load(0);
        $this->assertFalse(rules_action('component_rules_test_roles')->access(), 'Anonymous user can\'t use the rule component.');
    }
    
    /**
     * Test passing arguments by reference to an action.
     */
    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');
    }
    
    /**
     * Test sorting rule elements.
     */
    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.
     */
    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',
        ))
            ->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.
     */
    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.
     */
    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.');
    }
    
    /**
     * Test asserting metadata, customizing action info and make sure integrity
     * is checked.
     */
    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',
        ))
            ->condition(rules_condition('data_is', array(
            'data:select' => 'node:body:value',
            'value' => 'foo',
        ))->negate())
            ->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.');
        }
    }
    
    /**
     * Test using loops.
     */
    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();
    }
    
    /**
     * Test access checks.
     */
    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.');
    }
    
    /**
     * Test returning provided variables.
     */
    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.
     */
    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.');
    }
    
    /**
     * Test importing and exporting a rule.
     */
    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.');
    }
    
    /**
     * Test the named parameter mode.
     */
    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();
    }
    
    /**
     * Make sure Rules aborts when NULL values are used.
     */
    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.');
    }

}