[Summary view] [Print] [Text view]

   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  /**
  18   * Group external PHPunit tests
  19   *
  20   * @package    core_group
  21   * @category   external
  22   * @copyright  2012 Jerome Mouneyrac
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   * @since Moodle 2.4
  25   */
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  global $CFG;
  30  
  31  require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  32  require_once($CFG->dirroot . '/group/externallib.php');
  33  require_once($CFG->dirroot . '/group/lib.php');
  34  
  35  class core_group_externallib_testcase extends externallib_advanced_testcase {
  36  
  37      /**
  38       * Test create_groups
  39       */
  40      public function test_create_groups() {
  41          global $DB;
  42  
  43          $this->resetAfterTest(true);
  44  
  45          $course  = self::getDataGenerator()->create_course();
  46  
  47          $group1 = array();
  48          $group1['courseid'] = $course->id;
  49          $group1['name'] = 'Group Test 1';
  50          $group1['description'] = 'Group Test 1 description';
  51          $group1['descriptionformat'] = FORMAT_MOODLE;
  52          $group1['enrolmentkey'] = 'Test group enrol secret phrase';
  53          $group2 = array();
  54          $group2['courseid'] = $course->id;
  55          $group2['name'] = 'Group Test 2';
  56          $group2['description'] = 'Group Test 2 description';
  57          $group3 = array();
  58          $group3['courseid'] = $course->id;
  59          $group3['name'] = 'Group Test 3';
  60          $group3['description'] = 'Group Test 3 description';
  61  
  62          // Set the required capabilities by the external function
  63          $context = context_course::instance($course->id);
  64          $roleid = $this->assignUserCapability('moodle/course:managegroups', $context->id);
  65          $this->assignUserCapability('moodle/course:view', $context->id, $roleid);
  66  
  67          // Call the external function.
  68          $groups = core_group_external::create_groups(array($group1, $group2));
  69  
  70          // We need to execute the return values cleaning process to simulate the web service server.
  71          $groups = external_api::clean_returnvalue(core_group_external::create_groups_returns(), $groups);
  72  
  73          // Checks against DB values
  74          $this->assertEquals(2, count($groups));
  75          foreach ($groups as $group) {
  76              $dbgroup = $DB->get_record('groups', array('id' => $group['id']), '*', MUST_EXIST);
  77              switch ($dbgroup->name) {
  78                  case $group1['name']:
  79                      $groupdescription = $group1['description'];
  80                      $groupcourseid = $group1['courseid'];
  81                      $this->assertEquals($dbgroup->descriptionformat, $group1['descriptionformat']);
  82                      $this->assertEquals($dbgroup->enrolmentkey, $group1['enrolmentkey']);
  83                      break;
  84                  case $group2['name']:
  85                      $groupdescription = $group2['description'];
  86                      $groupcourseid = $group2['courseid'];
  87                      break;
  88                  default:
  89                      throw new moodle_exception('unknowgroupname');
  90                      break;
  91              }
  92              $this->assertEquals($dbgroup->description, $groupdescription);
  93              $this->assertEquals($dbgroup->courseid, $groupcourseid);
  94          }
  95  
  96          // Call without required capability
  97          $this->unassignUserCapability('moodle/course:managegroups', $context->id, $roleid);
  98          $this->setExpectedException('required_capability_exception');
  99          $froups = core_group_external::create_groups(array($group3));
 100      }
 101  
 102      /**
 103       * Test get_groups
 104       */
 105      public function test_get_groups() {
 106          global $DB;
 107  
 108          $this->resetAfterTest(true);
 109  
 110          $course = self::getDataGenerator()->create_course();
 111          $group1data = array();
 112          $group1data['courseid'] = $course->id;
 113          $group1data['name'] = 'Group Test 1';
 114          $group1data['description'] = 'Group Test 1 description';
 115          $group1data['descriptionformat'] = FORMAT_MOODLE;
 116          $group1data['enrolmentkey'] = 'Test group enrol secret phrase';
 117          $group2data = array();
 118          $group2data['courseid'] = $course->id;
 119          $group2data['name'] = 'Group Test 2';
 120          $group2data['description'] = 'Group Test 2 description';
 121          $group1 = self::getDataGenerator()->create_group($group1data);
 122          $group2 = self::getDataGenerator()->create_group($group2data);
 123  
 124          // Set the required capabilities by the external function
 125          $context = context_course::instance($course->id);
 126          $roleid = $this->assignUserCapability('moodle/course:managegroups', $context->id);
 127          $this->assignUserCapability('moodle/course:view', $context->id, $roleid);
 128  
 129          // Call the external function.
 130          $groups = core_group_external::get_groups(array($group1->id, $group2->id));
 131  
 132          // We need to execute the return values cleaning process to simulate the web service server.
 133          $groups = external_api::clean_returnvalue(core_group_external::get_groups_returns(), $groups);
 134  
 135          // Checks against DB values
 136          $this->assertEquals(2, count($groups));
 137          foreach ($groups as $group) {
 138              $dbgroup = $DB->get_record('groups', array('id' => $group['id']), '*', MUST_EXIST);
 139              switch ($dbgroup->name) {
 140                  case $group1->name:
 141                      $groupdescription = $group1->description;
 142                      $groupcourseid = $group1->courseid;
 143                      $this->assertEquals($dbgroup->descriptionformat, $group1->descriptionformat);
 144                      $this->assertEquals($dbgroup->enrolmentkey, $group1->enrolmentkey);
 145                      break;
 146                  case $group2->name:
 147                      $groupdescription = $group2->description;
 148                      $groupcourseid = $group2->courseid;
 149                      break;
 150                  default:
 151                      throw new moodle_exception('unknowgroupname');
 152                      break;
 153              }
 154              $this->assertEquals($dbgroup->description, $groupdescription);
 155              $this->assertEquals($dbgroup->courseid, $groupcourseid);
 156          }
 157  
 158          // Call without required capability
 159          $this->unassignUserCapability('moodle/course:managegroups', $context->id, $roleid);
 160          $this->setExpectedException('required_capability_exception');
 161          $groups = core_group_external::get_groups(array($group1->id, $group2->id));
 162      }
 163  
 164      /**
 165       * Test delete_groups
 166       */
 167      public function test_delete_groups() {
 168          global $DB;
 169  
 170          $this->resetAfterTest(true);
 171  
 172          $course = self::getDataGenerator()->create_course();
 173          $group1data = array();
 174          $group1data['courseid'] = $course->id;
 175          $group1data['name'] = 'Group Test 1';
 176          $group1data['description'] = 'Group Test 1 description';
 177          $group1data['descriptionformat'] = FORMAT_MOODLE;
 178          $group1data['enrolmentkey'] = 'Test group enrol secret phrase';
 179          $group2data = array();
 180          $group2data['courseid'] = $course->id;
 181          $group2data['name'] = 'Group Test 2';
 182          $group2data['description'] = 'Group Test 2 description';
 183          $group3data['courseid'] = $course->id;
 184          $group3data['name'] = 'Group Test 3';
 185          $group3data['description'] = 'Group Test 3 description';
 186          $group1 = self::getDataGenerator()->create_group($group1data);
 187          $group2 = self::getDataGenerator()->create_group($group2data);
 188          $group3 = self::getDataGenerator()->create_group($group3data);
 189  
 190          // Set the required capabilities by the external function
 191          $context = context_course::instance($course->id);
 192          $roleid = $this->assignUserCapability('moodle/course:managegroups', $context->id);
 193          $this->assignUserCapability('moodle/course:view', $context->id, $roleid);
 194  
 195          // Checks against DB values
 196          $groupstotal = $DB->count_records('groups', array());
 197          $this->assertEquals(3, $groupstotal);
 198  
 199          // Call the external function.
 200          core_group_external::delete_groups(array($group1->id, $group2->id));
 201  
 202          // Checks against DB values
 203          $groupstotal = $DB->count_records('groups', array());
 204          $this->assertEquals(1, $groupstotal);
 205  
 206          // Call without required capability
 207          $this->unassignUserCapability('moodle/course:managegroups', $context->id, $roleid);
 208          $this->setExpectedException('required_capability_exception');
 209          $froups = core_group_external::delete_groups(array($group3->id));
 210      }
 211  
 212      /**
 213       * Test get_groupings
 214       */
 215      public function test_get_groupings() {
 216          global $DB;
 217  
 218          $this->resetAfterTest(true);
 219  
 220          $course = self::getDataGenerator()->create_course();
 221  
 222          $groupingdata = array();
 223          $groupingdata['courseid'] = $course->id;
 224          $groupingdata['name'] = 'Grouping Test';
 225          $groupingdata['description'] = 'Grouping Test description';
 226          $groupingdata['descriptionformat'] = FORMAT_MOODLE;
 227  
 228          $grouping = self::getDataGenerator()->create_grouping($groupingdata);
 229  
 230          // Set the required capabilities by the external function.
 231          $context = context_course::instance($course->id);
 232          $roleid = $this->assignUserCapability('moodle/course:managegroups', $context->id);
 233          $this->assignUserCapability('moodle/course:view', $context->id, $roleid);
 234  
 235          // Call the external function without specifying the optional parameter.
 236          $groupings = core_group_external::get_groupings(array($grouping->id));
 237          // We need to execute the return values cleaning process to simulate the web service server.
 238          $groupings = external_api::clean_returnvalue(core_group_external::get_groupings_returns(), $groupings);
 239  
 240          $this->assertEquals(1, count($groupings));
 241  
 242          $group1data = array();
 243          $group1data['courseid'] = $course->id;
 244          $group1data['name'] = 'Group Test 1';
 245          $group1data['description'] = 'Group Test 1 description';
 246          $group1data['descriptionformat'] = FORMAT_MOODLE;
 247          $group2data = array();
 248          $group2data['courseid'] = $course->id;
 249          $group2data['name'] = 'Group Test 2';
 250          $group2data['description'] = 'Group Test 2 description';
 251          $group2data['descriptionformat'] = FORMAT_MOODLE;
 252  
 253          $group1 = self::getDataGenerator()->create_group($group1data);
 254          $group2 = self::getDataGenerator()->create_group($group2data);
 255  
 256          groups_assign_grouping($grouping->id, $group1->id);
 257          groups_assign_grouping($grouping->id, $group2->id);
 258  
 259          // Call the external function specifying that groups are returned.
 260          $groupings = core_group_external::get_groupings(array($grouping->id), true);
 261          // We need to execute the return values cleaning process to simulate the web service server.
 262          $groupings = external_api::clean_returnvalue(core_group_external::get_groupings_returns(), $groupings);
 263          $this->assertEquals(1, count($groupings));
 264          $this->assertEquals(2, count($groupings[0]['groups']));
 265          foreach ($groupings[0]['groups'] as $group) {
 266              $dbgroup = $DB->get_record('groups', array('id' => $group['id']), '*', MUST_EXIST);
 267              $dbgroupinggroups = $DB->get_record('groupings_groups',
 268                                                  array('groupingid' => $groupings[0]['id'],
 269                                                        'groupid' => $group['id']),
 270                                                  '*', MUST_EXIST);
 271              switch ($dbgroup->name) {
 272                  case $group1->name:
 273                      $groupdescription = $group1->description;
 274                      $groupcourseid = $group1->courseid;
 275                      break;
 276                  case $group2->name:
 277                      $groupdescription = $group2->description;
 278                      $groupcourseid = $group2->courseid;
 279                      break;
 280                  default:
 281                      throw new moodle_exception('unknowgroupname');
 282                      break;
 283              }
 284              $this->assertEquals($dbgroup->description, $groupdescription);
 285              $this->assertEquals($dbgroup->courseid, $groupcourseid);
 286          }
 287      }
 288  }