MDL-48024 behat: allow plugins to have data generators
[moodle.git] / lib / behat / classes / behat_generator_base.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  * Base class for data generators component support 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 defined('MOODLE_INTERNAL') || die();
28 use Behat\Gherkin\Node\TableNode as TableNode;
29 use Behat\Behat\Tester\Exception\PendingException as PendingException;
32 /**
33  * Class to quickly create Behat test data using component data generators.
34  *
35  * There is a subclass of class for each component that wants to be able to
36  * generate entities using the Behat step
37  *     Given the following "entity types" exist:
38  *       | test | data |
39  *
40  * For core entities, the entity type is like "courses" or "users" and
41  * generating those is handled by behat_core_generator. For other components
42  * the entity type is like "mod_quiz > User override" and that is handled by
43  * behat_mod_quiz_generator defined in mod/quiz/tests/generator/behat_mod_quiz_generator.php.
44  *
45  * The types of entities that can be generated are described by the array returned
46  * by the {@link get_generateable_entities()} method. The list in
47  * {@link behat_core_generator} is a good (if complex) example.
48  *
49  * How things work is best explained with a few examples. All this is implemented
50  * in the {@link generate_items()} method below, if you want to see every detail of
51  * how it works.
52  *
53  * Simple example from behat_core_generator:
54  * 'users' => [
55  *     'datagenerator' => 'user',
56  *     'required' => ['username'],
57  * ],
58  * The steps performed are:
59  *
60  * 1. 'datagenerator' => 'user' means that the word used in the method names below is 'user'.
61  *
62  * 2. Because 'required' is present, check the supplied data exists 'username' column is present
63  *    in the supplied data table and if not display an error.
64  *
65  * 3. Then for each row in the table as an array $elementdata (array keys are column names)
66  *    and process it as follows
67  *
68  * 4. (Not used in this example.)
69  *
70  * 5. If the method 'preprocess_user' exists, then call it to update $elementdata.
71  *    (It does, in this case it sets the password to the username, if password was not given.)
72  *
73  * We then do one of 4 things:
74  *
75  * 6a. If there is a method 'process_user' we call it. (It doesn't for user,
76  *     but there are other examples like process_enrol_user() in behat_core_generator.)
77  *
78  * 6b. (Not used in this example.)
79  *
80  * 6c. Else, if testing_data_generator::create_user exists, we call it with $elementdata. (it does.)
81  *
82  * 6d. If none of these three things work. an error is thrown.
83  *
84  * To understand the missing steps above, consider the example from behat_mod_quiz_generator:
85  * 'group override' => [
86  *      'datagenerator' => 'override',
87  *      'required' => ['quiz', 'group'],
88  *      'switchids' => ['quiz' => 'quiz', 'group' => 'groupid'],
89  * ],
90  * Processing is as above, except that:
91  *
92  * 1. Note 'datagenerator' is 'override' (not group_override). 'user override' maps to the
93  *    same datagenerator. This works fine.
94  *
95  * 4. Because 'switchids' is present, human-readable data in the table gets converted to ids.
96  *    They array key 'group' refers to a column which may be present in the table (it will be
97  *    here because it is required, but it does not have to be in general). If that column
98  *    is present and contains a value, then the method matching name like get_group_id() is
99  *    called with the value from that column in the data table. You must implement this
100  *    method. You can see several examples of this sort of method below.
101  *
102  *    If that method returns a group id, then $elementdata['group'] is unset and
103  *    $elementdata['groupid'] is set to the result of the get_group_id() call. 'groupid' here
104  *    because of the definition is 'switchids' => [..., 'group' => 'groupid'].
105  *    If get_group_id() cannot find the group, it should throw a helpful exception.
106  *
107  *    Similarly, 'quiz' (the quiz name) is looked up with a call to get_quiz_id(). Here, the
108  *    new array key set matches the old one removed. This is fine.
109  *
110  * 6b. We are in a plugin, so before checking whether testing_data_generator::create_override
111  *     exists we first check whether mod_quiz_generator::create_override() exists. It does,
112  *     and this is what gets called.
113  *
114  * This second example shows why the get_..._id methods for core entities are in this base
115  * class, not in behat_core_generator. Plugins may need to look up the ids of
116  * core entities.
117  *
118  * behat_core_generator is defined in lib/behat/classes/behat_core_generator.php
119  * and for components, behat_..._generator is defined in tests/generator/behat_..._generator.php
120  * inside the plugin. For example behat_mod_quiz_generator is defined in
121  * mod/quiz/tests/generator/behat_mod_quiz_generator.php.
122  *
123  * @package   core
124  * @category  test
125  * @copyright 2012 David MonllaĆ³
126  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
127  */
128 abstract class behat_generator_base {
130     /**
131      * @var string the name of the component we belong to.
132      *
133      * This should probably only be used to make error messages clearer.
134      */
135     protected $component;
137     /**
138      * @var testing_data_generator the core data generator
139      */
140     protected $datagenerator;
142     /**
143      * @var testing_data_generator the data generator for this component.
144      */
145     protected $componentdatagenerator;
147     /**
148      * Constructor.
149      *
150      * @param string $component component name, to make error messages more readable.
151      */
152     public function __construct(string $component) {
153         $this->component = $component;
154     }
156     /**
157      * Get a list of the entities that can be created for this component.
158      *
159      * This function must be overridden in subclasses. See class comment
160      * above for a description of the data structure.
161      * See {@link behat_core_generator} for an example.
162      *
163      * @return array entity name => information about how to generate.
164      */
165     protected abstract function get_creatable_entities(): array;
167     /**
168      * Do the work to generate an entity.
169      *
170      * This is called by {@link behat_data_generators::the_following_entities_exist()}.
171      *
172      * @param string    $generatortype The name of the entity to create.
173      * @param TableNode $data from the step.
174      */
175     public function generate_items(string $generatortype, TableNode $data) {
176         // Now that we need them require the data generators.
177         require_once(__DIR__ . '/../../testing/generator/lib.php');
179         $elements = $this->get_creatable_entities();
181         if (!isset($elements[$generatortype])) {
182             throw new PendingException($this->name_for_errors($generatortype) .
183                     ' is not a known type of entity that can be generated.');
184         }
185         $entityinfo = $elements[$generatortype];
187         $this->datagenerator = testing_util::get_data_generator();
188         if ($this->component === 'core') {
189             $this->componentdatagenerator = $this->datagenerator;
190         } else {
191             $this->componentdatagenerator = $this->datagenerator->get_plugin_generator($this->component);
192         }
194         $generatortype = $entityinfo['datagenerator'];
196         foreach ($data->getHash() as $elementdata) {
198             // Check if all the required fields are there.
199             foreach ($entityinfo['required'] as $requiredfield) {
200                 if (!isset($elementdata[$requiredfield])) {
201                     throw new Exception($this->name_for_errors($generatortype) .
202                             ' requires the field ' . $requiredfield . ' to be specified');
203                 }
204             }
206             // Switch from human-friendly references to ids.
207             if (!empty($entityinfo['switchids'])) {
208                 foreach ($entityinfo['switchids'] as $element => $field) {
209                     $methodname = 'get_' . $element . '_id';
211                     // Not all the switch fields are required, default vars will be assigned by data generators.
212                     if (isset($elementdata[$element])) {
213                         if (!method_exists($this, $methodname)) {
214                             throw new coding_exception('The generator for ' .
215                                     $this->name_for_errors($generatortype) .
216                                     ' entities specifies \'switchids\' => [..., \'' . $element .
217                                     '\' => \'' . $field . '\', ...] but the required method ' .
218                                     $methodname . '() has not been defined in ' .
219                                     get_class($this) . '.');
220                         }
221                         // Temp $id var to avoid problems when $element == $field.
222                         $id = $this->{$methodname}($elementdata[$element]);
223                         unset($elementdata[$element]);
224                         $elementdata[$field] = $id;
225                     }
226                 }
227             }
229             // Preprocess the entities that requires a special treatment.
230             if (method_exists($this, 'preprocess_' . $generatortype)) {
231                 $elementdata = $this->{'preprocess_' . $generatortype}($elementdata);
232             }
234             // Creates element.
235             if (method_exists($this, 'process_' . $generatortype)) {
236                 // Use a method on this class to do the work.
237                 $this->{'process_' . $generatortype}($elementdata);
239             } else if (method_exists($this->componentdatagenerator, 'create_' . $generatortype)) {
240                 // Using the component't own data generator if it exists.
241                 $this->componentdatagenerator->{'create_' . $generatortype}($elementdata);
243             } else if (method_exists($this->datagenerator, 'create_' . $generatortype)) {
244                 // Use a method on the core data geneator, if there is one.
245                 $this->datagenerator->{'create_' . $generatortype}($elementdata);
247             } else {
248                 // Give up.
249                 throw new PendingException($this->name_for_errors($generatortype) .
250                         ' data generator is not implemented');
251             }
252         }
253     }
255     /**
256      * Helper for formatting error messages.
257      *
258      * @param string $entitytype entity type without prefix, e.g. 'frog'.
259      * @return string either 'frog' for core entities, or 'mod_mymod > frog' for components.
260      */
261     protected function name_for_errors(string $entitytype): string {
262         if ($this->component === 'core') {
263             return '"' . $entitytype . '"';
264         } else {
265             return '"' . $this->component . ' > ' . $entitytype . '"';
266         }
267     }
269     /**
270      * Gets the grade category id from the grade category fullname
271      *
272      * @param string $fullname the grade category name.
273      * @return int corresponding id.
274      */
275     protected function get_gradecategory_id($fullname) {
276         global $DB;
278         if (!$id = $DB->get_field('grade_categories', 'id', array('fullname' => $fullname))) {
279             throw new Exception('The specified grade category with fullname "' . $fullname . '" does not exist');
280         }
281         return $id;
282     }
284     /**
285      * Gets the user id from it's username.
286      * @throws Exception
287      * @param string $username
288      * @return int
289      */
290     protected function get_user_id($username) {
291         global $DB;
293         if (!$id = $DB->get_field('user', 'id', array('username' => $username))) {
294             throw new Exception('The specified user with username "' . $username . '" does not exist');
295         }
296         return $id;
297     }
299     /**
300      * Gets the role id from it's shortname.
301      * @throws Exception
302      * @param string $roleshortname
303      * @return int
304      */
305     protected function get_role_id($roleshortname) {
306         global $DB;
308         if (!$id = $DB->get_field('role', 'id', array('shortname' => $roleshortname))) {
309             throw new Exception('The specified role with shortname "' . $roleshortname . '" does not exist');
310         }
312         return $id;
313     }
315     /**
316      * Gets the category id from it's idnumber.
317      * @throws Exception
318      * @param string $idnumber
319      * @return int
320      */
321     protected function get_category_id($idnumber) {
322         global $DB;
324         // If no category was specified use the data generator one.
325         if ($idnumber == false) {
326             return null;
327         }
329         if (!$id = $DB->get_field('course_categories', 'id', array('idnumber' => $idnumber))) {
330             throw new Exception('The specified category with idnumber "' . $idnumber . '" does not exist');
331         }
333         return $id;
334     }
336     /**
337      * Gets the course id from it's shortname.
338      * @throws Exception
339      * @param string $shortname
340      * @return int
341      */
342     protected function get_course_id($shortname) {
343         global $DB;
345         if (!$id = $DB->get_field('course', 'id', array('shortname' => $shortname))) {
346             throw new Exception('The specified course with shortname "' . $shortname . '" does not exist');
347         }
348         return $id;
349     }
351     /**
352      * Gets the group id from it's idnumber.
353      * @throws Exception
354      * @param string $idnumber
355      * @return int
356      */
357     protected function get_group_id($idnumber) {
358         global $DB;
360         if (!$id = $DB->get_field('groups', 'id', array('idnumber' => $idnumber))) {
361             throw new Exception('The specified group with idnumber "' . $idnumber . '" does not exist');
362         }
363         return $id;
364     }
366     /**
367      * Gets the grouping id from it's idnumber.
368      * @throws Exception
369      * @param string $idnumber
370      * @return int
371      */
372     protected function get_grouping_id($idnumber) {
373         global $DB;
375         // Do not fetch grouping ID for empty grouping idnumber.
376         if (empty($idnumber)) {
377             return null;
378         }
380         if (!$id = $DB->get_field('groupings', 'id', array('idnumber' => $idnumber))) {
381             throw new Exception('The specified grouping with idnumber "' . $idnumber . '" does not exist');
382         }
383         return $id;
384     }
386     /**
387      * Gets the cohort id from it's idnumber.
388      * @throws Exception
389      * @param string $idnumber
390      * @return int
391      */
392     protected function get_cohort_id($idnumber) {
393         global $DB;
395         if (!$id = $DB->get_field('cohort', 'id', array('idnumber' => $idnumber))) {
396             throw new Exception('The specified cohort with idnumber "' . $idnumber . '" does not exist');
397         }
398         return $id;
399     }
401     /**
402      * Gets the outcome item id from its shortname.
403      * @throws Exception
404      * @param string $shortname
405      * @return int
406      */
407     protected function get_outcome_id($shortname) {
408         global $DB;
410         if (!$id = $DB->get_field('grade_outcomes', 'id', array('shortname' => $shortname))) {
411             throw new Exception('The specified outcome with shortname "' . $shortname . '" does not exist');
412         }
413         return $id;
414     }
416     /**
417      * Get the id of a named scale.
418      * @param string $name the name of the scale.
419      * @return int the scale id.
420      */
421     protected function get_scale_id($name) {
422         global $DB;
424         if (!$id = $DB->get_field('scale', 'id', array('name' => $name))) {
425             throw new Exception('The specified scale with name "' . $name . '" does not exist');
426         }
427         return $id;
428     }
430     /**
431      * Get the id of a named question category (must be globally unique).
432      * Note that 'Top' is a special value, used when setting the parent of another
433      * category, meaning top-level.
434      *
435      * @param string $name the question category name.
436      * @return int the question category id.
437      */
438     protected function get_questioncategory_id($name) {
439         global $DB;
441         if ($name == 'Top') {
442             return 0;
443         }
445         if (!$id = $DB->get_field('question_categories', 'id', array('name' => $name))) {
446             throw new Exception('The specified question category with name "' . $name . '" does not exist');
447         }
448         return $id;
449     }
451     /**
452      * Gets the internal context id from the context reference.
453      *
454      * The context reference changes depending on the context
455      * level, it can be the system, a user, a category, a course or
456      * a module.
457      *
458      * @throws Exception
459      * @param string $levelname The context level string introduced by the test writer
460      * @param string $contextref The context reference introduced by the test writer
461      * @return context
462      */
463     protected function get_context($levelname, $contextref) {
464         global $DB;
466         // Getting context levels and names (we will be using the English ones as it is the test site language).
467         $contextlevels = context_helper::get_all_levels();
468         $contextnames = array();
469         foreach ($contextlevels as $level => $classname) {
470             $contextnames[context_helper::get_level_name($level)] = $level;
471         }
473         if (empty($contextnames[$levelname])) {
474             throw new Exception('The specified "' . $levelname . '" context level does not exist');
475         }
476         $contextlevel = $contextnames[$levelname];
478         // Return it, we don't need to look for other internal ids.
479         if ($contextlevel == CONTEXT_SYSTEM) {
480             return context_system::instance();
481         }
483         switch ($contextlevel) {
485             case CONTEXT_USER:
486                 $instanceid = $DB->get_field('user', 'id', array('username' => $contextref));
487                 break;
489             case CONTEXT_COURSECAT:
490                 $instanceid = $DB->get_field('course_categories', 'id', array('idnumber' => $contextref));
491                 break;
493             case CONTEXT_COURSE:
494                 $instanceid = $DB->get_field('course', 'id', array('shortname' => $contextref));
495                 break;
497             case CONTEXT_MODULE:
498                 $instanceid = $DB->get_field('course_modules', 'id', array('idnumber' => $contextref));
499                 break;
501             default:
502                 break;
503         }
505         $contextclass = $contextlevels[$contextlevel];
506         if (!$context = $contextclass::instance($instanceid, IGNORE_MISSING)) {
507             throw new Exception('The specified "' . $contextref . '" context reference does not exist');
508         }
510         return $context;
511     }
513     /**
514      * Gets the contact id from it's username.
515      * @throws Exception
516      * @param string $username
517      * @return int
518      */
519     protected function get_contact_id($username) {
520         global $DB;
522         if (!$id = $DB->get_field('user', 'id', array('username' => $username))) {
523             throw new Exception('The specified user with username "' . $username . '" does not exist');
524         }
525         return $id;
526     }