behat_form_select.php 13.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Single select form field class.
 *
 * @package    core_form
 * @category   test
 * @copyright  2012 David Monllaó
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

// NOTE: no MOODLE_INTERNAL test here, this file may be required by behat before including /config.php.

require_once(__DIR__  . '/behat_form_field.php');

/**
 * Single select form field.
 *
 * @package    core_form
 * @category   test
 * @copyright  2012 David Monllaó
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class behat_form_select extends behat_form_field {

    /**
41
     * Sets the value(s) of a select element.
42
     *
43
44
     * Seems an easy select, but there are lots of combinations
     * of browsers and operative systems and each one manages the
45
     * autosubmits and the multiple option selects in a different way.
46
     *
47
     * @param string $value plain value or comma separated values if multiple. Commas in values escaped with backslash.
48
49
50
     * @return void
     */
    public function set_value($value) {
51

52
53
54
55
56
57
58
59
        // In some browsers we select an option and it triggers all the
        // autosubmits and works as expected but not in all of them, so we
        // try to catch all the possibilities to make this function work as
        // expected.

        // Get the internal id of the element we are going to click.
        // This kind of internal IDs are only available in the selenium wire
        // protocol, so only available using selenium drivers, phantomjs and family.
60
        if ($this->running_javascript()) {
61
62
            $currentelementid = $this->get_internal_field_id();
        }
63

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
        // Is the select multiple?
        $multiple = $this->field->hasAttribute('multiple');

        // By default, assume the passed value is a non-multiple option.
        $options = array(trim($value));

        // Here we select the option(s).
        if ($multiple) {
            // Split and decode values. Comma separated list of values allowed. With valuable commas escaped with backslash.
            $options = preg_replace('/\\\,/', ',',  preg_split('/(?<!\\\),/', $value));
            // This is a multiple select, let's pass the multiple flag after first option.
            $afterfirstoption = false;
            foreach ($options as $option) {
                $this->field->selectOption(trim($option), $afterfirstoption);
                $afterfirstoption = true;
            }
        } else {
            // This is a single select, let's pass the last one specified.
            $this->field->selectOption(end($options));
        }
84

85
86
87
88
        // With JS disabled this is enough and we finish here.
        if (!$this->running_javascript()) {
            return;
        }
89

90
91
        // With JS enabled we add more clicks as some selenium
        // drivers requires it to fire JS events.
92

93
94
95
        // In some browsers the selectOption actions can perform a form submit or reload page
        // so we need to ensure the element is still available to continue interacting
        // with it. We don't wait here.
96
        // getXpath() does not send a query to selenium, so we don't need to wrap it in a try & catch.
97
98
99
100
        $selectxpath = $this->field->getXpath();
        if (!$this->session->getDriver()->find($selectxpath)) {
            return;
        }
101

102
103
104
105
106
107
108
        // We also check the selenium internal element id, if it have changed
        // we are dealing with an autosubmit that was already executed, and we don't to
        // execute anything else as the action we wanted was already performed.
        if ($currentelementid != $this->get_internal_field_id()) {
            return;
        }

109
110
111
        // Wait for all the possible AJAX requests that have been
        // already triggered by selectOption() to be finished.
        $this->session->wait(behat_base::TIMEOUT * 1000, behat_base::PAGE_READY_JS);
112

113
114
115
116
117
118
119
120
121
122
123
        // Wrapped in try & catch as the element may disappear if an AJAX request was submitted.
        try {
            $multiple = $this->field->hasAttribute('multiple');
        } catch (Exception $e) {
            // We do not specify any specific Exception type as there are
            // different exceptions that can be thrown by the driver and
            // we can not control them all, also depending on the selenium
            // version the exception type can change.
            return;
        }

124
        // Single select sometimes needs an extra click in the option.
125
        if (!$multiple) {
126

127
            // Var $options only contains 1 option.
128
129
            $optionxpath = $this->get_option_xpath(end($options), $selectxpath);

130
131
            // Using the driver direcly because Element methods are messy when dealing
            // with elements inside containers.
132
133
            if ($optionnodes = $this->session->getDriver()->find($optionxpath)) {

134
135
136
137
138
139
140
141
                // Wrapped in a try & catch as we can fall into race conditions
                // and the element may not be there.
                try {
                    current($optionnodes)->click();
                } catch (Exception $e) {
                    // We continue and return as this means that the element is not there or it is not the same.
                    return;
                }
142
            }
143
144

        } else {
145

146
147
148
149
150
151
152
153
154
            // Wrapped in a try & catch as we can fall into race conditions
            // and the element may not be there.
            try {
                // Multiple ones needs the click in the select.
                $this->field->click();
            } catch (Exception $e) {
                // We continue and return as this means that the element is not there or it is not the same.
                return;
            }
155

156
157
158
159
160
161
            // We also check that the option(s) are still there. We neither wait.
            foreach ($options as $option) {
                $optionxpath = $this->get_option_xpath($option, $selectxpath);
                if (!$this->session->getDriver()->find($optionxpath)) {
                    return;
                }
162
163
            }

164
            // Wait for all the possible AJAX requests that have been
165
            // already triggered by clicking on the field to be finished.
166
167
            $this->session->wait(behat_base::TIMEOUT * 1000, behat_base::PAGE_READY_JS);

168
169
170
            // Wrapped in a try & catch as we can fall into race conditions
            // and the element may not be there.
            try {
171

172
                // Repeating the select(s) as some drivers (chrome that I know) are moving
173
                // to another option after the general select field click above.
174
                $afterfirstoption = false;
175
                foreach ($options as $option) {
176
177
                    $this->field->selectOption(trim($option), $afterfirstoption);
                    $afterfirstoption = true;
178
                }
179
180
181
182
            } catch (Exception $e) {
                // We continue and return as this means that the element is not there or it is not the same.
                return;
            }
183
        }
184
185
186
    }

    /**
187
     * Returns the text of the currently selected options.
188
     *
189
     * @return string Comma separated if multiple options are selected. Commas in option texts escaped with backslash.
190
191
     */
    public function get_value() {
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
        return $this->get_selected_options();
    }

    /**
     * Returns whether the provided argument matches the current value.
     *
     * @param mixed $expectedvalue
     * @return bool
     */
    public function matches($expectedvalue) {

        $multiple = $this->field->hasAttribute('multiple');

        // Same implementation as the parent if it is a single select.
        if (!$multiple) {
            if (trim($expectedvalue) != trim($this->get_value())) {
                return false;
            }
            return true;
        }

        // We are dealing with a multi-select.

        // Can pass multiple comma separated, with valuable commas escaped with backslash.
        $expectedarr = array(); // Array of passed text options to test.

        // Unescape + trim all options and flip it to have the expected values as keys.
        $expectedoptions = $this->get_unescaped_options($expectedvalue);

        // Get currently selected option's texts.
        $texts = $this->get_selected_options(true);
        $selectedoptiontexts = $this->get_unescaped_options($texts);

        // Get currently selected option's values.
        $values = $this->get_selected_options(false);
        $selectedoptionvalues = $this->get_unescaped_options($values);

        // Precheck to speed things up.
        if (count($expectedoptions) !== count($selectedoptiontexts) ||
                count($expectedoptions) !== count($selectedoptionvalues)) {
            return false;
        }

        // We check against string-ordered lists of options.
        if ($expectedoptions != $selectedoptiontexts &&
                $expectedoptions != $selectedoptionvalues) {
            return false;
        }

        return true;
    }

    /**
     * Cleans the list of options and returns it as a string separating options with |||.
     *
     * @param string $value The string containing the escaped options.
     * @return string The options
     */
    protected function get_unescaped_options($value) {

        // Can be multiple comma separated, with valuable commas escaped with backslash.
        $optionsarray = array_map(
            'trim',
            preg_replace('/\\\,/', ',',
                preg_split('/(?<!\\\),/', $value)
           )
        );

        // Sort by value (keeping the keys is irrelevant).
        core_collator::asort($optionsarray, SORT_STRING);

        // Returning it as a string which is easier to match against other values.
        return implode('|||', $optionsarray);
    }

    /**
     * Returns the field selected values.
     *
     * Externalized from the common behat_form_field API method get_value() as
     * matches() needs to check against both values and texts.
     *
     * @param bool $returntexts Returns the options texts or the options values.
     * @return string
     */
    protected function get_selected_options($returntexts = true) {

        $method = 'getText';
        if ($returntexts === false) {
            $method = 'getValue';
        }
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297

        // Is the select multiple?
        $multiple = $this->field->hasAttribute('multiple');

        $selectedoptions = array(); // To accumulate found selected options.

        // Selenium getValue() implementation breaks - separates - values having
        // commas within them, so we'll be looking for options with the 'selected' attribute instead.
        if ($this->running_javascript()) {
            // Get all the options in the select and extract their value/text pairs.
            $alloptions = $this->field->findAll('xpath', '//option');
            foreach ($alloptions as $option) {
                // Is it selected?
                if ($option->hasAttribute('selected')) {
                    if ($multiple) {
                        // If the select is multiple, text commas must be encoded.
298
                        $selectedoptions[] = trim(str_replace(',', '\,', $option->{$method}()));
299
                    } else {
300
                        $selectedoptions[] = trim($option->{$method}());
301
302
303
304
305
                    }
                }
            }

        } else {
306
307
            // Goutte does not keep the 'selected' attribute updated, but its getValue() returns
            // the selected elements correctly, also those having commas within them.
308
309
310

            // Goutte returns the values as an array or as a string depending
            // on whether multiple options are selected or not.
311
            $values = $this->field->getValue();
312
313
314
315
            if (!is_array($values)) {
                $values = array($values);
            }

316
317
318
319
320
321
322
            // Get all the options in the select and extract their value/text pairs.
            $alloptions = $this->field->findAll('xpath', '//option');
            foreach ($alloptions as $option) {
                // Is it selected?
                if (in_array($option->getValue(), $values)) {
                    if ($multiple) {
                        // If the select is multiple, text commas must be encoded.
323
                        $selectedoptions[] = trim(str_replace(',', '\,', $option->{$method}()));
324
                    } else {
325
                        $selectedoptions[] = trim($option->{$method}());
326
327
328
329
330
331
                    }
                }
            }
        }

        return implode(', ', $selectedoptions);
332
    }
333
334
335
336
337
338
339
340
341
342
343
344

    /**
     * Returns the opton XPath based on it's select xpath.
     *
     * @param string $option
     * @param string $selectxpath
     * @return string xpath
     */
    protected function get_option_xpath($option, $selectxpath) {
        $valueliteral = $this->session->getSelectorsHandler()->xpathLiteral(trim($option));
        return $selectxpath . "/descendant::option[(./@value=$valueliteral or normalize-space(.)=$valueliteral)]";
    }
345
}