[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   * Tests groups subsystems.
  19   *
  20   * @package    core_group
  21   * @category   phpunit
  22   * @copyright  2007 onwards Martin Dougiamas (http://dougiamas.com)
  23   * @author     Andrew Nicols
  24   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  25   */
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  /**
  30   * Unit tests for lib/grouplib.php
  31   * @group core_group
  32   */
  33  class core_grouplib_testcase extends advanced_testcase {
  34  
  35      public function test_groups_get_group_by_idnumber() {
  36          $this->resetAfterTest(true);
  37  
  38          $generator = $this->getDataGenerator();
  39  
  40          // Create a course category and course.
  41          $cat = $generator->create_category(array('parent' => 0));
  42          $course = $generator->create_course(array('category' => $cat->id));
  43  
  44          $idnumber1 = 'idnumber1';
  45          $idnumber2 = 'idnumber2';
  46  
  47          /*
  48           * Test with an empty and a null idnumber.
  49           */
  50          // An empty idnumber should always return a false value.
  51          $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  52          $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  53  
  54          // Even when a group exists which also has an empty idnumber.
  55          $generator->create_group(array('courseid' => $course->id));
  56          $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  57          $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  58  
  59          /*
  60           * Test with a valid idnumber.
  61           */
  62          // There is no matching idnumber at present.
  63          $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber1));
  64  
  65          // We should now have a valid group returned by the idnumber search.
  66          $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber1));
  67          $this->assertEquals($group, groups_get_group_by_idnumber($course->id, $idnumber1));
  68  
  69          // An empty idnumber should still return false.
  70          $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  71          $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  72  
  73          /*
  74           * Test with another idnumber.
  75           */
  76          // There is no matching idnumber at present.
  77          $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber2));
  78  
  79          // We should now have a valid group returned by the idnumber search.
  80          $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber2));
  81          $this->assertEquals($group, groups_get_group_by_idnumber($course->id, $idnumber2));
  82  
  83          /*
  84           * Group idnumbers are unique within a course so test that we don't
  85           * retrieve groups for the first course.
  86           */
  87  
  88          // Create a second course.
  89          $course = $generator->create_course(array('category' => $cat->id));
  90  
  91          // An empty idnumber should always return a false value.
  92          $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  93          $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  94  
  95          // Our existing idnumbers shouldn't be returned here as we're in a different course.
  96          $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber1));
  97          $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber2));
  98  
  99          // We should be able to reuse the idnumbers again since this is a different course.
 100          $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber1));
 101          $this->assertEquals($group, groups_get_group_by_idnumber($course->id, $idnumber1));
 102  
 103          $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 104          $this->assertEquals($group, groups_get_group_by_idnumber($course->id, $idnumber2));
 105      }
 106  
 107      public function test_groups_get_grouping_by_idnumber() {
 108          $this->resetAfterTest(true);
 109  
 110          $generator = $this->getDataGenerator();
 111  
 112          // Create a course category and course.
 113          $cat = $generator->create_category(array('parent' => 0));
 114          $course = $generator->create_course(array('category' => $cat->id));
 115  
 116          $idnumber1 = 'idnumber1';
 117          $idnumber2 = 'idnumber2';
 118  
 119          /*
 120           * Test with an empty and a null idnumber.
 121           */
 122          // An empty idnumber should always return a false value.
 123          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 124          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 125  
 126          // Even when a grouping exists which also has an empty idnumber.
 127          $generator->create_grouping(array('courseid' => $course->id));
 128          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 129          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 130  
 131          /*
 132           * Test with a valid idnumber
 133           */
 134          // There is no matching idnumber at present.
 135          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber1));
 136  
 137          // We should now have a valid group returned by the idnumber search.
 138          $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber1));
 139          $this->assertEquals($grouping, groups_get_grouping_by_idnumber($course->id, $idnumber1));
 140  
 141          // An empty idnumber should still return false.
 142          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 143          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 144  
 145          /*
 146           * Test with another idnumber.
 147           */
 148          // There is no matching idnumber at present.
 149          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber2));
 150  
 151          // We should now have a valid grouping returned by the idnumber search.
 152          $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 153          $this->assertEquals($grouping, groups_get_grouping_by_idnumber($course->id, $idnumber2));
 154  
 155          /*
 156           * Grouping idnumbers are unique within a course so test that we don't
 157           * retrieve groupings for the first course.
 158           */
 159  
 160          // Create a second course.
 161          $course = $generator->create_course(array('category' => $cat->id));
 162  
 163          // An empty idnumber should always return a false value.
 164          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 165          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 166  
 167          // Our existing idnumbers shouldn't be returned here as we're in a different course.
 168          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber1));
 169          $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber2));
 170  
 171          // We should be able to reuse the idnumbers again since this is a different course.
 172          $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber1));
 173          $this->assertEquals($grouping, groups_get_grouping_by_idnumber($course->id, $idnumber1));
 174  
 175          $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 176          $this->assertEquals($grouping, groups_get_grouping_by_idnumber($course->id, $idnumber2));
 177      }
 178  
 179      public function test_groups_get_group_by_name() {
 180          $this->resetAfterTest(true);
 181  
 182          $generator = $this->getDataGenerator();
 183  
 184          // Create a course category and course.
 185          $cat = $generator->create_category(array('parent' => 0));
 186          $course = $generator->create_course(array('category' => $cat->id));
 187  
 188          $name1 = 'Name 1';
 189          $name2 = 'Name 2';
 190  
 191          // Test with an empty and a null idnumber.
 192          $this->assertFalse(groups_get_group_by_name($course->id, ''));
 193          $this->assertFalse(groups_get_group_by_name($course->id, null));
 194  
 195          // Even when a group exists.
 196          $generator->create_group(array('courseid' => $course->id));
 197          $this->assertFalse(groups_get_group_by_name($course->id, ''));
 198          $this->assertFalse(groups_get_group_by_name($course->id, null));
 199  
 200          // Test with a valid name, but one that doesn't exist yet.
 201          $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 202          $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 203  
 204          // We should now have a valid group returned by the name search.
 205          $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 206          $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 207          $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 208  
 209          // We should now have a two valid groups returned by the name search.
 210          $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 211          $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 212          $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 213  
 214          // Delete a group.
 215          $this->assertTrue(groups_delete_group($group1));
 216          $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 217          $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 218  
 219          /*
 220           * Group idnumbers are unique within a course so test that we don't
 221           * retrieve groups for the first course.
 222           */
 223  
 224          // Create a second course.
 225          $course = $generator->create_course(array('category' => $cat->id));
 226  
 227          // An empty name should always return a false value.
 228          $this->assertFalse(groups_get_group_by_name($course->id, ''));
 229          $this->assertFalse(groups_get_group_by_name($course->id, null));
 230  
 231          // Our existing names shouldn't be returned here as we're in a different course.
 232          $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 233          $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 234  
 235          // We should be able to reuse the idnumbers again since this is a different course.
 236          $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 237          $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 238  
 239          $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 240          $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 241      }
 242  
 243      public function test_groups_get_grouping() {
 244          $this->resetAfterTest(true);
 245  
 246          $generator = $this->getDataGenerator();
 247  
 248          // Create a course category and course.
 249          $cat = $generator->create_category(array('parent' => 0));
 250          $course = $generator->create_course(array('category' => $cat->id));
 251  
 252          $name1 = 'Grouping 1';
 253          $name2 = 'Grouping 2';
 254  
 255          // Test with an empty and a null idnumber.
 256          $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 257          $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 258  
 259          // Even when a group exists.
 260          $generator->create_group(array('courseid' => $course->id));
 261          $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 262          $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 263  
 264          // Test with a valid name, but one that doesn't exist yet.
 265          $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 266          $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 267  
 268          // We should now have a valid group returned by the name search.
 269          $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 270          $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 271          $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 272  
 273          // We should now have a two valid groups returned by the name search.
 274          $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 275          $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 276          $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 277  
 278          // Delete a group.
 279          $this->assertTrue(groups_delete_grouping($group1));
 280          $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 281          $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 282  
 283          /*
 284           * Group idnumbers are unique within a course so test that we don't
 285           * retrieve groups for the first course.
 286           */
 287  
 288          // Create a second course.
 289          $course = $generator->create_course(array('category' => $cat->id));
 290  
 291          // An empty name should always return a false value.
 292          $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 293          $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 294  
 295          // Our existing names shouldn't be returned here as we're in a different course.
 296          $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 297          $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 298  
 299          // We should be able to reuse the idnumbers again since this is a different course.
 300          $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 301          $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 302  
 303          $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 304          $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 305      }
 306  
 307      public function test_groups_get_course_data() {
 308          $this->resetAfterTest(true);
 309  
 310          $generator = $this->getDataGenerator();
 311  
 312          // Create a course category and course.
 313          $cat = $generator->create_category(array('parent' => 0));
 314          $course = $generator->create_course(array('category' => $cat->id));
 315          $grouping1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 1'));
 316          $grouping2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 2'));
 317          $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 318          $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 319          $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 320          $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 321  
 322          // Assign the groups to groupings.
 323          $this->assertTrue(groups_assign_grouping($grouping1->id, $group1->id));
 324          $this->assertTrue(groups_assign_grouping($grouping1->id, $group2->id));
 325          $this->assertTrue(groups_assign_grouping($grouping2->id, $group3->id));
 326          $this->assertTrue(groups_assign_grouping($grouping2->id, $group4->id));
 327  
 328          // Get the data.
 329          $data = groups_get_course_data($course->id);
 330          $this->assertInstanceOf('stdClass', $data);
 331          $this->assertObjectHasAttribute('groups', $data);
 332          $this->assertObjectHasAttribute('groupings', $data);
 333          $this->assertObjectHasAttribute('mappings', $data);
 334  
 335          // Test we have the expected items returns.
 336          $this->assertCount(4, $data->groups);
 337          $this->assertCount(2, $data->groupings);
 338          $this->assertCount(4, $data->mappings);
 339  
 340          // Check we have the expected groups.
 341          $this->assertArrayHasKey($group1->id, $data->groups);
 342          $this->assertArrayHasKey($group2->id, $data->groups);
 343          $this->assertArrayHasKey($group3->id, $data->groups);
 344          $this->assertArrayHasKey($group4->id, $data->groups);
 345  
 346          // Test a group-id is mapped correctly.
 347          $this->assertSame($group3->name, $data->groups[$group3->id]->name);
 348  
 349          // Check we have the expected number of groupings.
 350          $this->assertContains($grouping1->id, array_keys($data->groupings));
 351          $this->assertContains($grouping2->id, array_keys($data->groupings));
 352  
 353          // Test a grouping-id is mapped correctly.
 354          $this->assertEquals($grouping2->name, $data->groupings[$grouping2->id]->name);
 355  
 356          // Test that all of the mappings are correct.
 357          $grouping1maps = 0;
 358          $grouping2maps = 0;
 359          $group1maps = 0;
 360          $group2maps = 0;
 361          $group3maps = 0;
 362          $group4maps = 0;
 363          foreach ($data->mappings as $mapping) {
 364              if ($mapping->groupingid === $grouping1->id) {
 365                  $grouping1maps++;
 366                  $this->assertContains($mapping->groupid, array($group1->id, $group2->id));
 367              } else if ($mapping->groupingid === $grouping2->id) {
 368                  $grouping2maps++;
 369                  $this->assertContains($mapping->groupid, array($group3->id, $group4->id));
 370              } else {
 371                  $this->fail('Unexpected groupingid');
 372              }
 373              switch ($mapping->groupid) {
 374                  case $group1->id : $group1maps++; break;
 375                  case $group2->id : $group2maps++; break;
 376                  case $group3->id : $group3maps++; break;
 377                  case $group4->id : $group4maps++; break;
 378              }
 379          }
 380          $this->assertEquals(2, $grouping1maps);
 381          $this->assertEquals(2, $grouping2maps);
 382          $this->assertEquals(1, $group1maps);
 383          $this->assertEquals(1, $group2maps);
 384          $this->assertEquals(1, $group3maps);
 385          $this->assertEquals(1, $group4maps);
 386  
 387          // Test the groups_get_all_groups which uses this functionality.
 388          $groups  = groups_get_all_groups($course->id);
 389          $groupkeys = array_keys($groups);
 390          $this->assertCount(4, $groups);
 391          $this->assertContains($group1->id, $groupkeys);
 392          $this->assertContains($group2->id, $groupkeys);
 393          $this->assertContains($group3->id, $groupkeys);
 394          $this->assertContains($group4->id, $groupkeys);
 395  
 396          $groups  = groups_get_all_groups($course->id, null, $grouping1->id);
 397          $groupkeys = array_keys($groups);
 398          $this->assertCount(2, $groups);
 399          $this->assertContains($group1->id, $groupkeys);
 400          $this->assertContains($group2->id, $groupkeys);
 401          $this->assertNotContains($group3->id, $groupkeys);
 402          $this->assertNotContains($group4->id, $groupkeys);
 403  
 404          $groups  = groups_get_all_groups($course->id, null, $grouping2->id);
 405          $groupkeys = array_keys($groups);
 406          $this->assertCount(2, $groups);
 407          $this->assertNotContains($group1->id, $groupkeys);
 408          $this->assertNotContains($group2->id, $groupkeys);
 409          $this->assertContains($group3->id, $groupkeys);
 410          $this->assertContains($group4->id, $groupkeys);
 411  
 412          // Test this function using an alternate column for the result index
 413          $groups  = groups_get_all_groups($course->id, null, $grouping2->id, 'g.name, g.id');
 414          $groupkeys = array_keys($groups);
 415          $this->assertCount(2, $groups);
 416          $this->assertNotContains($group3->id, $groupkeys);
 417          $this->assertContains($group3->name, $groupkeys);
 418          $this->assertEquals($group3->id, $groups[$group3->name]->id);
 419      }
 420  
 421      /**
 422       * Tests for groups_group_visible.
 423       */
 424      public function test_groups_group_visible() {
 425          global $CFG, $DB;
 426  
 427          $generator = $this->getDataGenerator();
 428          $this->resetAfterTest();
 429          $this->setAdminUser();
 430  
 431          // Create a course category, course and groups.
 432          $cat = $generator->create_category(array('parent' => 0));
 433          $course = $generator->create_course(array('category' => $cat->id));
 434          $coursecontext = context_course::instance($course->id);
 435          $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 436          $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 437          $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 438          $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 439  
 440          // Create cm.
 441          $assign = $generator->create_module("assign", array('course' => $course->id));
 442          $cm = get_coursemodule_from_instance("assign", $assign->id);
 443  
 444          // Create users.
 445          $user1 = $generator->create_user();
 446          $user2 = $generator->create_user();
 447          $user3 = $generator->create_user();
 448  
 449          // Enrol users into the course.
 450          $generator->enrol_user($user1->id, $course->id);
 451          $generator->enrol_user($user2->id, $course->id);
 452  
 453          // Assign groups.
 454          groups_add_member($group1, $user2);
 455  
 456          // Give capability at course level to the user to access all groups.
 457          $role = $DB->get_field("role", "id", array("shortname" => "manager"));
 458          $generator->enrol_user($user3->id, $course->id, $role);
 459          // Make sure the user has the capability.
 460          assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $role, $coursecontext->id);
 461  
 462          // No groups , not forced.
 463          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 464          $this->assertTrue($result);
 465          $result = groups_group_visible(0, $course, null, $user1->id);
 466          $this->assertTrue($result); // Requesting all groups.
 467  
 468          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 469          $this->assertTrue($result); // Cm with no groups.
 470  
 471          $cm->groupmode = SEPARATEGROUPS;
 472          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 473          $this->assertFalse($result); // Cm with separate groups.
 474          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 475          $this->assertTrue($result); // Cm with separate groups.
 476  
 477          $cm->groupmode = VISIBLEGROUPS;
 478          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 479          $this->assertTrue($result); // Cm with visible groups.
 480  
 481          // No groups, forced.
 482          $course->groupmode = NOGROUPS;
 483          $course->groupmodeforce = true;
 484          update_course($course);
 485          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 486          $this->assertTrue($result);
 487          $result = groups_group_visible(0, $course, null, $user1->id);
 488          $this->assertTrue($result); // Requesting all groups.
 489  
 490          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 491          $this->assertTrue($result); // Cm with no groups.
 492  
 493          $cm->groupmode = SEPARATEGROUPS;
 494          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 495          $this->assertTrue($result); // Cm with separate groups.
 496          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 497          $this->assertTrue($result); // Cm with separate groups.
 498  
 499          $cm->groupmode = SEPARATEGROUPS;
 500          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 501          $this->assertTrue($result); // Cm with visible groups.
 502  
 503          // Visible groups, forced.
 504          $course->groupmode = VISIBLEGROUPS;
 505          $course->groupmodeforce = true;
 506          update_course($course);
 507          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 508          $this->assertTrue($result);
 509          $result = groups_group_visible(0, $course, null, $user1->id);
 510          $this->assertTrue($result); // Requesting all groups.
 511  
 512          $cm->groupmode = NOGROUPS;
 513          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 514          $this->assertTrue($result); // Cm with no groups.
 515  
 516          $cm->groupmode = SEPARATEGROUPS;
 517          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 518          $this->assertTrue($result); // Cm with separate groups.
 519          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 520          $this->assertTrue($result); // Cm with separate groups.
 521  
 522          $cm->groupmode = VISIBLEGROUPS;
 523          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 524          $this->assertTrue($result); // Cm with visible groups.
 525  
 526          // Visible groups, not forced.
 527          $course->groupmode = VISIBLEGROUPS;
 528          $course->groupmodeforce = false;
 529          update_course($course);
 530          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 531          $this->assertTrue($result);
 532          $result = groups_group_visible(0, $course, null, $user1->id);
 533          $this->assertTrue($result); // Requesting all groups.
 534  
 535          $cm->groupmode = NOGROUPS;
 536          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 537          $this->assertTrue($result); // Cm with no groups.
 538  
 539          $cm->groupmode = SEPARATEGROUPS;
 540          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 541          $this->assertFalse($result); // Cm with separate groups.
 542          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 543          $this->assertTrue($result); // Cm with separate groups.
 544  
 545          $cm->groupmode = VISIBLEGROUPS;
 546          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 547          $this->assertTrue($result); // Cm with visible groups.
 548  
 549          // Separate groups, forced.
 550          $course->groupmode = SEPARATEGROUPS;
 551          $course->groupmodeforce = true;
 552          update_course($course);
 553          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 554          $this->assertFalse($result);
 555          $result = groups_group_visible($group1->id, $course, null, $user2->id);
 556          $this->assertTrue($result);
 557          $result = groups_group_visible(0, $course, null, $user2->id);
 558          $this->assertFalse($result); // Requesting all groups.
 559          $result = groups_group_visible(0, $course, null, $user3->id);
 560          $this->assertTrue($result); // Requesting all groups.
 561          $result = groups_group_visible($group1->id, $course, null, $user3->id);
 562          $this->assertTrue($result); // Make sure user with access to all groups can see any group.
 563  
 564          $cm->groupmode = NOGROUPS;
 565          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 566          $this->assertFalse($result); // Cm with no groups.
 567  
 568          $cm->groupmode = SEPARATEGROUPS;
 569          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 570          $this->assertFalse($result); // Cm with separate groups.
 571          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 572          $this->assertTrue($result); // Cm with separate groups.
 573          $result = groups_group_visible($group1->id, $course, $cm, $user3->id);
 574          $this->assertTrue($result); // Make sure user with access to all groups can see any group.
 575  
 576          $cm->groupmode = VISIBLEGROUPS;
 577          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 578          $this->assertFalse($result); // Cm with visible groups.
 579  
 580          // Separate groups, not forced.
 581          $course->groupmode = SEPARATEGROUPS;
 582          $course->groupmodeforce = false;
 583          update_course($course);
 584          $result = groups_group_visible($group1->id, $course, null, $user1->id);
 585          $this->assertFalse($result);
 586          $result = groups_group_visible($group1->id, $course, null, $user2->id);
 587          $this->assertTrue($result);
 588          $result = groups_group_visible(0, $course, null, $user2->id);
 589          $this->assertFalse($result); // Requesting all groups.
 590          $result = groups_group_visible(0, $course, null, $user3->id);
 591          $this->assertTrue($result); // Requesting all groups.
 592  
 593          $cm->groupmode = NOGROUPS;
 594          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 595          $this->assertTrue($result); // Cm with no groups.
 596  
 597          $cm->groupmode = SEPARATEGROUPS;
 598          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 599          $this->assertFalse($result); // Cm with separate groups.
 600          $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 601          $this->assertTrue($result); // Cm with separate groups.
 602  
 603          $cm->groupmode = VISIBLEGROUPS;
 604          $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 605          $this->assertTrue($result); // Cm with visible groups.
 606      }
 607  
 608      function test_groups_get_groupmode() {
 609          global $DB;
 610          $generator = $this->getDataGenerator();
 611          $this->resetAfterTest();
 612          $this->setAdminUser();
 613  
 614          // Create a course with no groups forcing.
 615          $course1 = $generator->create_course();
 616  
 617          // Create cm1 with no groups, cm1 with visible groups, cm2 with separate groups and cm3 with visible groups.
 618          $assign1 = $generator->create_module("assign", array('course' => $course1->id));
 619          $assign2 = $generator->create_module("assign", array('course' => $course1->id),
 620                  array('groupmode' => SEPARATEGROUPS));
 621          $assign3 = $generator->create_module("assign", array('course' => $course1->id),
 622                  array('groupmode' => VISIBLEGROUPS));
 623  
 624          // Request data for tests.
 625          $cm1 = get_coursemodule_from_instance("assign", $assign1->id);
 626          $cm2 = get_coursemodule_from_instance("assign", $assign2->id);
 627          $cm3 = get_coursemodule_from_instance("assign", $assign3->id);
 628          $modinfo = get_fast_modinfo($course1->id);
 629  
 630          // Assert that any method of getting activity groupmode returns the correct result.
 631          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1));
 632          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1, $course1));
 633          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 634          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 635          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 636          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 637          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3));
 638          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 639          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 640  
 641          // Update the course set the groupmode SEPARATEGROUPS but not forced.
 642          update_course((object)array('id' => $course1->id, 'groupmode' => SEPARATEGROUPS));
 643          // Re-request the data from DB.
 644          $course1 = $DB->get_record('course', array('id' => $course1->id));
 645          $modinfo = get_fast_modinfo($course1->id);
 646  
 647          // Existing activities are not changed.
 648          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1));
 649          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1, $course1));
 650          $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 651          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 652          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 653          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 654          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3));
 655          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 656          $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 657  
 658          // Update the course set the groupmode SEPARATEGROUPS and forced.
 659          update_course((object)array('id' => $course1->id, 'groupmode' => SEPARATEGROUPS, 'groupmodeforce' => true));
 660          // Re-request the data from DB.
 661          $course1 = $DB->get_record('course', array('id' => $course1->id));
 662          $modinfo = get_fast_modinfo($course1->id);
 663  
 664          // Make sure all activities have separate groups mode now.
 665          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm1));
 666          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm1, $course1));
 667          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 668          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 669          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 670          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 671          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm3));
 672          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 673          $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 674      }
 675  
 676      /**
 677       * Tests for groups_allgroups_course_menu() .
 678       */
 679      public function test_groups_allgroups_course_menu() {
 680          global $SESSION;
 681  
 682          $this->resetAfterTest();
 683  
 684          // Generate data.
 685          $course = $this->getDataGenerator()->create_course();
 686          $record = new stdClass();
 687          $record->courseid = $course->id;
 688          $group1 = $this->getDataGenerator()->create_group($record);
 689          $group2 = $this->getDataGenerator()->create_group($record);
 690          $user = $this->getDataGenerator()->create_user();
 691          $this->getDataGenerator()->enrol_user($user->id, $course->id);
 692          $this->setUser($user);
 693  
 694          $html = groups_allgroups_course_menu($course, 'someurl.php');
 695          // Since user is not a part of this group and doesn't have accessallgroups permission,
 696          // the html should be empty.
 697          $this->assertEmpty($html);
 698  
 699          groups_add_member($group1->id, $user);
 700          // Now user can access one of the group. We can't assert an exact match here because of random ids generated by yui. So do
 701          // partial match to see if all groups are listed or not.
 702          $html = groups_allgroups_course_menu($course, 'someurl.php');
 703          $this->assertContains(format_string($group1->name), $html);
 704          $this->assertNotContains(format_string($group2->name), $html);
 705  
 706          $this->setAdminUser();
 707  
 708          // Now user can access everything.
 709          $html = groups_allgroups_course_menu($course, 'someurl.php');
 710          $this->assertContains(format_string($group1->name), $html);
 711          $this->assertContains(format_string($group2->name), $html);
 712  
 713          // Make sure separate groups mode, doesn't change anything.
 714          $course->groupmode = SEPARATEGROUPS;
 715          update_course($course);
 716          $html = groups_allgroups_course_menu($course, 'someurl.php');
 717          $this->assertContains(format_string($group1->name), $html);
 718          $this->assertContains(format_string($group2->name), $html);
 719  
 720          // Make sure Visible groups mode, doesn't change anything.
 721          $course->groupmode = VISIBLEGROUPS;
 722          update_course($course);
 723          $html = groups_allgroups_course_menu($course, 'someurl.php');
 724          $this->assertContains(format_string($group1->name), $html);
 725          $this->assertContains(format_string($group2->name), $html);
 726  
 727          // Let us test activegroup changes now.
 728          $this->setUser($user);
 729          $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid] = 5;
 730          groups_allgroups_course_menu($course, 'someurl.php', false); // Do not update session.
 731          $this->assertSame(5, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 732          groups_allgroups_course_menu($course, 'someurl.php', true, $group1->id); // Update session.
 733          $this->assertSame($group1->id, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 734          // Try to update session with an invalid groupid. It should not accept the invalid id.
 735          groups_allgroups_course_menu($course, 'someurl.php', true, 256);
 736          $this->assertEquals($group1->id, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 737      }
 738  
 739      /**
 740       * This unit test checks that groups_get_all_groups returns groups in
 741       * alphabetical order even if they are in a grouping.
 742       */
 743      public function test_groups_ordering() {
 744          $generator = $this->getDataGenerator();
 745          $this->resetAfterTest();
 746  
 747          // Create a course category and course.
 748          $cat = $generator->create_category(array('parent' => 0));
 749          $course = $generator->create_course(array('category' => $cat->id));
 750          $grouping = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping'));
 751  
 752          // Create groups in reverse order.
 753          $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 754          $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 755  
 756          // Assign the groups to the grouping in reverse order.
 757          $this->assertTrue(groups_assign_grouping($grouping->id, $group2->id));
 758          $this->assertTrue(groups_assign_grouping($grouping->id, $group1->id));
 759  
 760          // Get all groups and check they are alphabetical.
 761          $groups = array_values(groups_get_all_groups($course->id, 0));
 762          $this->assertEquals('Group 1', $groups[0]->name);
 763          $this->assertEquals('Group 2', $groups[1]->name);
 764  
 765          // Now check the same is true when accessed by grouping.
 766          $groups = array_values(groups_get_all_groups($course->id, 0, $grouping->id));
 767          $this->assertEquals('Group 1', $groups[0]->name);
 768          $this->assertEquals('Group 2', $groups[1]->name);
 769      }
 770  
 771      /**
 772       * Tests for groups_get_user_groups() method.
 773       */
 774      public function test_groups_get_user_groups() {
 775          $this->resetAfterTest(true);
 776          $generator = $this->getDataGenerator();
 777  
 778          // Create courses.
 779          $course1 = $generator->create_course();
 780          $course2 = $generator->create_course();
 781  
 782          // Create users.
 783          $user1 = $generator->create_user();
 784          $user2 = $generator->create_user();
 785          $user3 = $generator->create_user();
 786  
 787          // Enrol users.
 788          $generator->enrol_user($user1->id, $course1->id);
 789          $generator->enrol_user($user1->id, $course2->id);
 790          $generator->enrol_user($user2->id, $course2->id);
 791          $generator->enrol_user($user3->id, $course2->id);
 792  
 793          // Create groups.
 794          $group1 = $generator->create_group(array('courseid' => $course1->id));
 795          $group2 = $generator->create_group(array('courseid' => $course2->id));
 796          $group3 = $generator->create_group(array('courseid' => $course2->id));
 797  
 798          // Assign users to groups.
 799          $this->assertTrue($generator->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id)));
 800          $this->assertTrue($generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user2->id)));
 801  
 802          // Get user groups.
 803          $usergroups1 = groups_get_user_groups($course1->id, $user1->id);
 804          $usergroups2 = groups_get_user_groups($course2->id, $user2->id);;
 805  
 806          // Assert return data.
 807          $this->assertEquals($group1->id, $usergroups1[0][0]);
 808          $this->assertEquals($group2->id, $usergroups2[0][0]);
 809  
 810          // Now, test with groupings.
 811          $grouping1 = $generator->create_grouping(array('courseid' => $course1->id));
 812          $grouping2 = $generator->create_grouping(array('courseid' => $course2->id));
 813  
 814          // Assign the groups to grouping.
 815          groups_assign_grouping($grouping1->id, $group1->id);
 816          groups_assign_grouping($grouping2->id, $group2->id);
 817          groups_assign_grouping($grouping2->id, $group3->id);
 818  
 819          // Test with grouping.
 820          $usergroups1 = groups_get_user_groups($course1->id, $user1->id);
 821          $usergroups2 = groups_get_user_groups($course2->id, $user2->id);
 822          $this->assertArrayHasKey($grouping1->id, $usergroups1);
 823          $this->assertArrayHasKey($grouping2->id, $usergroups2);
 824  
 825          // Test user without a group.
 826          $usergroups1 = groups_get_user_groups($course2->id, $user3->id);
 827          $this->assertCount(0, $usergroups1[0]);
 828  
 829          // Test with userid = 0.
 830          $usergroups1 = groups_get_user_groups($course1->id, 0);
 831          $usergroups2 = groups_get_user_groups($course2->id, 0);
 832          $this->assertCount(0, $usergroups1[0]);
 833          $this->assertCount(0, $usergroups2[0]);
 834  
 835          // Test with courseid = 0.
 836          $usergroups1 = groups_get_user_groups(0, $user1->id);
 837          $usergroups2 = groups_get_user_groups(0, $user2->id);
 838          $this->assertCount(0, $usergroups1[0]);
 839          $this->assertCount(0, $usergroups2[0]);
 840      }
 841  }