749770bb287bc1c42e4e7457caea3e5b7fdbcf33
[moodle.git] / lib / tests / behat / behat_data_generators.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Data generators for acceptance testing.
19  *
20  * @package   core
21  * @category  test
22  * @copyright 2012 David MonllaĆ³
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 // NOTE: no MOODLE_INTERNAL test here, this file may be required by behat before including /config.php.
28 require_once(__DIR__ . '/../../behat/behat_base.php');
30 use Behat\Gherkin\Node\TableNode as TableNode;
31 use Behat\Behat\Exception\PendingException as PendingException;
33 /**
34  * Class to set up quickly a Given environment.
35  *
36  * Acceptance tests are block-boxed, so this steps definitions should only
37  * be used to set up the test environment as we are not replicating user steps.
38  *
39  * All data generators should be in lib/testing/generator/*, shared between phpunit
40  * and behat and they should be called from here, if possible using the standard
41  * 'create_$elementname($options)' and if it's not possible (data generators arguments will not be
42  * always the same) or the element is not suitable to be a data generator, create a
43  * 'process_$elementname($options)' method and use the data generator from there if possible.
44  *
45  * @todo      If the available elements list grows too much this class must be split into smaller pieces
46  * @package   core
47  * @category  test
48  * @copyright 2012 David MonllaĆ³
49  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
50  */
51 class behat_data_generators extends behat_base {
53     const cap_allow = 'Allow';
54     const cap_prevent = 'Prevent';
55     const cap_prohibit = 'Prohibit';
57     /**
58      * @var testing_data_generator
59      */
60     protected $datagenerator;
62     /**
63      * Each element specifies:
64      * - The data generator sufix used.
65      * - The required fields.
66      * - The mapping between other elements references and database field names.
67      * @var array
68      */
69     protected static $elements = array(
70         'users' => array(
71             'datagenerator' => 'user',
72             'required' => array('username')
73         ),
74         'categories' => array(
75             'datagenerator' => 'category',
76             'required' => array('idnumber'),
77             'switchids' => array('category' => 'parent')
78         ),
79         'courses' => array(
80             'datagenerator' => 'course',
81             'required' => array('shortname'),
82             'switchids' => array('category' => 'category')
83         ),
84         'groups' => array(
85             'datagenerator' => 'group',
86             'required' => array('idnumber', 'course'),
87             'switchids' => array('course' => 'courseid')
88         ),
89         'groupings' => array(
90             'datagenerator' => 'grouping',
91             'required' => array('idnumber', 'course'),
92             'switchids' => array('course' => 'courseid')
93         ),
94         'course enrolments' => array(
95             'datagenerator' => 'enrol_user',
96             'required' => array('user', 'course', 'role'),
97             'switchids' => array('user' => 'userid', 'course' => 'courseid', 'role' => 'roleid')
99         ),
100         'permission overrides' => array(
101             'datagenerator' => 'permission_override',
102             'required' => array('capability', 'permission', 'role', 'contextlevel', 'reference'),
103             'switchids' => array('role' => 'roleid')
104         ),
105         'system role assigns' => array(
106             'datagenerator' => 'system_role_assign',
107             'required' => array('user', 'role'),
108             'switchids' => array('user' => 'userid', 'role' => 'roleid')
109         ),
110         'role assigns' => array(
111             'datagenerator' => 'role_assign',
112             'required' => array('user', 'role', 'contextlevel', 'reference'),
113             'switchids' => array('user' => 'userid', 'role' => 'roleid')
114         ),
115         'activities' => array(
116             'datagenerator' => 'activity',
117             'required' => array('activity', 'idnumber', 'course'),
118             'switchids' => array('course' => 'course')
119         ),
120         'group members' => array(
121             'datagenerator' => 'group_member',
122             'required' => array('user', 'group'),
123             'switchids' => array('user' => 'userid', 'group' => 'groupid')
124         ),
125         'grouping groups' => array(
126             'datagenerator' => 'grouping_group',
127             'required' => array('grouping', 'group'),
128             'switchids' => array('grouping' => 'groupingid', 'group' => 'groupid')
129         ),
130         'cohorts' => array(
131             'datagenerator' => 'cohort',
132             'required' => array('idnumber')
133         ),
134         'roles' => array(
135             'datagenerator' => 'role',
136             'required' => array('shortname')
137         )
138     );
140     /**
141      * Creates the specified element. More info about available elements in http://docs.moodle.org/dev/Acceptance_testing#Fixtures.
142      *
143      * @Given /^the following "(?P<element_string>(?:[^"]|\\")*)" exists:$/
144      *
145      * @throws Exception
146      * @throws PendingException
147      * @param string    $elementname The name of the entity to add
148      * @param TableNode $data
149      */
150     public function the_following_exists($elementname, TableNode $data) {
152         // Now that we need them require the data generators.
153         require_once(__DIR__ . '/../../testing/generator/lib.php');
155         if (empty(self::$elements[$elementname])) {
156             throw new PendingException($elementname . ' data generator is not implemented');
157         }
159         $this->datagenerator = testing_util::get_data_generator();
161         $elementdatagenerator = self::$elements[$elementname]['datagenerator'];
162         $requiredfields = self::$elements[$elementname]['required'];
163         if (!empty(self::$elements[$elementname]['switchids'])) {
164             $switchids = self::$elements[$elementname]['switchids'];
165         }
167         foreach ($data->getHash() as $elementdata) {
169             // Check if all the required fields are there.
170             foreach ($requiredfields as $requiredfield) {
171                 if (!isset($elementdata[$requiredfield])) {
172                     throw new Exception($elementname . ' requires the field ' . $requiredfield . ' to be specified');
173                 }
174             }
176             // Switch from human-friendly references to ids.
177             if (isset($switchids)) {
178                 foreach ($switchids as $element => $field) {
179                     $methodname = 'get_' . $element . '_id';
181                     // Not all the switch fields are required, default vars will be assigned by data generators.
182                     if (isset($elementdata[$element])) {
183                         // Temp $id var to avoid problems when $element == $field.
184                         $id = $this->{$methodname}($elementdata[$element]);
185                         unset($elementdata[$element]);
186                         $elementdata[$field] = $id;
187                     }
188                 }
189             }
191             // Preprocess the entities that requires a special treatment.
192             if (method_exists($this, 'preprocess_' . $elementdatagenerator)) {
193                 $elementdata = $this->{'preprocess_' . $elementdatagenerator}($elementdata);
194             }
196             // Creates element.
197             $methodname = 'create_' . $elementdatagenerator;
198             if (method_exists($this->datagenerator, $methodname)) {
199                 // Using data generators directly.
200                 $this->datagenerator->{$methodname}($elementdata);
202             } else if (method_exists($this, 'process_' . $elementdatagenerator)) {
203                 // Using an alternative to the direct data generator call.
204                 $this->{'process_' . $elementdatagenerator}($elementdata);
205             } else {
206                 throw new PendingException($elementname . ' data generator is not implemented');
207             }
208         }
210     }
212     /**
213      * If password is not set it uses the username.
214      * @param array $data
215      * @return array
216      */
217     protected function preprocess_user($data) {
218         if (!isset($data['password'])) {
219             $data['password'] = $data['username'];
220         }
221         return $data;
222     }
224     /**
225      * Adapter to modules generator
226      * @throws Exception Custom exception for test writers
227      * @param array $data
228      * @return void
229      */
230     protected function process_activity($data) {
231         global $DB;
233         // The the_following_exists() method checks that the field exists.
234         $activityname = $data['activity'];
235         unset($data['activity']);
237         // We split $data in the activity $record and the course module $options.
238         $cmoptions = array();
239         $cmcolumns = $DB->get_columns('course_modules');
240         foreach ($cmcolumns as $key => $value) {
241             if (isset($data[$key])) {
242                 $cmoptions[$key] = $data[$key];
243             }
244         }
246         // Custom exception.
247         try {
248             $this->datagenerator->create_module($activityname, $data, $cmoptions);
249         } catch (coding_exception $e) {
250             throw new Exception('\'' . $activityname . '\' activity can not be added using this step,' .
251                 ' use the step \'I add a "ACTIVITY_OR_RESOURCE_NAME_STRING" to section "SECTION_NUMBER"\' instead');
252         }
253     }
255     /**
256      * Adapter to enrol_user() data generator.
257      * @throws Exception
258      * @param array $data
259      * @return void
260      */
261     protected function process_enrol_user($data) {
262         global $SITE;
264         if (empty($data['roleid'])) {
265             throw new Exception('\'course enrolments\' requires the field \'role\' to be specified');
266         }
268         if (!isset($data['userid'])) {
269             throw new Exception('\'course enrolments\' requires the field \'user\' to be specified');
270         }
272         if (!isset($data['courseid'])) {
273             throw new Exception('\'course enrolments\' requires the field \'course\' to be specified');
274         }
276         if (!isset($data['enrol'])) {
277             $data['enrol'] = 'manual';
278         }
280         // If the provided course shortname is the site shortname we consider it a system role assign.
281         if ($data['courseid'] == $SITE->id) {
282             // Frontpage course assign.
283             $context = context_course::instance($data['courseid']);
284             role_assign($data['roleid'], $data['userid'], $context->id);
286         } else {
287             // Course assign.
288             $this->datagenerator->enrol_user($data['userid'], $data['courseid'], $data['roleid'], $data['enrol']);
289         }
291     }
293     /**
294      * Allows/denies a capability at the specified context
295      *
296      * @throws Exception
297      * @param array $data
298      * @return void
299      */
300     protected function process_permission_override($data) {
302         // Will throw an exception if it does not exist.
303         $context = $this->get_context($data['contextlevel'], $data['reference']);
305         switch ($data['permission']) {
306             case self::cap_allow:
307                 $permission = CAP_ALLOW;
308                 break;
309             case self::cap_prevent:
310                 $permission = CAP_PREVENT;
311                 break;
312             case self::cap_prohibit:
313                 $permission = CAP_PROHIBIT;
314                 break;
315             default:
316                 throw new Exception('The \'' . $data['permission'] . '\' permission does not exist');
317                 break;
318         }
320         if (is_null(get_capability_info($data['capability']))) {
321             throw new Exception('The \'' . $data['capability'] . '\' capability does not exist');
322         }
324         role_change_permission($data['roleid'], $context, $data['capability'], $permission);
325     }
327     /**
328      * Assigns a role to a user at system context
329      *
330      * Used by "system role assigns" can be deleted when
331      * system role assign will be deprecated in favour of
332      * "role assigns"
333      *
334      * @throws Exception
335      * @param array $data
336      * @return void
337      */
338     protected function process_system_role_assign($data) {
340         if (empty($data['roleid'])) {
341             throw new Exception('\'system role assigns\' requires the field \'role\' to be specified');
342         }
344         if (!isset($data['userid'])) {
345             throw new Exception('\'system role assigns\' requires the field \'user\' to be specified');
346         }
348         $context = context_system::instance();
350         $this->datagenerator->role_assign($data['roleid'], $data['userid'], $context->id);
351     }
353     /**
354      * Assigns a role to a user at the specified context
355      *
356      * @throws Exception
357      * @param array $data
358      * @return void
359      */
360     protected function process_role_assign($data) {
362         if (empty($data['roleid'])) {
363             throw new Exception('\'role assigns\' requires the field \'role\' to be specified');
364         }
366         if (!isset($data['userid'])) {
367             throw new Exception('\'role assigns\' requires the field \'user\' to be specified');
368         }
370         if (empty($data['contextlevel'])) {
371             throw new Exception('\'role assigns\' requires the field \'contextlevel\' to be specified');
372         }
374         if (!isset($data['reference'])) {
375             throw new Exception('\'role assigns\' requires the field \'reference\' to be specified');
376         }
378         // Getting the context id.
379         $context = $this->get_context($data['contextlevel'], $data['reference']);
381         $this->datagenerator->role_assign($data['roleid'], $data['userid'], $context->id);
382     }
384     /**
385      * Creates a role.
386      *
387      * @param array $data
388      * @return void
389      */
390     protected function process_role($data) {
392         // We require the user to fill the role shortname.
393         if (empty($data['shortname'])) {
394             throw new Exception('\'role\' requires the field \'shortname\' to be specified');
395         }
397         $this->datagenerator->create_role($data);
398     }
400     /**
401      * Gets the user id from it's username.
402      * @throws Exception
403      * @param string $username
404      * @return int
405      */
406     protected function get_user_id($username) {
407         global $DB;
409         if (!$id = $DB->get_field('user', 'id', array('username' => $username))) {
410             throw new Exception('The specified user with username "' . $username . '" does not exist');
411         }
412         return $id;
413     }
415     /**
416      * Gets the role id from it's shortname.
417      * @throws Exception
418      * @param string $roleshortname
419      * @return int
420      */
421     protected function get_role_id($roleshortname) {
422         global $DB;
424         if (!$id = $DB->get_field('role', 'id', array('shortname' => $roleshortname))) {
425             throw new Exception('The specified role with shortname "' . $roleshortname . '" does not exist');
426         }
428         return $id;
429     }
431     /**
432      * Gets the category id from it's idnumber.
433      * @throws Exception
434      * @param string $idnumber
435      * @return int
436      */
437     protected function get_category_id($idnumber) {
438         global $DB;
440         // If no category was specified use the data generator one.
441         if ($idnumber == false) {
442             return null;
443         }
445         if (!$id = $DB->get_field('course_categories', 'id', array('idnumber' => $idnumber))) {
446             throw new Exception('The specified category with idnumber "' . $idnumber . '" does not exist');
447         }
449         return $id;
450     }
452     /**
453      * Gets the course id from it's shortname.
454      * @throws Exception
455      * @param string $shortname
456      * @return int
457      */
458     protected function get_course_id($shortname) {
459         global $DB;
461         if (!$id = $DB->get_field('course', 'id', array('shortname' => $shortname))) {
462             throw new Exception('The specified course with shortname "' . $shortname . '" does not exist');
463         }
464         return $id;
465     }
467     /**
468      * Gets the group id from it's idnumber.
469      * @throws Exception
470      * @param string $idnumber
471      * @return int
472      */
473     protected function get_group_id($idnumber) {
474         global $DB;
476         if (!$id = $DB->get_field('groups', 'id', array('idnumber' => $idnumber))) {
477             throw new Exception('The specified group with idnumber "' . $idnumber . '" does not exist');
478         }
479         return $id;
480     }
482     /**
483      * Gets the grouping id from it's idnumber.
484      * @throws Exception
485      * @param string $idnumber
486      * @return int
487      */
488     protected function get_grouping_id($idnumber) {
489         global $DB;
491         if (!$id = $DB->get_field('groupings', 'id', array('idnumber' => $idnumber))) {
492             throw new Exception('The specified grouping with idnumber "' . $idnumber . '" does not exist');
493         }
494         return $id;
495     }
497     /**
498      * Gets the internal context id from the context reference.
499      *
500      * The context reference changes depending on the context
501      * level, it can be the system, a user, a category, a course or
502      * a module.
503      *
504      * @throws Exception
505      * @param string $levelname The context level string introduced by the test writer
506      * @param string $contextref The context reference introduced by the test writer
507      * @return context
508      */
509     protected function get_context($levelname, $contextref) {
510         global $DB;
512         // Getting context levels and names (we will be using the English ones as it is the test site language).
513         $contextlevels = context_helper::get_all_levels();
514         $contextnames = array();
515         foreach ($contextlevels as $level => $classname) {
516             $contextnames[context_helper::get_level_name($level)] = $level;
517         }
519         if (empty($contextnames[$levelname])) {
520             throw new Exception('The specified "' . $levelname . '" context level does not exist');
521         }
522         $contextlevel = $contextnames[$levelname];
524         // Return it, we don't need to look for other internal ids.
525         if ($contextlevel == CONTEXT_SYSTEM) {
526             return context_system::instance();
527         }
529         switch ($contextlevel) {
531             case CONTEXT_USER:
532                 $instanceid = $DB->get_field('user', 'id', array('username' => $contextref));
533                 break;
535             case CONTEXT_COURSECAT:
536                 $instanceid = $DB->get_field('course_categories', 'id', array('idnumber' => $contextref));
537                 break;
539             case CONTEXT_COURSE:
540                 $instanceid = $DB->get_field('course', 'id', array('shortname' => $contextref));
541                 break;
543             case CONTEXT_MODULE:
544                 $instanceid = $DB->get_field('course_modules', 'id', array('idnumber' => $contextref));
545                 break;
547             default:
548                 break;
549         }
551         $contextclass = $contextlevels[$contextlevel];
552         if (!$context = $contextclass::instance($instanceid, IGNORE_MISSING)) {
553             throw new Exception('The specified "' . $contextref . '" context reference does not exist');
554         }
556         return $context;
557     }