ConditionsFormTest.php

<?php

namespace Drupal\Tests\rules\Functional;


/**
 * Tests that each Rules Condition can be edited.
 *
 * @group RulesUi
 */
class ConditionsFormTest extends RulesBrowserTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'node',
        'ban',
        'path_alias',
        'rules',
        'typed_data',
    ];
    
    /**
     * We use the minimal profile because we want to test local action links.
     *
     * @var string
     */
    protected $profile = 'minimal';
    
    /**
     * A user account with administration permissions.
     *
     * @var \Drupal\Core\Session\AccountInterface
     */
    protected $account;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        // Create an article content type that we will use for testing.
        $type = $this->container
            ->get('entity_type.manager')
            ->getStorage('node_type')
            ->create([
            'type' => 'article',
            'name' => 'Article',
        ]);
        $type->save();
        $this->account = $this->drupalCreateUser([
            'administer rules',
            'administer site configuration',
        ]);
        $this->drupalLogin($this->account);
        // Create a named role for use in conditions and actions.
        $this->createRole([
            'administer nodes',
        ], 'test-editor', 'Test Editor');
    }
    
    /**
     * Test each condition provided by Rules.
     *
     * Check that every condition can be added to a rule and that the edit page
     * can be accessed. This ensures that the datatypes used in the definitions
     * do exist. This test does not execute the conditions or actions.
     *
     * @dataProvider dataConditionsFormWidgets
     */
    public function testConditionsFormWidgets($id, $required = [], $defaulted = [], $widgets = [], $selectors = []) {
        $expressionManager = $this->container
            ->get('plugin.manager.rules_expression');
        $storage = $this->container
            ->get('entity_type.manager')
            ->getStorage('rules_reaction_rule');
        
        /** @var \Drupal\Tests\WebAssert $assert */
        $assert = $this->assertSession();
        // Create a rule.
        $rule = $expressionManager->createRule();
        // Add the condition to the rule.
        $condition = $expressionManager->createCondition($id);
        $rule->addExpressionObject($condition);
        // Save the configuration.
        $expr_id = 'condition_' . str_replace(':', '_', $id);
        $config_entity = $storage->create([
            'id' => $expr_id,
            'expression' => $rule->getConfiguration(),
            // Specify a node event so that the node... selector values are available.
'events' => [
                [
                    'event_name' => 'rules_entity_update:node',
                ],
            ],
        ]);
        $config_entity->save();
        // Edit the condition and check that the page is generated without error.
        $this->drupalGet('admin/config/workflow/rules/reactions/edit/' . $expr_id . '/edit/' . $condition->getUuid());
        $assert->statusCodeEquals(200);
        $assert->pageTextContains('Edit ' . $condition->getLabel());
        // If any field values have been specified then fill in the form and save.
        if (!empty($required) || !empty($defaulted)) {
            // Switch to data selector where required.
            if (!empty($selectors)) {
                foreach ($selectors as $name) {
                    $this->pressButton('edit-context-definitions-' . $name . '-switch-button');
                    // Check that the switch worked.
                    $assert->elementExists('xpath', '//input[@id="edit-context-definitions-' . $name . '-switch-button" and contains(@value, "Switch to the direct input mode")]');
                }
            }
            // Try to save the form before entering the required values.
            if (!empty($required)) {
                $this->pressButton('Save');
                // Check that the form has not been saved.
                $assert->pageTextContains('Error message');
                $assert->pageTextContains('field is required');
                // Fill each required field with the value provided.
                foreach ($required as $name => $value) {
                    $this->fillField('edit-context-definitions-' . $name . '-setting', $value);
                }
            }
            // Check that the condition can be saved.
            $this->pressButton('Save');
            $assert->pageTextNotContains('InvalidArgumentException: Cannot set a list with a non-array value');
            $assert->pageTextNotContains('Error message');
            $assert->pageTextContains('You have unsaved changes.');
            // Allow for the ?uuid query string being present or absent in the assert
            // method by using addressMatches() with regex instead of addressEquals().
            $assert->addressMatches('#admin/config/workflow/rules/reactions/edit/' . $expr_id . '(\\?uuid=' . $condition->getUuid() . '|)$#');
            // Check that re-edit and re-save works OK.
            $this->clickLink('Edit');
            if (!empty($defaulted)) {
                // Fill each previously defaulted field with the value provided.
                foreach ($defaulted as $name => $value) {
                    $this->fillField('edit-context-definitions-' . $name . '-setting', $value);
                }
            }
            $this->pressButton('Save');
            $assert->pageTextNotContains('Error message');
            $assert->addressMatches('#admin/config/workflow/rules/reactions/edit/' . $expr_id . '(\\?uuid=' . $condition->getUuid() . '|)$#');
            // Save the rule.
            $this->pressButton('Save');
            $assert->pageTextContains("Reaction rule {$expr_id} has been updated");
        }
    }
    
    /**
     * Provides data for testConditionsFormWidgets().
     *
     * @return array
     *   The test data array. The top level keys are free text but should be short
     *   and relate to the test case. The values are ordered arrays of test case
     *   data with elements that must appear in the following order:
     *   - Machine name of the condition being tested.
     *   - (optional) Required values to enter on the Context form. This is an
     *     associative array with keys equal to the field names and values equal
     *     to the required field values.
     *   - (optional) Values for fields that have defaults. This is an associative
     *     array with keys equal to the field names and values equal to the field
     *     values. These are used on the second edit, to alter the fields that
     *     have been saved with their default value.
     *   - (optional) Widget types we expect to see on the Context form. This is
     *     an associative array with keys equal to the field names as above, and
     *     values equal to expected widget type.
     *   - (optional) Names of fields for which the selector/direct input button
     *     needs pressing to 'data selection' before the field value is entered.
     */
    public function dataConditionsFormWidgets() {
        // Instead of directly returning the full set of test data, create variable
        // $data to hold it. This allows for manipulation before the final return.
        $data = [
            // Data.
'1. Data comparison' => [
                // Machine name.
'rules_data_comparison',
                // Required values.
[
                    'data' => 'node.title.value',
                    'value' => 'node_unchanged.title.value',
                ],
                // Defaulted values.
[
                    'operation' => 'contains',
                ],
                // Widgets.
[
                    'data' => 'text-input',
                    'operation' => 'text-input',
                    'value' => 'text-input',
                ],
                // Selectors.
[
                    'value',
                ],
            ],
            '2. Data is empty' => [
                'rules_data_is_empty',
                [
                    'data' => 'node.title.value',
                ],
            ],
            '3. List contains' => [
                'rules_list_contains',
                [
                    'list' => 'node.uid.entity.roles',
                    'item' => 'abc',
                ],
                [],
                [
                    'list' => 'textarea',
                ],
            ],
            '4. List count is' => [
                'rules_list_count_is',
                [
                    'list' => 'node.uid.entity.roles',
                    'value' => 2,
                ],
                [
                    'operator' => '<=',
                ],
            ],
            '5. Text comparison - direct' => [
                'rules_text_comparison',
                [
                    'text' => 'node.title.value',
                    'match' => 'abc',
                ],
            ],
            '6. Text comparison - selector' => [
                'rules_text_comparison',
                [
                    'text' => 'node.title.value',
                    'match' => 'node.uid.entity.name.value',
                ],
                [
                    'operator' => 'ends',
                ],
                [],
                [
                    'match',
                ],
            ],
            // Entity.
'7. Entity has field' => [
                'rules_entity_has_field',
                [
                    'entity' => 'node',
                    'field' => 'login',
                ],
            ],
            '8. Entity is new' => [
                'rules_entity_is_new',
                [
                    'entity' => 'node',
                ],
            ],
            '9. Entity is of bundle' => [
                'rules_entity_is_of_bundle',
                [
                    'entity' => 'node',
                    'type' => 'node',
                    'bundle' => 'article',
                ],
            ],
            '10. Entity is of type' => [
                'rules_entity_is_of_type',
                [
                    'entity' => 'node',
                    'type' => 'path_alias',
                ],
            ],
            // Content.
'11. Node is of type' => [
                'rules_node_is_of_type',
                [
                    'node' => 'node',
                    'types' => 'article',
                ],
            ],
            '12. Node is promoted' => [
                'rules_node_is_promoted',
                [
                    'node' => 'node',
                ],
            ],
            '13. Node is published' => [
                'rules_node_is_published',
                [
                    'node' => 'node',
                ],
            ],
            '14. Node is sticky' => [
                'rules_node_is_sticky',
                [
                    'node' => 'node',
                ],
            ],
            // Path.
'15. Path alias exists' => [
                'rules_path_alias_exists',
                [
                    'alias' => '/abc',
                ],
                [
                    'language' => 'und',
                ],
            ],
            '16. Path has alias' => [
                'rules_path_has_alias',
                [
                    'path' => '/node/1',
                ],
                [
                    'language' => 'en',
                ],
            ],
            // User.
'17. Entity field access' => [
                'rules_entity_field_access',
                [
                    'entity' => 'node',
                    'field' => 'timezone',
                    'user' => '@user.current_user_context:current_user',
                ],
                [
                    'operation' => 'edit',
                ],
            ],
            '18. User has role' => [
                'rules_user_has_role',
                [
                    'user' => '@user.current_user_context:current_user',
                    'roles' => 'test-editor',
                ],
                [
                    'operation' => 'OR',
                ],
                [],
                [
                    'user',
                ],
            ],
            '19. User is blocked' => [
                'rules_user_is_blocked',
                [
                    'user' => '@user.current_user_context:current_user',
                ],
                [],
                [],
                [
                    'user',
                ],
            ],
            // Ban.
'20. Ip is banned' => [
                'rules_ip_is_banned',
                [],
                [
                    'ip' => '192.0.2.1',
                ],
            ],
        ];
        // Use unset $data['The key to remove']; to remove a temporarily unwanted
        // item, use return [$data['The key to test']]; to selectively test just one
        // item, or use return $data; to test everything.
        return $data;
    }

}