PageRenderTime 31ms CodeModel.GetById 35ms RepoModel.GetById 0ms app.codeStats 1ms

/webservice/simpletest/testwebservice.php

https://github.com/blackboard-open-source/moodle
PHP | 1573 lines | 1104 code | 242 blank | 227 comment | 44 complexity | cfa6f75c666ba74fdd3e6f5146da63dc MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.1, GPL-3.0, Apache-2.0

Large files files are truncated, but you can click here to view the full file

  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. * Test the different web service protocols.
  18. *
  19. * @author jerome@moodle.com
  20. * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  21. * @package web service
  22. */
  23. if (!defined('MOODLE_INTERNAL')) {
  24. /// It must be included from a Moodle page
  25. die('Direct access to this script is forbidden.');
  26. }
  27. /**
  28. * How to configure this unit tests:
  29. * 0- Enable the web service you wish to test in the Moodle administration
  30. * 1- Create a service with all functions in the Moodle administration
  31. * 2- Create a token associate this service and to an admin (or a user with all required capabilities)
  32. * 3- Configure setUp() function:
  33. * a- write the token
  34. * b- activate the protocols you wish to test
  35. * c- activate the functions you wish to test (readonlytests and writetests arrays)
  36. * d- set the number of time the web services are run
  37. * Do not run WRITE test function on a production site as they impact the DB (even though every
  38. * test should clean the modified data)
  39. *
  40. * How to write a new function:
  41. * 1- Add the function name to the array readonlytests/writetests
  42. * 2- Set it as false when you commit!
  43. * 3- write the function - Do not prefix the function name by 'test'
  44. */
  45. class webservice_test extends UnitTestCase {
  46. public $testtoken;
  47. public $testrest;
  48. public $testxmlrpc;
  49. public $testsoap;
  50. public $timerrest;
  51. public $timerxmlrpc;
  52. public $timersoap;
  53. public $readonlytests;
  54. public $writetests;
  55. function setUp() {
  56. //token to test
  57. $this->testtoken = 'acabec9d20933913f14309785324f579';
  58. //protocols to test
  59. $this->testrest = false; //Does not work till XML => PHP is implemented (MDL-22965)
  60. $this->testxmlrpc = false;
  61. $this->testsoap = false;
  62. ////// READ-ONLY DB tests ////
  63. $this->readonlytests = array(
  64. 'moodle_group_get_groups' => false,
  65. 'moodle_course_get_courses' => false,
  66. 'moodle_user_get_users_by_id' => false,
  67. 'moodle_enrol_get_enrolled_users' => false,
  68. 'moodle_group_get_course_groups' => false,
  69. 'moodle_group_get_groupmembers' => false,
  70. 'moodle_webservice_get_siteinfo' => false,
  71. 'core_course_get_contents' => false
  72. );
  73. ////// WRITE DB tests ////
  74. $this->writetests = array(
  75. 'moodle_user_create_users' => false,
  76. 'moodle_course_create_courses' => false,
  77. 'moodle_user_delete_users' => false,
  78. 'moodle_user_update_users' => false,
  79. 'moodle_role_assign' => false,
  80. 'moodle_role_unassign' => false,
  81. 'moodle_group_add_groupmembers' => false,
  82. 'moodle_group_delete_groupmembers' => false,
  83. 'moodle_group_create_groups' => false,
  84. 'moodle_group_delete_groups' => false,
  85. 'moodle_enrol_manual_enrol_users' => false,
  86. 'moodle_message_send_messages' => false,
  87. 'moodle_notes_create_notes' => false
  88. );
  89. //performance testing: number of time the web service are run
  90. $this->iteration = 1;
  91. //DO NOT CHANGE
  92. //reset the timers
  93. $this->timerrest = 0;
  94. $this->timerxmlrpc = 0;
  95. $this->timersoap = 0;
  96. }
  97. function testRun() {
  98. global $CFG;
  99. if (!$this->testrest and !$this->testxmlrpc and !$this->testsoap) {
  100. print_r("Web service unit tests are not run as not setup.
  101. (see /webservice/simpletest/testwebservice.php)");
  102. }
  103. if (!empty($this->testtoken)) {
  104. //Does not work till XML => PHP is implemented (MDL-22965)
  105. if ($this->testrest) {
  106. $this->timerrest = time();
  107. require_once($CFG->dirroot . "/webservice/rest/lib.php");
  108. $restclient = new webservice_rest_client($CFG->wwwroot
  109. . '/webservice/rest/server.php', $this->testtoken);
  110. for ($i = 1; $i <= $this->iteration; $i = $i + 1) {
  111. foreach ($this->readonlytests as $functioname => $run) {
  112. if ($run) {
  113. //$this->{$functioname}($restclient);
  114. }
  115. }
  116. foreach ($this->writetests as $functioname => $run) {
  117. if ($run) {
  118. //$this->{$functioname}($restclient);
  119. }
  120. }
  121. }
  122. $this->timerrest = time() - $this->timerrest;
  123. //here you could call a log function to display the timer
  124. //example:
  125. //error_log('REST time: ');
  126. //error_log(print_r($this->timerrest));
  127. }
  128. if ($this->testxmlrpc) {
  129. $this->timerxmlrpc = time();
  130. require_once($CFG->dirroot . "/webservice/xmlrpc/lib.php");
  131. $xmlrpcclient = new webservice_xmlrpc_client($CFG->wwwroot
  132. . '/webservice/xmlrpc/server.php', $this->testtoken);
  133. for ($i = 1; $i <= $this->iteration; $i = $i + 1) {
  134. foreach ($this->readonlytests as $functioname => $run) {
  135. if ($run) {
  136. $this->{$functioname}($xmlrpcclient);
  137. }
  138. }
  139. foreach ($this->writetests as $functioname => $run) {
  140. if ($run) {
  141. $this->{$functioname}($xmlrpcclient);
  142. }
  143. }
  144. }
  145. $this->timerxmlrpc = time() - $this->timerxmlrpc;
  146. //here you could call a log function to display the timer
  147. //example:
  148. //error_log('XML-RPC time: ');
  149. //error_log(print_r($this->timerxmlrpc));
  150. }
  151. if ($this->testsoap) {
  152. $this->timersoap = time();
  153. require_once($CFG->dirroot . "/webservice/soap/lib.php");
  154. $soapclient = new webservice_soap_client($CFG->wwwroot
  155. . '/webservice/soap/server.php', $this->testtoken,
  156. array("features" => SOAP_WAIT_ONE_WAY_CALLS)); //force SOAP synchronous mode
  157. //when function return null
  158. $soapclient->setWsdlCache(false);
  159. for ($i = 1; $i <= $this->iteration; $i = $i + 1) {
  160. foreach ($this->readonlytests as $functioname => $run) {
  161. if ($run) {
  162. $this->{$functioname}($soapclient);
  163. }
  164. }
  165. foreach ($this->writetests as $functioname => $run) {
  166. if ($run) {
  167. $this->{$functioname}($soapclient);
  168. }
  169. }
  170. }
  171. $this->timersoap = time() - $this->timersoap;
  172. //here you could call a log function to display the timer
  173. //example:
  174. //error_log('SOAP time: ');
  175. //error_log(print_r($this->timersoap));
  176. }
  177. }
  178. }
  179. ///// WEB SERVICE TEST FUNCTIONS
  180. function moodle_group_get_groups($client) {
  181. global $DB;
  182. $dbgroups = $DB->get_records('groups');
  183. $groupids = array();
  184. foreach ($dbgroups as $dbgroup) {
  185. $groupids[] = $dbgroup->id;
  186. }
  187. $function = 'moodle_group_get_groups';
  188. $params = array('groupids' => $groupids);
  189. $groups = $client->call($function, $params);
  190. $this->assertEqual(count($groups), count($groupids));
  191. }
  192. function moodle_webservice_get_siteinfo($client) {
  193. global $SITE, $CFG;
  194. $function = 'moodle_webservice_get_siteinfo';
  195. $params = array();
  196. $info = $client->call($function, $params);
  197. $this->assertEqual($info['sitename'], $SITE->fullname);
  198. $this->assertEqual($info['siteurl'], $CFG->wwwroot);
  199. }
  200. function moodle_user_get_users_by_id($client) {
  201. global $DB;
  202. $dbusers = $DB->get_records('user', array('deleted' => 0));
  203. $userids = array();
  204. foreach ($dbusers as $dbuser) {
  205. $userids[] = $dbuser->id;
  206. }
  207. $function = 'moodle_user_get_users_by_id';
  208. $params = array('userids' => $userids);
  209. $users = $client->call($function, $params);
  210. $this->assertEqual(count($users), count($userids));
  211. }
  212. function core_course_get_contents($client) {
  213. global $DB, $CFG;
  214. $dbcourses = $DB->get_records('course');
  215. $function = 'core_course_get_contents';
  216. $coursecontents = array();
  217. foreach ($dbcourses as $dbcourse) {
  218. $params = array('courseid' => $dbcourse->id);
  219. if (file_exists($CFG->dirroot . '/' . '/course/format/' . $dbcourse->format . '/lib.php')) {
  220. $coursecontents = $client->call($function, $params);
  221. }
  222. //Display the content of $coursecontents in your php log and check if you obtain
  223. //what you are expecting
  224. //error_log(print_r($coursecontents, true));
  225. }
  226. }
  227. /**
  228. * This test will:
  229. * 1- create a user (core call)
  230. * 2- enrol this user in the courses supporting enrolment
  231. * 3- unenrol this user (core call)
  232. */
  233. function moodle_enrol_manual_enrol_users($client) {
  234. global $DB, $CFG;
  235. require_once($CFG->dirroot . "/user/lib.php");
  236. require_once($CFG->dirroot . "/user/profile/lib.php");
  237. require_once($CFG->dirroot . "/lib/enrollib.php");
  238. //Delete some previous test data
  239. if ($user = $DB->get_record('user', array('username' => 'veryimprobabletestusername2'))) {
  240. $DB->delete_records('user', array('id' => $user->id));
  241. }
  242. if ($role = $DB->get_record('role', array('shortname' => 'role1thatshouldnotexist'))) {
  243. set_role_contextlevels($role->id, array(CONTEXT_COURSE));
  244. delete_role($role->id);
  245. }
  246. //create a user
  247. $user = new stdClass();
  248. $user->username = 'veryimprobabletestusername2';
  249. $user->password = 'testpassword2';
  250. $user->firstname = 'testfirstname2';
  251. $user->lastname = 'testlastname2';
  252. $user->email = 'testemail1@moodle.com';
  253. $user->id = user_create_user($user);
  254. $roleid = create_role('role1thatshouldnotexist', 'role1thatshouldnotexist', '');
  255. set_role_contextlevels($roleid, array(CONTEXT_COURSE));
  256. $enrolments = array();
  257. $courses = $DB->get_records('course');
  258. foreach ($courses as $course) {
  259. if ($course->id > 1) {
  260. $enrolments[] = array('roleid' => $roleid,
  261. 'userid' => $user->id, 'courseid' => $course->id);
  262. $enrolledcourses[] = $course;
  263. }
  264. }
  265. //web service call
  266. $function = 'moodle_enrol_manual_enrol_users';
  267. $wsparams = array('enrolments' => $enrolments);
  268. $enrolmentsresult = $client->call($function, $wsparams);
  269. //get instance that can unenrol
  270. $enrols = enrol_get_plugins(true);
  271. $enrolinstances = enrol_get_instances($course->id, true);
  272. $unenrolled = false;
  273. foreach ($enrolinstances as $instance) {
  274. if (!$unenrolled and $enrols[$instance->enrol]->allow_unenrol($instance)) {
  275. $unenrolinstance = $instance;
  276. $unenrolled = true;
  277. }
  278. }
  279. //test and unenrol the user
  280. $enrolledusercourses = enrol_get_users_courses($user->id);
  281. foreach ($enrolledcourses as $course) {
  282. //test
  283. $this->assertEqual(true, isset($enrolledusercourses[$course->id]));
  284. //unenrol the user
  285. $enrols[$unenrolinstance->enrol]->unenrol_user($unenrolinstance, $user->id, $roleid);
  286. }
  287. //delete user
  288. $DB->delete_records('user', array('id' => $user->id));
  289. //delete the context level
  290. set_role_contextlevels($roleid, array(CONTEXT_COURSE));
  291. //delete role
  292. delete_role($roleid);
  293. }
  294. function moodle_enrol_get_enrolled_users($client) {
  295. global $DB;
  296. //function settings
  297. $withcapability = '';
  298. $groupid = null;
  299. $onlyactive = false;
  300. $dbcourses = $DB->get_records('course');
  301. $function = 'moodle_enrol_get_enrolled_users';
  302. foreach ($dbcourses as $dbcourse) {
  303. $params = array();
  304. $coursecontext = get_context_instance(CONTEXT_COURSE, $dbcourse->id);
  305. list($sql, $params) = get_enrolled_sql($coursecontext, $withcapability, $groupid, $onlyactive);
  306. $sql = "SELECT DISTINCT ue.userid, e.courseid
  307. FROM {user_enrolments} ue
  308. JOIN {enrol} e ON (e.id = ue.enrolid)
  309. WHERE e.courseid = :courseid AND ue.userid IN ($sql)";
  310. $params['courseid'] = $dbcourse->id;
  311. $enrolledusers = $DB->get_records_sql($sql, $params);
  312. $wsparams = array('courseid' => $dbcourse->id, 'withcapability' => $withcapability,
  313. 'groupid' => $groupid, 'onlyactive' => $onlyactive);
  314. $resultusers = $client->call($function, $wsparams);
  315. $this->assertEqual(count($resultusers), count($enrolledusers));
  316. }
  317. }
  318. function moodle_course_get_courses($client) {
  319. global $DB;
  320. $function = 'moodle_course_get_courses';
  321. //retrieve all courses from db
  322. $dbcourses = $DB->get_records('course');
  323. $courseids = array();
  324. foreach ($dbcourses as $dbcourse) {
  325. $courseids[] = $dbcourse->id;
  326. }
  327. //retrieve all courses by id
  328. $params = array('options' => array('ids' => $courseids));
  329. $courses = $client->call($function, $params);
  330. //check it is the same course count
  331. $this->assertEqual(count($courses), count($courseids));
  332. //check all course values are identic
  333. foreach ($courses as $course) {
  334. $this->assertEqual($course['fullname'],
  335. $dbcourses[$course['id']]->fullname);
  336. $this->assertEqual($course['shortname'],
  337. $dbcourses[$course['id']]->shortname);
  338. $this->assertEqual($course['categoryid'],
  339. $dbcourses[$course['id']]->category);
  340. $this->assertEqual($course['categorysortorder'],
  341. $dbcourses[$course['id']]->sortorder);
  342. $this->assertEqual($course['idnumber'],
  343. $dbcourses[$course['id']]->idnumber);
  344. $this->assertEqual($course['summary'],
  345. $dbcourses[$course['id']]->summary);
  346. $this->assertEqual($course['summaryformat'],
  347. $dbcourses[$course['id']]->summaryformat);
  348. $this->assertEqual($course['format'],
  349. $dbcourses[$course['id']]->format);
  350. $this->assertEqual($course['showgrades'],
  351. $dbcourses[$course['id']]->showgrades);
  352. $this->assertEqual($course['newsitems'],
  353. $dbcourses[$course['id']]->newsitems);
  354. $this->assertEqual($course['startdate'],
  355. $dbcourses[$course['id']]->startdate);
  356. $this->assertEqual($course['numsections'],
  357. $dbcourses[$course['id']]->numsections);
  358. $this->assertEqual($course['maxbytes'],
  359. $dbcourses[$course['id']]->maxbytes);
  360. $this->assertEqual($course['visible'],
  361. $dbcourses[$course['id']]->visible);
  362. $this->assertEqual($course['hiddensections'],
  363. $dbcourses[$course['id']]->hiddensections);
  364. $this->assertEqual($course['groupmode'],
  365. $dbcourses[$course['id']]->groupmode);
  366. $this->assertEqual($course['groupmodeforce'],
  367. $dbcourses[$course['id']]->groupmodeforce);
  368. $this->assertEqual($course['defaultgroupingid'],
  369. $dbcourses[$course['id']]->defaultgroupingid);
  370. $this->assertEqual($course['lang'],
  371. $dbcourses[$course['id']]->lang);
  372. $this->assertEqual($course['timecreated'],
  373. $dbcourses[$course['id']]->timecreated);
  374. $this->assertEqual($course['timemodified'],
  375. $dbcourses[$course['id']]->timemodified);
  376. if (key_exists('enablecompletion', $course)) {
  377. $this->assertEqual($course['enablecompletion'],
  378. $dbcourses[$course['id']]->enablecompletion);
  379. }
  380. if (key_exists('completionstartonenrol', $course)) {
  381. $this->assertEqual($course['completionstartonenrol'],
  382. $dbcourses[$course['id']]->completionstartonenrol);
  383. }
  384. if (key_exists('completionnotify', $course)) {
  385. $this->assertEqual($course['completionnotify'],
  386. $dbcourses[$course['id']]->completionnotify);
  387. }
  388. $this->assertEqual($course['forcetheme'],
  389. $dbcourses[$course['id']]->theme);
  390. }
  391. }
  392. function moodle_course_create_courses($client) {
  393. global $DB, $CFG;
  394. ///Test data
  395. $courseconfig = get_config('moodlecourse');
  396. $themeobjects = get_list_of_themes();
  397. $theme = key($themeobjects);
  398. $categoryid = $DB->get_record('course_categories', array(), '*', IGNORE_MULTIPLE)->id;
  399. $categoryid = empty($categoryid) ? 0 : $categoryid;
  400. $course1 = new stdClass();
  401. $course1->fullname = 'Test Data create course 1';
  402. $course1->shortname = 'testdatacourse1';
  403. $course1->categoryid = $categoryid;
  404. $course1->idnumber = '328327982372342343234';
  405. $course1->summary = 'This is a summary';
  406. $course1->summaryformat = FORMAT_HTML;
  407. $course1->format = $courseconfig->format;
  408. $course1->showgrades = $courseconfig->showgrades;
  409. $course1->showreports = $courseconfig->showreports;
  410. $course1->newsitems = $courseconfig->newsitems;
  411. $course1->startdate = time();
  412. $course1->numsections = $courseconfig->numsections;
  413. $course1->maxbytes = $courseconfig->maxbytes;
  414. $course1->visible = $courseconfig->visible;
  415. $course1->hiddensections = $courseconfig->hiddensections;
  416. $course1->groupmode = $courseconfig->groupmode;
  417. $course1->groupmodeforce = $courseconfig->groupmodeforce;
  418. $course1->defaultgroupingid = 0;
  419. if (!empty($courseconfig->lang)) {
  420. $course1->lang = $courseconfig->lang;
  421. }
  422. $course1->enablecompletion = $courseconfig->enablecompletion;
  423. $course1->completionstartonenrol = $courseconfig->completionstartonenrol;
  424. $course1->completionnotify = 0;
  425. $course1->forcetheme = $theme;
  426. $course2 = new stdClass();
  427. $course2->fullname = 'Test Data create course 2';
  428. $course2->shortname = 'testdatacourse2';
  429. $course2->categoryid = $categoryid;
  430. $courses = array($course1, $course2);
  431. //do not run the test if course1 or course2 already exists
  432. $existingcourses = $DB->get_records_list('course', 'fullname',
  433. array($course1->fullname, $course2->fullname));
  434. if (!empty($existingcourses)) {
  435. throw new moodle_exception('testdatacoursesalreadyexist');
  436. }
  437. $function = 'moodle_course_create_courses';
  438. $params = array('courses' => $courses);
  439. $resultcourses = $client->call($function, $params);
  440. $this->assertEqual(count($courses), count($resultcourses));
  441. //retrieve user1 from the DB and check values
  442. $dbcourse1 = $DB->get_record('course', array('fullname' => $course1->fullname));
  443. $this->assertEqual($dbcourse1->fullname, $course1->fullname);
  444. $this->assertEqual($dbcourse1->shortname, $course1->shortname);
  445. $this->assertEqual($dbcourse1->category, $course1->categoryid);
  446. $this->assertEqual($dbcourse1->idnumber, $course1->idnumber);
  447. $this->assertEqual($dbcourse1->summary, $course1->summary);
  448. $this->assertEqual($dbcourse1->summaryformat, $course1->summaryformat);
  449. $this->assertEqual($dbcourse1->format, $course1->format);
  450. $this->assertEqual($dbcourse1->showgrades, $course1->showgrades);
  451. $this->assertEqual($dbcourse1->showreports, $course1->showreports);
  452. $this->assertEqual($dbcourse1->newsitems, $course1->newsitems);
  453. $this->assertEqual($dbcourse1->startdate, $course1->startdate);
  454. $this->assertEqual($dbcourse1->numsections, $course1->numsections);
  455. $this->assertEqual($dbcourse1->maxbytes, $course1->maxbytes);
  456. $this->assertEqual($dbcourse1->visible, $course1->visible);
  457. $this->assertEqual($dbcourse1->hiddensections, $course1->hiddensections);
  458. $this->assertEqual($dbcourse1->groupmode, $course1->groupmode);
  459. $this->assertEqual($dbcourse1->groupmodeforce, $course1->groupmodeforce);
  460. $this->assertEqual($dbcourse1->defaultgroupingid, $course1->defaultgroupingid);
  461. if (!empty($courseconfig->lang)) {
  462. $this->assertEqual($dbcourse1->lang, $course1->lang);
  463. }
  464. if (completion_info::is_enabled_for_site()) {
  465. $this->assertEqual($dbcourse1->enablecompletion, $course1->enablecompletion);
  466. $this->assertEqual($dbcourse1->completionstartonenrol, $course1->completionstartonenrol);
  467. }
  468. $this->assertEqual($dbcourse1->completionnotify, $course1->completionnotify);
  469. if (!empty($CFG->allowcoursethemes)) {
  470. $this->assertEqual($dbcourse1->theme, $course1->forcetheme);
  471. }
  472. //retrieve user2 from the DB and check values
  473. $dbcourse2 = $DB->get_record('course', array('fullname' => $course2->fullname));
  474. $this->assertEqual($dbcourse2->fullname, $course2->fullname);
  475. $this->assertEqual($dbcourse2->shortname, $course2->shortname);
  476. $this->assertEqual($dbcourse2->category, $course2->categoryid);
  477. $this->assertEqual($dbcourse2->summaryformat, FORMAT_MOODLE);
  478. $this->assertEqual($dbcourse2->format, $courseconfig->format);
  479. $this->assertEqual($dbcourse2->showgrades, $courseconfig->showgrades);
  480. $this->assertEqual($dbcourse2->showreports, $courseconfig->showreports);
  481. $this->assertEqual($dbcourse2->newsitems, $courseconfig->newsitems);
  482. $this->assertEqual($dbcourse2->numsections, $courseconfig->numsections);
  483. $this->assertEqual($dbcourse2->maxbytes, $courseconfig->maxbytes);
  484. $this->assertEqual($dbcourse2->visible, $courseconfig->visible);
  485. $this->assertEqual($dbcourse2->hiddensections, $courseconfig->hiddensections);
  486. $this->assertEqual($dbcourse2->groupmode, $courseconfig->groupmode);
  487. $this->assertEqual($dbcourse2->groupmodeforce, $courseconfig->groupmodeforce);
  488. $this->assertEqual($dbcourse2->defaultgroupingid, 0);
  489. //delete users from DB
  490. $DB->delete_records_list('course', 'id',
  491. array($dbcourse1->id, $dbcourse2->id));
  492. }
  493. function moodle_user_create_users($client) {
  494. global $DB, $CFG;
  495. //Test data
  496. //a full user: user1
  497. $user1 = new stdClass();
  498. $user1->username = 'testusername1';
  499. $user1->password = 'testpassword1';
  500. $user1->firstname = 'testfirstname1';
  501. $user1->lastname = 'testlastname1';
  502. $user1->email = 'testemail1@moodle.com';
  503. $user1->auth = 'manual';
  504. $user1->idnumber = 'testidnumber1';
  505. $user1->lang = 'en';
  506. $user1->theme = 'standard';
  507. $user1->timezone = '-12.5';
  508. $user1->mailformat = 0;
  509. $user1->description = 'Hello World!';
  510. $user1->city = 'testcity1';
  511. $user1->country = 'au';
  512. $preferencename1 = 'preference1';
  513. $preferencename2 = 'preference2';
  514. $user1->preferences = array(
  515. array('type' => $preferencename1, 'value' => 'preferencevalue1'),
  516. array('type' => $preferencename2, 'value' => 'preferencevalue2'));
  517. $customfieldname1 = 'testdatacustom1';
  518. $customfieldname2 = 'testdatacustom2';
  519. $user1->customfields = array(
  520. array('type' => $customfieldname1, 'value' => 'customvalue'),
  521. array('type' => $customfieldname2, 'value' => 'customvalue2'));
  522. //a small user: user2
  523. $user2 = new stdClass();
  524. $user2->username = 'testusername2';
  525. $user2->password = 'testpassword2';
  526. $user2->firstname = 'testfirstname2';
  527. $user2->lastname = 'testlastname2';
  528. $user2->email = 'testemail1@moodle.com';
  529. $user2->timezone = 'Pacific/Port_Moresby';
  530. $users = array($user1, $user2);
  531. //do not run the test if user1 or user2 already exists
  532. $existingusers = $DB->get_records_list('user', 'username',
  533. array($user1->username, $user2->username));
  534. if (!empty($existingusers)) {
  535. throw new moodle_exception('testdatausersalreadyexist');
  536. }
  537. //do not run the test if data test custom fields already exists
  538. $existingcustomfields = $DB->get_records_list('user_info_field', 'shortname',
  539. array($customfieldname1, $customfieldname2));
  540. if (!empty($existingcustomfields)) {
  541. throw new moodle_exception('testdatacustomfieldsalreadyexist');
  542. }
  543. //create the custom fields
  544. $customfield = new stdClass();
  545. $customfield->shortname = $customfieldname1;
  546. $customfield->name = $customfieldname1;
  547. $customfield->datatype = 'text';
  548. $DB->insert_record('user_info_field', $customfield);
  549. $customfield = new stdClass();
  550. $customfield->shortname = $customfieldname2;
  551. $customfield->name = $customfieldname2;
  552. $customfield->datatype = 'text';
  553. $DB->insert_record('user_info_field', $customfield);
  554. $function = 'moodle_user_create_users';
  555. $params = array('users' => $users);
  556. $resultusers = $client->call($function, $params);
  557. $this->assertEqual(count($users), count($resultusers));
  558. //retrieve user1 from the DB and check values
  559. $dbuser1 = $DB->get_record('user', array('username' => $user1->username));
  560. $this->assertEqual($dbuser1->firstname, $user1->firstname);
  561. $this->assertEqual($dbuser1->password,
  562. hash_internal_user_password($user1->password));
  563. $this->assertEqual($dbuser1->lastname, $user1->lastname);
  564. $this->assertEqual($dbuser1->email, $user1->email);
  565. $this->assertEqual($dbuser1->auth, $user1->auth);
  566. $this->assertEqual($dbuser1->idnumber, $user1->idnumber);
  567. $this->assertEqual($dbuser1->lang, $user1->lang);
  568. $this->assertEqual($dbuser1->theme, $user1->theme);
  569. $this->assertEqual($dbuser1->timezone, $user1->timezone);
  570. $this->assertEqual($dbuser1->mailformat, $user1->mailformat);
  571. $this->assertEqual($dbuser1->description, $user1->description);
  572. $this->assertEqual($dbuser1->city, $user1->city);
  573. $this->assertEqual($dbuser1->country, $user1->country);
  574. $user1preference1 = get_user_preferences($user1->preferences[0]['type'],
  575. null, $dbuser1->id);
  576. $this->assertEqual($user1->preferences[0]['value'], $user1preference1);
  577. $user1preference2 = get_user_preferences($user1->preferences[1]['type'],
  578. null, $dbuser1->id);
  579. $this->assertEqual($user1->preferences[1]['value'], $user1preference2);
  580. require_once($CFG->dirroot . "/user/profile/lib.php");
  581. $customfields = profile_user_record($dbuser1->id);
  582. $customfields = (array) $customfields;
  583. $customfieldname1 = $user1->customfields[0]['type'];
  584. $customfieldname2 = $user1->customfields[1]['type'];
  585. $this->assertEqual($customfields[$customfieldname1],
  586. $user1->customfields[0]['value']);
  587. $this->assertEqual($customfields[$customfieldname2],
  588. $user1->customfields[1]['value']);
  589. //retrieve user2 from the DB and check values
  590. $dbuser2 = $DB->get_record('user', array('username' => $user2->username));
  591. $this->assertEqual($dbuser2->firstname, $user2->firstname);
  592. $this->assertEqual($dbuser2->password,
  593. hash_internal_user_password($user2->password));
  594. $this->assertEqual($dbuser2->lastname, $user2->lastname);
  595. $this->assertEqual($dbuser2->email, $user2->email);
  596. $this->assertEqual($dbuser2->timezone, $user2->timezone);
  597. //unset preferences
  598. $DB->delete_records('user_preferences', array('userid' => $dbuser1->id));
  599. //clear custom fields data
  600. $DB->delete_records('user_info_data', array('userid' => $dbuser1->id));
  601. //delete custom fields
  602. $DB->delete_records_list('user_info_field', 'shortname',
  603. array($customfieldname1, $customfieldname2));
  604. //delete users from DB
  605. $DB->delete_records_list('user', 'id',
  606. array($dbuser1->id, $dbuser2->id));
  607. }
  608. function moodle_user_delete_users($client) {
  609. global $DB, $CFG;
  610. //Set test data
  611. //a full user: user1
  612. $user1 = new stdClass();
  613. $user1->username = 'veryimprobabletestusername1';
  614. $user1->password = 'testpassword1';
  615. $user1->firstname = 'testfirstname1';
  616. $user1->lastname = 'testlastname1';
  617. $user1->email = 'testemail1@moodle.com';
  618. $user1->auth = 'manual';
  619. $user1->idnumber = 'testidnumber1';
  620. $user1->lang = 'en';
  621. $user1->theme = 'standard';
  622. $user1->timezone = 99;
  623. $user1->mailformat = 0;
  624. $user1->description = 'Hello World!';
  625. $user1->city = 'testcity1';
  626. $user1->country = 'au';
  627. $preferencename1 = 'preference1';
  628. $preferencename2 = 'preference2';
  629. $user1->preferences = array(
  630. array('type' => $preferencename1, 'value' => 'preferencevalue1'),
  631. array('type' => $preferencename2, 'value' => 'preferencevalue2'));
  632. $customfieldname1 = 'testdatacustom1';
  633. $customfieldname2 = 'testdatacustom2';
  634. $user1->customfields = array(
  635. array('type' => $customfieldname1, 'value' => 'customvalue'),
  636. array('type' => $customfieldname2, 'value' => 'customvalue2'));
  637. //a small user: user2
  638. $user2 = new stdClass();
  639. $user2->username = 'veryimprobabletestusername2';
  640. $user2->password = 'testpassword2';
  641. $user2->firstname = 'testfirstname2';
  642. $user2->lastname = 'testlastname2';
  643. $user2->email = 'testemail1@moodle.com';
  644. $users = array($user1, $user2);
  645. //can run this test only if test usernames don't exist
  646. $searchusers = $DB->get_records_list('user', 'username',
  647. array($user1->username, $user1->username));
  648. if (count($searchusers) == 0) {
  649. //create two users
  650. require_once($CFG->dirroot."/user/lib.php");
  651. require_once($CFG->dirroot."/user/profile/lib.php");
  652. $user1->id = user_create_user($user1);
  653. // custom fields
  654. if(!empty($user1->customfields)) {
  655. foreach($user1->customfields as $customfield) {
  656. $user1->{"profile_field_".$customfield['type']} = $customfield['value'];
  657. }
  658. profile_save_data((object) $user1);
  659. }
  660. //preferences
  661. if (!empty($user1->preferences)) {
  662. foreach($user1->preferences as $preference) {
  663. set_user_preference($preference['type'], $preference['value'],$user1->id);
  664. }
  665. }
  666. $user2->id = user_create_user($user2);
  667. //create the custom fields
  668. $customfield = new stdClass();
  669. $customfield->shortname = $customfieldname1;
  670. $customfield->name = $customfieldname1;
  671. $customfield->datatype = 'text';
  672. $DB->insert_record('user_info_field', $customfield);
  673. $customfield = new stdClass();
  674. $customfield->shortname = $customfieldname2;
  675. $customfield->name = $customfieldname2;
  676. $customfield->datatype = 'text';
  677. $DB->insert_record('user_info_field', $customfield);
  678. //search for them => TEST they exists
  679. $searchusers = $DB->get_records_list('user', 'username',
  680. array($user1->username, $user2->username));
  681. $this->assertEqual(count($users), count($searchusers));
  682. //delete the users by webservice
  683. $function = 'moodle_user_delete_users';
  684. $params = array('users' => array($user1->id, $user2->id));
  685. $client->call($function, $params);
  686. //search for them => TESTS they don't exists
  687. $searchusers = $DB->get_records_list('user', 'username',
  688. array($user1->username, $user2->username));
  689. $this->assertTrue(empty($searchusers));
  690. //unset preferences
  691. $DB->delete_records('user_preferences', array('userid' => $user1->id));
  692. //clear custom fields data
  693. $DB->delete_records('user_info_data', array('userid' => $user1->id));
  694. //delete custom fields
  695. $DB->delete_records_list('user_info_field', 'shortname',
  696. array($customfieldname1, $customfieldname2));
  697. //delete users from DB
  698. $DB->delete_records_list('user', 'id',
  699. array($user1->id, $user2->id));
  700. }
  701. }
  702. function moodle_user_update_users($client) {
  703. global $DB, $CFG;
  704. //Set test data
  705. //a full user: user1
  706. $user1 = new stdClass();
  707. $user1->username = 'veryimprobabletestusername1';
  708. $user1->password = 'testpassword1';
  709. $user1->firstname = 'testfirstname1';
  710. $user1->lastname = 'testlastname1';
  711. $user1->email = 'testemail1@moodle.com';
  712. $user1->auth = 'manual';
  713. $user1->idnumber = 'testidnumber1';
  714. $user1->lang = 'en';
  715. $user1->theme = 'standard';
  716. $user1->timezone = 99;
  717. $user1->mailformat = 0;
  718. $user1->description = 'Hello World!';
  719. $user1->city = 'testcity1';
  720. $user1->country = 'au';
  721. $preferencename1 = 'preference1';
  722. $preferencename2 = 'preference2';
  723. $user1->preferences = array(
  724. array('type' => $preferencename1, 'value' => 'preferencevalue1'),
  725. array('type' => $preferencename2, 'value' => 'preferencevalue2'));
  726. $customfieldname1 = 'testdatacustom1';
  727. $customfieldname2 = 'testdatacustom2';
  728. $user1->customfields = array(
  729. array('type' => $customfieldname1, 'value' => 'customvalue'),
  730. array('type' => $customfieldname2, 'value' => 'customvalue2'));
  731. //a small user: user2
  732. $user2 = new stdClass();
  733. $user2->username = 'veryimprobabletestusername2';
  734. $user2->password = 'testpassword2';
  735. $user2->firstname = 'testfirstname2';
  736. $user2->lastname = 'testlastname2';
  737. $user2->email = 'testemail1@moodle.com';
  738. $users = array($user1, $user2);
  739. //can run this test only if test usernames don't exist
  740. $searchusers = $DB->get_records_list('user', 'username',
  741. array($user1->username, $user1->username));
  742. if (count($searchusers) == 0) {
  743. //create two users
  744. require_once($CFG->dirroot."/user/lib.php");
  745. require_once($CFG->dirroot."/user/profile/lib.php");
  746. $user1->id = user_create_user($user1);
  747. //unset field created by user_create_user
  748. unset($user1->timemodified);
  749. unset($user1->timecreated);
  750. // custom fields
  751. if(!empty($user1->customfields)) {
  752. foreach($user1->customfields as $customfield) {
  753. $customuser1->id = $user1->id;
  754. $customuser1->{"profile_field_".$customfield['type']} = $customfield['value'];
  755. }
  756. profile_save_data((object) $customuser1);
  757. }
  758. //preferences
  759. if (!empty($user1->preferences)) {
  760. foreach($user1->preferences as $preference) {
  761. set_user_preference($preference['type'], $preference['value'],$user1->id);
  762. }
  763. }
  764. $user2->id = user_create_user($user2);
  765. unset($user2->timemodified);
  766. unset($user2->timecreated);
  767. //create the custom fields
  768. $customfield = new stdClass();
  769. $customfield->shortname = $customfieldname1;
  770. $customfield->name = $customfieldname1;
  771. $customfield->datatype = 'text';
  772. $DB->insert_record('user_info_field', $customfield);
  773. $customfield = new stdClass();
  774. $customfield->shortname = $customfieldname2;
  775. $customfield->name = $customfieldname2;
  776. $customfield->datatype = 'text';
  777. $DB->insert_record('user_info_field', $customfield);
  778. //search for them => TEST they exists
  779. $searchusers = $DB->get_records_list('user', 'username',
  780. array($user1->username, $user2->username));
  781. $this->assertEqual(count($users), count($searchusers));
  782. //update the test data
  783. $user1->username = 'veryimprobabletestusername1_updated';
  784. $user1->password = 'testpassword1_updated';
  785. $user1->firstname = 'testfirstname1_updated';
  786. $user1->lastname = 'testlastname1_updated';
  787. $user1->email = 'testemail1_updated@moodle.com';
  788. $user1->auth = 'manual';
  789. $user1->idnumber = 'testidnumber1_updated';
  790. $user1->lang = 'en';
  791. $user1->theme = 'standard';
  792. $user1->timezone = 98;
  793. $user1->mailformat = 1;
  794. $user1->description = 'Hello World!_updated';
  795. $user1->city = 'testcity1_updated';
  796. $user1->country = 'au';
  797. $preferencename1 = 'preference1';
  798. $preferencename2 = 'preference2';
  799. $user1->preferences = array(
  800. array('type' => $preferencename1, 'value' => 'preferencevalue1_updated'),
  801. array('type' => $preferencename2, 'value' => 'preferencevalue2_updated'));
  802. $customfieldname1 = 'testdatacustom1';
  803. $customfieldname2 = 'testdatacustom2';
  804. $user1->customfields = array(
  805. array('type' => $customfieldname1, 'value' => 'customvalue_updated'),
  806. array('type' => $customfieldname2, 'value' => 'customvalue2_updated'));
  807. $user2->username = 'veryimprobabletestusername2_updated';
  808. $user2->password = 'testpassword2_updated';
  809. $user2->firstname = 'testfirstname2_updated';
  810. $user2->lastname = 'testlastname2_updated';
  811. $user2->email = 'testemail1_updated@moodle.com';
  812. $users = array($user1, $user2);
  813. //update the users by web service
  814. $function = 'moodle_user_update_users';
  815. $params = array('users' => $users);
  816. $client->call($function, $params);
  817. //compare DB user with the test data
  818. $dbuser1 = $DB->get_record('user', array('username' => $user1->username));
  819. $this->assertEqual($dbuser1->firstname, $user1->firstname);
  820. $this->assertEqual($dbuser1->password,
  821. hash_internal_user_password($user1->password));
  822. $this->assertEqual($dbuser1->lastname, $user1->lastname);
  823. $this->assertEqual($dbuser1->email, $user1->email);
  824. $this->assertEqual($dbuser1->auth, $user1->auth);
  825. $this->assertEqual($dbuser1->idnumber, $user1->idnumber);
  826. $this->assertEqual($dbuser1->lang, $user1->lang);
  827. $this->assertEqual($dbuser1->theme, $user1->theme);
  828. $this->assertEqual($dbuser1->timezone, $user1->timezone);
  829. $this->assertEqual($dbuser1->mailformat, $user1->mailformat);
  830. $this->assertEqual($dbuser1->description, $user1->description);
  831. $this->assertEqual($dbuser1->city, $user1->city);
  832. $this->assertEqual($dbuser1->country, $user1->country);
  833. $user1preference1 = get_user_preferences($user1->preferences[0]['type'],
  834. null, $dbuser1->id);
  835. $this->assertEqual($user1->preferences[0]['value'], $user1preference1);
  836. $user1preference2 = get_user_preferences($user1->preferences[1]['type'],
  837. null, $dbuser1->id);
  838. $this->assertEqual($user1->preferences[1]['value'], $user1preference2);
  839. require_once($CFG->dirroot . "/user/profile/lib.php");
  840. $customfields = profile_user_record($dbuser1->id);
  841. $customfields = (array) $customfields;
  842. $customfieldname1 = $user1->customfields[0]['type'];
  843. $customfieldname2 = $user1->customfields[1]['type'];
  844. $this->assertEqual($customfields[$customfieldname1],
  845. $user1->customfields[0]['value']);
  846. $this->assertEqual($customfields[$customfieldname2],
  847. $user1->customfields[1]['value']);
  848. $dbuser2 = $DB->get_record('user', array('username' => $user2->username));
  849. $this->assertEqual($dbuser2->firstname, $user2->firstname);
  850. $this->assertEqual($dbuser2->password,
  851. hash_internal_user_password($user2->password));
  852. $this->assertEqual($dbuser2->lastname, $user2->lastname);
  853. $this->assertEqual($dbuser2->email, $user2->email);
  854. //unset preferences
  855. $DB->delete_records('user_preferences', array('userid' => $dbuser1->id));
  856. //clear custom fields data
  857. $DB->delete_records('user_info_data', array('userid' => $dbuser1->id));
  858. //delete custom fields
  859. $DB->delete_records_list('user_info_field', 'shortname',
  860. array($customfieldname1, $customfieldname2));
  861. //delete users from DB
  862. $DB->delete_records_list('user', 'id',
  863. array($dbuser1->id, $dbuser2->id));
  864. }
  865. }
  866. function moodle_role_assign($client) {
  867. global $DB, $CFG;
  868. $searchusers = $DB->get_records_list('user', 'username',
  869. array('veryimprobabletestusername2'));
  870. $searchroles = $DB->get_records_list('role', 'shortname',
  871. array('role1thatshouldnotexist', 'role2thatshouldnotexist'));
  872. if (empty($searchusers) and empty($searchroles)) {
  873. //create a temp user
  874. $user = new stdClass();
  875. $user->username = 'veryimprobabletestusername2';
  876. $user->password = 'testpassword2';
  877. $user->firstname = 'testfirstname2';
  878. $user->lastname = 'testlastname2';
  879. $user->email = 'testemail1@moodle.com';
  880. require_once($CFG->dirroot."/user/lib.php");
  881. $user->id = user_create_user($user);
  882. //create two roles
  883. $role1->id = create_role('role1thatshouldnotexist', 'role1thatshouldnotexist', '');
  884. $role2->id = create_role('role2thatshouldnotexist', 'role2thatshouldnotexist', '');
  885. //assign user to role by webservice
  886. $context = get_system_context();
  887. $assignments = array(
  888. array('roleid' => $role1->id, 'userid' => $user->id, 'contextid' => $context->id),
  889. array('roleid' => $role2->id, 'userid' => $user->id, 'contextid' => $context->id)
  890. );
  891. $function = 'moodle_role_assign';
  892. $params = array('assignments' => $assignments);
  893. $client->call($function, $params);
  894. //check that the assignment work
  895. $roles = get_user_roles($context, $user->id, false);
  896. foreach ($roles as $role) {
  897. $this->assertTrue(($role->roleid == $role1->id) or ($role->roleid == $role2->id) );
  898. }
  899. //unassign roles from user
  900. role_unassign($role1->id, $user->id, $context->id, '', NULL);
  901. role_unassign($role2->id, $user->id, $context->id, '', NULL);
  902. //delete user from DB
  903. $DB->delete_records('user', array('id' => $user->id));
  904. //delete the two role from DB
  905. delete_role($role1->id);
  906. delete_role($role2->id);
  907. }
  908. }
  909. function moodle_role_unassign($client) {
  910. global $DB, $CFG;
  911. $searchusers = $DB->get_records_list('user', 'username',
  912. array('veryimprobabletestusername2'));
  913. $searchroles = $DB->get_records_list('role', 'shortname',
  914. array('role1thatshouldnotexist', 'role2thatshouldnotexist'));
  915. if (empty($searchusers) and empty($searchroles)) {
  916. //create a temp user
  917. $user = new stdClass();
  918. $user->username = 'veryimprobabletestusername2';
  919. $user->password = 'testpassword2';
  920. $user->firstname = 'testfirstname2';
  921. $user->lastname = 'testlastname2';
  922. $user->email = 'testemail1@moodle.com';
  923. require_once($CFG->dirroot."/user/lib.php");
  924. $user->id = user_create_user($user);
  925. //create two roles
  926. $role1->id = create_role('role1thatshouldnotexist', 'role1thatshouldnotexist', '');
  927. $role2->id = create_role('role2thatshouldnotexist', 'role2thatshouldnotexist', '');
  928. //assign roles from user
  929. $context = get_system_context();
  930. role_assign($role1->id, $user->id, $context->id);
  931. role_assign($role2->id, $user->id, $context->id);
  932. //check that the local assignment work
  933. $roles = get_user_roles($context, $user->id, false);
  934. foreach ($roles as $role) {
  935. $this->assertTrue(($role->roleid == $role1->id) or ($role->roleid == $role2->id) );
  936. }
  937. //unassign user to role by webservice
  938. $assignments = array(
  939. array('roleid' => $role1->id, 'userid' => $user->id, 'contextid' => $context->id),
  940. array('roleid' => $role2->id, 'userid' => $user->id, 'contextid' => $context->id)
  941. );
  942. $function = 'moodle_role_unassign';
  943. $params = array('assignments' => $assignments);
  944. $client->call($function, $params);
  945. //check that the web service unassignment work
  946. $roles = get_user_roles($context, $user->id, false);
  947. $this->assertTrue(empty($roles));
  948. //delete user from DB
  949. $DB->delete_records('user', array('id' => $user->id));
  950. //delete the two role from DB
  951. delete_role($role1->id);
  952. delete_role($role2->id);
  953. }
  954. }
  955. /**
  956. * READ ONLY test
  957. * TODO: find a better solution that running web service for each course
  958. * in the system
  959. * For each courses, test the number of groups
  960. * @param object $client
  961. */
  962. function moodle_group_get_course_groups($client) {
  963. global $DB;
  964. $courses = $DB->get_records('course');
  965. foreach($courses as $course) {
  966. $coursegroups = groups_get_all_groups($course->id);
  967. $function = 'moodle_group_get_course_groups';
  968. $params = array('courseid' => $course->id);
  969. $groups = $client->call($function, $params);
  970. $this->assertEqual(count($groups), count($coursegroups));
  971. }
  972. }
  973. /**
  974. * READ ONLY test
  975. * Test that the same number of members are returned
  976. * for each existing group in the system
  977. * @param object $client
  978. */
  979. function moodle_group_get_groupmembers($client) {
  980. global $DB;
  981. $groups = $DB->get_records('groups');
  982. $groupids = array();
  983. foreach ($groups as $group) {
  984. $groupids[] = $group->id;
  985. }
  986. $function = 'moodle_group_get_groupmembers';
  987. $params = array('groupids' => $groupids);
  988. $groupsmembers = $client->call($function, $params);
  989. foreach($groupsmembers as $groupmembers) {
  990. $dbgroupmembers = groups_get_members($groupmembers['groupid']);
  991. unset($groups[$groupmembers['groupid']]);
  992. $this->assertEqual(count($dbgroupmembers), count($groupmembers['userids']));
  993. }
  994. //check that all existing groups have been returned by the web service function
  995. $this->assertTrue(empty($groups));
  996. }
  997. function moodle_group_add_groupmembers($client) {
  998. global $DB, $CFG;
  999. //create category
  1000. $category = new stdClass();
  1001. $category->name = 'tmpcategoryfortest123';
  1002. $category->id = $DB->insert_record('c…

Large files files are truncated, but you can click here to view the full file