PageRenderTime 65ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/admin/tool/lp/tests/behat/behat_tool_lp_data_generators.php

http://github.com/moodle/moodle
PHP | 362 lines | 218 code | 43 blank | 101 comment | 31 complexity | 62d5f1cdd3e42124c55afb501347da7d MD5 | raw file
Possible License(s): MIT, AGPL-3.0, MPL-2.0-no-copyleft-exception, LGPL-3.0, GPL-3.0, Apache-2.0, LGPL-2.1, BSD-3-Clause
  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/>.
  16. /**
  17. * Step definition to generate database fixtures for learning plan system.
  18. *
  19. * @package tool_lp
  20. * @category test
  21. * @copyright 2016 Issam Taboubi <issam.taboubi@umontreal.ca>
  22. * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23. */
  24. require_once(__DIR__ . '/../../../../../lib/behat/behat_base.php');
  25. use Behat\Gherkin\Node\TableNode as TableNode;
  26. use Behat\Behat\Tester\Exception\PendingException as PendingException;
  27. use core_competency\competency;
  28. use core_competency\competency_framework;
  29. use core_competency\plan;
  30. use core_competency\user_evidence;
  31. /**
  32. * Step definition to generate database fixtures for learning plan system.
  33. *
  34. * @package tool_lp
  35. * @category test
  36. * @copyright 2016 Issam Taboubi <issam.taboubi@umontreal.ca>
  37. * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38. */
  39. class behat_tool_lp_data_generators extends behat_base {
  40. /**
  41. * @var tool_lp data generator
  42. */
  43. protected $datageneratorlp;
  44. /**
  45. * Each element specifies:
  46. * - The data generator sufix used.
  47. * - The required fields.
  48. * - The mapping between other elements references and database field names.
  49. * @var array
  50. */
  51. protected static $elements = array(
  52. 'frameworks' => array(
  53. 'datagenerator' => 'framework',
  54. 'required' => array()
  55. ),
  56. 'templates' => array(
  57. 'datagenerator' => 'template',
  58. 'required' => array()
  59. ),
  60. 'plans' => array(
  61. 'datagenerator' => 'plan',
  62. 'required' => array('user')
  63. ),
  64. 'competencies' => array(
  65. 'datagenerator' => 'competency',
  66. 'required' => array('framework')
  67. ),
  68. 'userevidence' => array(
  69. 'datagenerator' => 'user_evidence',
  70. 'required' => array('user')
  71. ),
  72. 'plancompetencies' => array(
  73. 'datagenerator' => 'plan_competency',
  74. 'required' => array('plan', 'competency')
  75. ),
  76. 'userevidencecompetencies' => array(
  77. 'datagenerator' => 'user_evidence_competency',
  78. 'required' => array('userevidence', 'competency')
  79. ),
  80. 'usercompetencies' => array(
  81. 'datagenerator' => 'user_competency',
  82. 'required' => array('user', 'competency')
  83. ),
  84. 'usercompetencyplans' => array(
  85. 'datagenerator' => 'user_competency_plan',
  86. 'required' => array('user', 'competency', 'plan')
  87. )
  88. );
  89. /**
  90. * Creates the specified element. More info about available elements in http://docs.moodle.org/dev/Acceptance_testing#Fixtures.
  91. *
  92. * @Given /^the following lp "(?P<element_string>(?:[^"]|\\")*)" exist:$/
  93. *
  94. * @throws Exception
  95. * @throws PendingException
  96. * @param string $elementname The name of the entity to add
  97. * @param TableNode $data
  98. */
  99. public function the_following_lp_exist($elementname, TableNode $data) {
  100. // Now that we need them require the data generators.
  101. require_once(__DIR__.'/../../../../../lib/phpunit/classes/util.php');
  102. if (empty(self::$elements[$elementname])) {
  103. throw new PendingException($elementname . ' data generator is not implemented');
  104. }
  105. $datagenerator = testing_util::get_data_generator();
  106. $this->datageneratorlp = $datagenerator->get_plugin_generator('core_competency');
  107. $elementdatagenerator = self::$elements[$elementname]['datagenerator'];
  108. $requiredfields = self::$elements[$elementname]['required'];
  109. if (!empty(self::$elements[$elementname]['switchids'])) {
  110. $switchids = self::$elements[$elementname]['switchids'];
  111. }
  112. foreach ($data->getHash() as $elementdata) {
  113. // Check if all the required fields are there.
  114. foreach ($requiredfields as $requiredfield) {
  115. if (!isset($elementdata[$requiredfield])) {
  116. throw new Exception($elementname . ' requires the field ' . $requiredfield . ' to be specified');
  117. }
  118. }
  119. // Switch from human-friendly references to ids.
  120. if (isset($switchids)) {
  121. foreach ($switchids as $element => $field) {
  122. $methodname = 'get_' . $element . '_id';
  123. // Not all the switch fields are required, default vars will be assigned by data generators.
  124. if (isset($elementdata[$element])) {
  125. // Temp $id var to avoid problems when $element == $field.
  126. $id = $this->{$methodname}($elementdata[$element]);
  127. unset($elementdata[$element]);
  128. $elementdata[$field] = $id;
  129. }
  130. }
  131. }
  132. // Preprocess the entities that requires a special treatment.
  133. if (method_exists($this, 'preprocess_' . $elementdatagenerator)) {
  134. $elementdata = $this->{'preprocess_' . $elementdatagenerator}($elementdata);
  135. }
  136. // Creates element.
  137. $methodname = 'create_' . $elementdatagenerator;
  138. if (method_exists($this->datageneratorlp, $methodname)) {
  139. // Using data generators directly.
  140. $this->datageneratorlp->{$methodname}($elementdata);
  141. } else if (method_exists($this, 'process_' . $elementdatagenerator)) {
  142. // Using an alternative to the direct data generator call.
  143. $this->{'process_' . $elementdatagenerator}($elementdata);
  144. } else {
  145. throw new PendingException($elementname . ' data generator is not implemented');
  146. }
  147. }
  148. }
  149. /**
  150. * Adapt creating competency from framework idnumber or frameworkid.
  151. *
  152. * @param array $data
  153. * @return array
  154. */
  155. protected function preprocess_competency($data) {
  156. if (isset($data['framework'])) {
  157. $framework = competency_framework::get_record(array('idnumber' => $data['framework']));
  158. if ($framework) {
  159. $data['competencyframeworkid'] = $framework->get('id');
  160. } else {
  161. $framework = competency_framework::get_record(array('id' => $data['framework']));
  162. if ($framework) {
  163. $data['competencyframeworkid'] = $framework->get('id');
  164. } else {
  165. throw new Exception('Could not resolve framework with idnumber or id : "' . $data['category'] . '"');
  166. }
  167. }
  168. }
  169. unset($data['framework']);
  170. return $data;
  171. }
  172. /**
  173. * Adapt creating plan from user username.
  174. *
  175. * @param array $data
  176. * @return array
  177. */
  178. protected function preprocess_plan($data) {
  179. global $DB;
  180. if (isset($data['user'])) {
  181. $user = $DB->get_record('user', array('username' => $data['user']), '*', MUST_EXIST);
  182. $data['userid'] = $user->id;
  183. }
  184. unset($data['user']);
  185. if (isset($data['reviewer'])) {
  186. if (is_number($data['reviewer'])) {
  187. $data['reviewerid'] = $data['reviewer'];
  188. } else {
  189. $user = $DB->get_record('user', array('username' => $data['reviewer']), '*', MUST_EXIST);
  190. $data['reviewerid'] = $user->id;
  191. }
  192. unset($data['reviewer']);
  193. }
  194. if (isset($data['status'])) {
  195. switch ($data['status']) {
  196. case 'draft':
  197. $status = plan::STATUS_DRAFT;
  198. break;
  199. case 'in review':
  200. $status = plan::STATUS_IN_REVIEW;
  201. break;
  202. case 'waiting for review':
  203. $status = plan::STATUS_WAITING_FOR_REVIEW;
  204. break;
  205. case 'active':
  206. $status = plan::STATUS_ACTIVE;
  207. break;
  208. case 'complete':
  209. $status = plan::STATUS_COMPLETE;
  210. break;
  211. default:
  212. throw new Exception('Could not resolve plan status with: "' . $data['status'] . '"');
  213. break;
  214. }
  215. $data['status'] = $status;
  216. }
  217. return $data;
  218. }
  219. /**
  220. * Adapt creating user_evidence from user username.
  221. *
  222. * @param array $data
  223. * @return array
  224. */
  225. protected function preprocess_user_evidence($data) {
  226. global $DB;
  227. if (isset($data['user'])) {
  228. $user = $DB->get_record('user', array('username' => $data['user']), '*', MUST_EXIST);
  229. $data['userid'] = $user->id;
  230. }
  231. unset($data['user']);
  232. return $data;
  233. }
  234. /**
  235. * Adapt creating plan_competency from plan name and competency shortname.
  236. *
  237. * @param array $data
  238. * @return array
  239. */
  240. protected function preprocess_plan_competency($data) {
  241. global $DB;
  242. if (isset($data['plan'])) {
  243. $plan = $DB->get_record(plan::TABLE, array('name' => $data['plan']), '*', MUST_EXIST);
  244. $data['planid'] = $plan->id;
  245. }
  246. unset($data['plan']);
  247. if (isset($data['competency'])) {
  248. $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
  249. $data['competencyid'] = $competency->id;
  250. }
  251. unset($data['competency']);
  252. return $data;
  253. }
  254. /**
  255. * Adapt creating plan_competency from user evidence name and competency shortname.
  256. *
  257. * @param array $data
  258. * @return array
  259. */
  260. protected function preprocess_user_evidence_competency($data) {
  261. global $DB;
  262. if (isset($data['userevidence'])) {
  263. $userevidence = $DB->get_record(user_evidence::TABLE, array('name' => $data['userevidence']), '*', MUST_EXIST);
  264. $data['userevidenceid'] = $userevidence->id;
  265. }
  266. unset($data['userevidence']);
  267. if (isset($data['competency'])) {
  268. $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
  269. $data['competencyid'] = $competency->id;
  270. }
  271. unset($data['competency']);
  272. return $data;
  273. }
  274. /**
  275. * Adapt creating user_competency from user name and competency shortname.
  276. *
  277. * @param array $data
  278. * @return array
  279. */
  280. protected function preprocess_user_competency($data) {
  281. global $DB;
  282. if (isset($data['user'])) {
  283. $user = $DB->get_record('user', array('username' => $data['user']), '*', MUST_EXIST);
  284. $data['userid'] = $user->id;
  285. }
  286. unset($data['user']);
  287. if (isset($data['competency'])) {
  288. $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
  289. $data['competencyid'] = $competency->id;
  290. }
  291. unset($data['competency']);
  292. return $data;
  293. }
  294. /**
  295. * Adapt creating user_competency_plan from user name, competency shortname and plan name.
  296. *
  297. * @param array $data
  298. * @return array
  299. */
  300. protected function preprocess_user_competency_plan($data) {
  301. global $DB;
  302. if (isset($data['user'])) {
  303. $user = $DB->get_record('user', array('username' => $data['user']), '*', MUST_EXIST);
  304. $data['userid'] = $user->id;
  305. }
  306. unset($data['user']);
  307. if (isset($data['competency'])) {
  308. $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
  309. $data['competencyid'] = $competency->id;
  310. }
  311. unset($data['competency']);
  312. if (isset($data['plan'])) {
  313. $plan = $DB->get_record(plan::TABLE, array('name' => $data['plan']), '*', MUST_EXIST);
  314. $data['planid'] = $plan->id;
  315. }
  316. unset($data['plan']);
  317. return $data;
  318. }
  319. }