lib/tests/grouplib_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  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
 180     public function test_groups_get_members_ids_sql() {
 181         global $DB;
 182
 183         $this->resetAfterTest(true);
 184
 185         $generator = $this->getDataGenerator();
 186
 187         $course = $generator->create_course();
 188         $student = $generator->create_user();
 189         $plugin = enrol_get_plugin('manual');
 190         $role = $DB->get_record('role', array('shortname' => 'student'));
 191         $group = $generator->create_group(array('courseid' => $course->id));
 192         $instance = $DB->get_record('enrol', array(
 193                 'courseid' => $course->id,
 194                 'enrol' => 'manual',
 195         ));
 196
 197         $this->assertNotEquals($instance, false);
 198
 199         // Enrol the user in the course.
 200         $plugin->enrol_user($instance, $student->id, $role->id);
 201
 202         list($sql, $params) = groups_get_members_ids_sql($group->id, true);
 203
 204         // Test an empty group.
 205         $users = $DB->get_records_sql($sql, $params);
 206
 207         $this->assertFalse(array_key_exists($student->id, $users));
 208         groups_add_member($group->id, $student->id);
 209
 210         // Test with a group member.
 211         $users = $DB->get_records_sql($sql, $params);
 212         $this->assertTrue(array_key_exists($student->id, $users));
 213     }
 214
 215     public function test_groups_get_group_by_name() {
 216         $this->resetAfterTest(true);
 217
 218         $generator = $this->getDataGenerator();
 219
 220         // Create a course category and course.
 221         $cat = $generator->create_category(array('parent' => 0));
 222         $course = $generator->create_course(array('category' => $cat->id));
 223
 224         $name1 = 'Name 1';
 225         $name2 = 'Name 2';
 226
 227         // Test with an empty and a null idnumber.
 228         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 229         $this->assertFalse(groups_get_group_by_name($course->id, null));
 230
 231         // Even when a group exists.
 232         $generator->create_group(array('courseid' => $course->id));
 233         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 234         $this->assertFalse(groups_get_group_by_name($course->id, null));
 235
 236         // Test with a valid name, but one that doesn't exist yet.
 237         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 238         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 239
 240         // We should now have a valid group returned by the name search.
 241         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 242         $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 243         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 244
 245         // We should now have a two valid groups returned by the name search.
 246         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 247         $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 248         $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 249
 250         // Delete a group.
 251         $this->assertTrue(groups_delete_group($group1));
 252         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 253         $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 254
 255         /*
 256          * Group idnumbers are unique within a course so test that we don't
 257          * retrieve groups for the first course.
 258          */
 259
 260         // Create a second course.
 261         $course = $generator->create_course(array('category' => $cat->id));
 262
 263         // An empty name should always return a false value.
 264         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 265         $this->assertFalse(groups_get_group_by_name($course->id, null));
 266
 267         // Our existing names shouldn't be returned here as we're in a different course.
 268         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 269         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 270
 271         // We should be able to reuse the idnumbers again since this is a different course.
 272         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 273         $this->assertEquals($group1->id, groups_get_group_by_name($course->id, $name1));
 274
 275         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 276         $this->assertEquals($group2->id, groups_get_group_by_name($course->id, $name2));
 277     }
 278
 279     public function test_groups_get_grouping() {
 280         $this->resetAfterTest(true);
 281
 282         $generator = $this->getDataGenerator();
 283
 284         // Create a course category and course.
 285         $cat = $generator->create_category(array('parent' => 0));
 286         $course = $generator->create_course(array('category' => $cat->id));
 287
 288         $name1 = 'Grouping 1';
 289         $name2 = 'Grouping 2';
 290
 291         // Test with an empty and a null idnumber.
 292         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 293         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 294
 295         // Even when a group exists.
 296         $generator->create_group(array('courseid' => $course->id));
 297         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 298         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 299
 300         // Test with a valid name, but one that doesn't exist yet.
 301         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 302         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 303
 304         // We should now have a valid group returned by the name search.
 305         $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 306         $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 307         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 308
 309         // We should now have a two valid groups returned by the name search.
 310         $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 311         $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 312         $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 313
 314         // Delete a group.
 315         $this->assertTrue(groups_delete_grouping($group1));
 316         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 317         $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 318
 319         /*
 320          * Group idnumbers are unique within a course so test that we don't
 321          * retrieve groups for the first course.
 322          */
 323
 324         // Create a second course.
 325         $course = $generator->create_course(array('category' => $cat->id));
 326
 327         // An empty name should always return a false value.
 328         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 329         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 330
 331         // Our existing names shouldn't be returned here as we're in a different course.
 332         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 333         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 334
 335         // We should be able to reuse the idnumbers again since this is a different course.
 336         $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 337         $this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
 338
 339         $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 340         $this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
 341     }
 342
 343     public function test_groups_get_course_data() {
 344         $this->resetAfterTest(true);
 345
 346         $generator = $this->getDataGenerator();
 347
 348         // Create a course category and course.
 349         $cat = $generator->create_category(array('parent' => 0));
 350         $course = $generator->create_course(array('category' => $cat->id));
 351         $grouping1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 1'));
 352         $grouping2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 2'));
 353         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 354         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 355         $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 356         $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 357
 358         // Assign the groups to groupings.
 359         $this->assertTrue(groups_assign_grouping($grouping1->id, $group1->id));
 360         $this->assertTrue(groups_assign_grouping($grouping1->id, $group2->id));
 361         $this->assertTrue(groups_assign_grouping($grouping2->id, $group3->id));
 362         $this->assertTrue(groups_assign_grouping($grouping2->id, $group4->id));
 363
 364         // Get the data.
 365         $data = groups_get_course_data($course->id);
 366         $this->assertInstanceOf('stdClass', $data);
 367         $this->assertObjectHasAttribute('groups', $data);
 368         $this->assertObjectHasAttribute('groupings', $data);
 369         $this->assertObjectHasAttribute('mappings', $data);
 370
 371         // Test we have the expected items returns.
 372         $this->assertCount(4, $data->groups);
 373         $this->assertCount(2, $data->groupings);
 374         $this->assertCount(4, $data->mappings);
 375
 376         // Check we have the expected groups.
 377         $this->assertArrayHasKey($group1->id, $data->groups);
 378         $this->assertArrayHasKey($group2->id, $data->groups);
 379         $this->assertArrayHasKey($group3->id, $data->groups);
 380         $this->assertArrayHasKey($group4->id, $data->groups);
 381
 382         // Test a group-id is mapped correctly.
 383         $this->assertSame($group3->name, $data->groups[$group3->id]->name);
 384
 385         // Check we have the expected number of groupings.
 386         $this->assertContains($grouping1->id, array_keys($data->groupings));
 387         $this->assertContains($grouping2->id, array_keys($data->groupings));
 388
 389         // Test a grouping-id is mapped correctly.
 390         $this->assertEquals($grouping2->name, $data->groupings[$grouping2->id]->name);
 391
 392         // Test that all of the mappings are correct.
 393         $grouping1maps = 0;
 394         $grouping2maps = 0;
 395         $group1maps = 0;
 396         $group2maps = 0;
 397         $group3maps = 0;
 398         $group4maps = 0;
 399         foreach ($data->mappings as $mapping) {
 400             if ($mapping->groupingid === $grouping1->id) {
 401                 $grouping1maps++;
 402                 $this->assertContains($mapping->groupid, array($group1->id, $group2->id));
 403             } else if ($mapping->groupingid === $grouping2->id) {
 404                 $grouping2maps++;
 405                 $this->assertContains($mapping->groupid, array($group3->id, $group4->id));
 406             } else {
 407                 $this->fail('Unexpected groupingid');
 408             }
 409             switch ($mapping->groupid) {
 410                 case $group1->id : $group1maps++; break;
 411                 case $group2->id : $group2maps++; break;
 412                 case $group3->id : $group3maps++; break;
 413                 case $group4->id : $group4maps++; break;
 414             }
 415         }
 416         $this->assertEquals(2, $grouping1maps);
 417         $this->assertEquals(2, $grouping2maps);
 418         $this->assertEquals(1, $group1maps);
 419         $this->assertEquals(1, $group2maps);
 420         $this->assertEquals(1, $group3maps);
 421         $this->assertEquals(1, $group4maps);
 422
 423         // Test the groups_get_all_groups which uses this functionality.
 424         $groups  = groups_get_all_groups($course->id);
 425         $groupkeys = array_keys($groups);
 426         $this->assertCount(4, $groups);
 427         $this->assertContains($group1->id, $groupkeys);
 428         $this->assertContains($group2->id, $groupkeys);
 429         $this->assertContains($group3->id, $groupkeys);
 430         $this->assertContains($group4->id, $groupkeys);
 431
 432         $groups  = groups_get_all_groups($course->id, null, $grouping1->id);
 433         $groupkeys = array_keys($groups);
 434         $this->assertCount(2, $groups);
 435         $this->assertContains($group1->id, $groupkeys);
 436         $this->assertContains($group2->id, $groupkeys);
 437         $this->assertNotContains($group3->id, $groupkeys);
 438         $this->assertNotContains($group4->id, $groupkeys);
 439
 440         $groups  = groups_get_all_groups($course->id, null, $grouping2->id);
 441         $groupkeys = array_keys($groups);
 442         $this->assertCount(2, $groups);
 443         $this->assertNotContains($group1->id, $groupkeys);
 444         $this->assertNotContains($group2->id, $groupkeys);
 445         $this->assertContains($group3->id, $groupkeys);
 446         $this->assertContains($group4->id, $groupkeys);
 447
 448         // Test this function using an alternate column for the result index
 449         $groups  = groups_get_all_groups($course->id, null, $grouping2->id, 'g.name, g.id');
 450         $groupkeys = array_keys($groups);
 451         $this->assertCount(2, $groups);
 452         $this->assertNotContains($group3->id, $groupkeys);
 453         $this->assertContains($group3->name, $groupkeys);
 454         $this->assertEquals($group3->id, $groups[$group3->name]->id);
 455     }
 456
 457     /**
 458      * Tests for groups_group_visible.
 459      */
 460     public function test_groups_group_visible() {
 461         global $CFG, $DB;
 462
 463         $generator = $this->getDataGenerator();
 464         $this->resetAfterTest();
 465         $this->setAdminUser();
 466
 467         // Create a course category, course and groups.
 468         $cat = $generator->create_category(array('parent' => 0));
 469         $course = $generator->create_course(array('category' => $cat->id));
 470         $coursecontext = context_course::instance($course->id);
 471         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 472         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 473         $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 474         $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 475
 476         // Create cm.
 477         $assign = $generator->create_module("assign", array('course' => $course->id));
 478         $cm = get_coursemodule_from_instance("assign", $assign->id);
 479
 480         // Create users.
 481         $user1 = $generator->create_user();
 482         $user2 = $generator->create_user();
 483         $user3 = $generator->create_user();
 484
 485         // Enrol users into the course.
 486         $generator->enrol_user($user1->id, $course->id);
 487         $generator->enrol_user($user2->id, $course->id);
 488
 489         // Assign groups.
 490         groups_add_member($group1, $user2);
 491
 492         // Give capability at course level to the user to access all groups.
 493         $role = $DB->get_field("role", "id", array("shortname" => "manager"));
 494         $generator->enrol_user($user3->id, $course->id, $role);
 495         // Make sure the user has the capability.
 496         assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $role, $coursecontext->id);
 497
 498         // No groups , not forced.
 499         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 500         $this->assertTrue($result);
 501         $result = groups_group_visible(0, $course, null, $user1->id);
 502         $this->assertTrue($result); // Requesting all groups.
 503
 504         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 505         $this->assertTrue($result); // Cm with no groups.
 506
 507         $cm->groupmode = SEPARATEGROUPS;
 508         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 509         $this->assertFalse($result); // Cm with separate groups.
 510         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 511         $this->assertTrue($result); // Cm with separate groups.
 512
 513         $cm->groupmode = VISIBLEGROUPS;
 514         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 515         $this->assertTrue($result); // Cm with visible groups.
 516
 517         // No groups, forced.
 518         $course->groupmode = NOGROUPS;
 519         $course->groupmodeforce = true;
 520         update_course($course);
 521         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 522         $this->assertTrue($result);
 523         $result = groups_group_visible(0, $course, null, $user1->id);
 524         $this->assertTrue($result); // Requesting all groups.
 525
 526         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 527         $this->assertTrue($result); // Cm with no groups.
 528
 529         $cm->groupmode = SEPARATEGROUPS;
 530         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 531         $this->assertTrue($result); // Cm with separate groups.
 532         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 533         $this->assertTrue($result); // Cm with separate groups.
 534
 535         $cm->groupmode = SEPARATEGROUPS;
 536         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 537         $this->assertTrue($result); // Cm with visible groups.
 538
 539         // Visible groups, forced.
 540         $course->groupmode = VISIBLEGROUPS;
 541         $course->groupmodeforce = true;
 542         update_course($course);
 543         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 544         $this->assertTrue($result);
 545         $result = groups_group_visible(0, $course, null, $user1->id);
 546         $this->assertTrue($result); // Requesting all groups.
 547
 548         $cm->groupmode = NOGROUPS;
 549         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 550         $this->assertTrue($result); // Cm with no groups.
 551
 552         $cm->groupmode = SEPARATEGROUPS;
 553         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 554         $this->assertTrue($result); // Cm with separate groups.
 555         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 556         $this->assertTrue($result); // Cm with separate groups.
 557
 558         $cm->groupmode = VISIBLEGROUPS;
 559         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 560         $this->assertTrue($result); // Cm with visible groups.
 561
 562         // Visible groups, not forced.
 563         $course->groupmode = VISIBLEGROUPS;
 564         $course->groupmodeforce = false;
 565         update_course($course);
 566         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 567         $this->assertTrue($result);
 568         $result = groups_group_visible(0, $course, null, $user1->id);
 569         $this->assertTrue($result); // Requesting all groups.
 570
 571         $cm->groupmode = NOGROUPS;
 572         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 573         $this->assertTrue($result); // Cm with no groups.
 574
 575         $cm->groupmode = SEPARATEGROUPS;
 576         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 577         $this->assertFalse($result); // Cm with separate groups.
 578         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 579         $this->assertTrue($result); // Cm with separate groups.
 580
 581         $cm->groupmode = VISIBLEGROUPS;
 582         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 583         $this->assertTrue($result); // Cm with visible groups.
 584
 585         // Separate groups, forced.
 586         $course->groupmode = SEPARATEGROUPS;
 587         $course->groupmodeforce = true;
 588         update_course($course);
 589         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 590         $this->assertFalse($result);
 591         $result = groups_group_visible($group1->id, $course, null, $user2->id);
 592         $this->assertTrue($result);
 593         $result = groups_group_visible(0, $course, null, $user2->id);
 594         $this->assertFalse($result); // Requesting all groups.
 595         $result = groups_group_visible(0, $course, null, $user3->id);
 596         $this->assertTrue($result); // Requesting all groups.
 597         $result = groups_group_visible($group1->id, $course, null, $user3->id);
 598         $this->assertTrue($result); // Make sure user with access to all groups can see any group.
 599
 600         $cm->groupmode = NOGROUPS;
 601         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 602         $this->assertFalse($result); // Cm with no groups.
 603
 604         $cm->groupmode = SEPARATEGROUPS;
 605         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 606         $this->assertFalse($result); // Cm with separate groups.
 607         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 608         $this->assertTrue($result); // Cm with separate groups.
 609         $result = groups_group_visible($group1->id, $course, $cm, $user3->id);
 610         $this->assertTrue($result); // Make sure user with access to all groups can see any group.
 611
 612         $cm->groupmode = VISIBLEGROUPS;
 613         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 614         $this->assertFalse($result); // Cm with visible groups.
 615
 616         // Separate groups, not forced.
 617         $course->groupmode = SEPARATEGROUPS;
 618         $course->groupmodeforce = false;
 619         update_course($course);
 620         $result = groups_group_visible($group1->id, $course, null, $user1->id);
 621         $this->assertFalse($result);
 622         $result = groups_group_visible($group1->id, $course, null, $user2->id);
 623         $this->assertTrue($result);
 624         $result = groups_group_visible(0, $course, null, $user2->id);
 625         $this->assertFalse($result); // Requesting all groups.
 626         $result = groups_group_visible(0, $course, null, $user3->id);
 627         $this->assertTrue($result); // Requesting all groups.
 628
 629         $cm->groupmode = NOGROUPS;
 630         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 631         $this->assertTrue($result); // Cm with no groups.
 632
 633         $cm->groupmode = SEPARATEGROUPS;
 634         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 635         $this->assertFalse($result); // Cm with separate groups.
 636         $result = groups_group_visible($group1->id, $course, $cm, $user2->id);
 637         $this->assertTrue($result); // Cm with separate groups.
 638
 639         $cm->groupmode = VISIBLEGROUPS;
 640         $result = groups_group_visible($group1->id, $course, $cm, $user1->id);
 641         $this->assertTrue($result); // Cm with visible groups.
 642     }
 643
 644     function test_groups_get_groupmode() {
 645         global $DB;
 646         $generator = $this->getDataGenerator();
 647         $this->resetAfterTest();
 648         $this->setAdminUser();
 649
 650         // Create a course with no groups forcing.
 651         $course1 = $generator->create_course();
 652
 653         // Create cm1 with no groups, cm1 with visible groups, cm2 with separate groups and cm3 with visible groups.
 654         $assign1 = $generator->create_module("assign", array('course' => $course1->id));
 655         $assign2 = $generator->create_module("assign", array('course' => $course1->id),
 656                 array('groupmode' => SEPARATEGROUPS));
 657         $assign3 = $generator->create_module("assign", array('course' => $course1->id),
 658                 array('groupmode' => VISIBLEGROUPS));
 659
 660         // Request data for tests.
 661         $cm1 = get_coursemodule_from_instance("assign", $assign1->id);
 662         $cm2 = get_coursemodule_from_instance("assign", $assign2->id);
 663         $cm3 = get_coursemodule_from_instance("assign", $assign3->id);
 664         $modinfo = get_fast_modinfo($course1->id);
 665
 666         // Assert that any method of getting activity groupmode returns the correct result.
 667         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1));
 668         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1, $course1));
 669         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 670         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 671         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 672         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 673         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3));
 674         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 675         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 676
 677         // Update the course set the groupmode SEPARATEGROUPS but not forced.
 678         update_course((object)array('id' => $course1->id, 'groupmode' => SEPARATEGROUPS));
 679         // Re-request the data from DB.
 680         $course1 = $DB->get_record('course', array('id' => $course1->id));
 681         $modinfo = get_fast_modinfo($course1->id);
 682
 683         // Existing activities are not changed.
 684         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1));
 685         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($cm1, $course1));
 686         $this->assertEquals(NOGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 687         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 688         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 689         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 690         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3));
 691         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 692         $this->assertEquals(VISIBLEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 693
 694         // Update the course set the groupmode SEPARATEGROUPS and forced.
 695         update_course((object)array('id' => $course1->id, 'groupmode' => SEPARATEGROUPS, 'groupmodeforce' => true));
 696         // Re-request the data from DB.
 697         $course1 = $DB->get_record('course', array('id' => $course1->id));
 698         $modinfo = get_fast_modinfo($course1->id);
 699
 700         // Make sure all activities have separate groups mode now.
 701         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm1));
 702         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm1, $course1));
 703         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm1->id]));
 704         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2));
 705         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm2, $course1));
 706         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm2->id]));
 707         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm3));
 708         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($cm3, $course1));
 709         $this->assertEquals(SEPARATEGROUPS, groups_get_activity_groupmode($modinfo->cms[$cm3->id]));
 710     }
 711
 712     /**
 713      * Tests for groups_allgroups_course_menu() .
 714      */
 715     public function test_groups_allgroups_course_menu() {
 716         global $SESSION;
 717
 718         $this->resetAfterTest();
 719
 720         // Generate data.
 721         $course = $this->getDataGenerator()->create_course();
 722         $record = new stdClass();
 723         $record->courseid = $course->id;
 724         $group1 = $this->getDataGenerator()->create_group($record);
 725         $group2 = $this->getDataGenerator()->create_group($record);
 726         $user = $this->getDataGenerator()->create_user();
 727         $this->getDataGenerator()->enrol_user($user->id, $course->id);
 728         $this->setUser($user);
 729
 730         $html = groups_allgroups_course_menu($course, 'someurl.php');
 731         // Since user is not a part of this group and doesn't have accessallgroups permission,
 732         // the html should be empty.
 733         $this->assertEmpty($html);
 734
 735         groups_add_member($group1->id, $user);
 736         // 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
 737         // partial match to see if all groups are listed or not.
 738         $html = groups_allgroups_course_menu($course, 'someurl.php');
 739         $this->assertContains(format_string($group1->name), $html);
 740         $this->assertNotContains(format_string($group2->name), $html);
 741
 742         $this->setAdminUser();
 743
 744         // Now user can access everything.
 745         $html = groups_allgroups_course_menu($course, 'someurl.php');
 746         $this->assertContains(format_string($group1->name), $html);
 747         $this->assertContains(format_string($group2->name), $html);
 748
 749         // Make sure separate groups mode, doesn't change anything.
 750         $course->groupmode = SEPARATEGROUPS;
 751         update_course($course);
 752         $html = groups_allgroups_course_menu($course, 'someurl.php');
 753         $this->assertContains(format_string($group1->name), $html);
 754         $this->assertContains(format_string($group2->name), $html);
 755
 756         // Make sure Visible groups mode, doesn't change anything.
 757         $course->groupmode = VISIBLEGROUPS;
 758         update_course($course);
 759         $html = groups_allgroups_course_menu($course, 'someurl.php');
 760         $this->assertContains(format_string($group1->name), $html);
 761         $this->assertContains(format_string($group2->name), $html);
 762
 763         // Let us test activegroup changes now.
 764         $this->setUser($user);
 765         $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid] = 5;
 766         groups_allgroups_course_menu($course, 'someurl.php', false); // Do not update session.
 767         $this->assertSame(5, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 768         groups_allgroups_course_menu($course, 'someurl.php', true, $group1->id); // Update session.
 769         $this->assertSame($group1->id, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 770         // Try to update session with an invalid groupid. It should not accept the invalid id.
 771         groups_allgroups_course_menu($course, 'someurl.php', true, 256);
 772         $this->assertEquals($group1->id, $SESSION->activegroup[$course->id][VISIBLEGROUPS][$course->defaultgroupingid]);
 773     }
 774
 775     /**
 776      * This unit test checks that groups_get_all_groups returns groups in
 777      * alphabetical order even if they are in a grouping.
 778      */
 779     public function test_groups_ordering() {
 780         $generator = $this->getDataGenerator();
 781         $this->resetAfterTest();
 782
 783         // Create a course category and course.
 784         $cat = $generator->create_category(array('parent' => 0));
 785         $course = $generator->create_course(array('category' => $cat->id));
 786         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping'));
 787
 788         // Create groups in reverse order.
 789         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 790         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 791
 792         // Assign the groups to the grouping in reverse order.
 793         $this->assertTrue(groups_assign_grouping($grouping->id, $group2->id));
 794         $this->assertTrue(groups_assign_grouping($grouping->id, $group1->id));
 795
 796         // Get all groups and check they are alphabetical.
 797         $groups = array_values(groups_get_all_groups($course->id, 0));
 798         $this->assertEquals('Group 1', $groups[0]->name);
 799         $this->assertEquals('Group 2', $groups[1]->name);
 800
 801         // Now check the same is true when accessed by grouping.
 802         $groups = array_values(groups_get_all_groups($course->id, 0, $grouping->id));
 803         $this->assertEquals('Group 1', $groups[0]->name);
 804         $this->assertEquals('Group 2', $groups[1]->name);
 805     }
 806
 807     /**
 808      * Tests for groups_get_user_groups() method.
 809      */
 810     public function test_groups_get_user_groups() {
 811         $this->resetAfterTest(true);
 812         $generator = $this->getDataGenerator();
 813
 814         // Create courses.
 815         $course1 = $generator->create_course();
 816         $course2 = $generator->create_course();
 817
 818         // Create users.
 819         $user1 = $generator->create_user();
 820         $user2 = $generator->create_user();
 821         $user3 = $generator->create_user();
 822
 823         // Enrol users.
 824         $generator->enrol_user($user1->id, $course1->id);
 825         $generator->enrol_user($user1->id, $course2->id);
 826         $generator->enrol_user($user2->id, $course2->id);
 827         $generator->enrol_user($user3->id, $course2->id);
 828
 829         // Create groups.
 830         $group1 = $generator->create_group(array('courseid' => $course1->id));
 831         $group2 = $generator->create_group(array('courseid' => $course2->id));
 832         $group3 = $generator->create_group(array('courseid' => $course2->id));
 833
 834         // Assign users to groups.
 835         $this->assertTrue($generator->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id)));
 836         $this->assertTrue($generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user2->id)));
 837
 838         // Get user groups.
 839         $usergroups1 = groups_get_user_groups($course1->id, $user1->id);
 840         $usergroups2 = groups_get_user_groups($course2->id, $user2->id);;
 841
 842         // Assert return data.
 843         $this->assertEquals($group1->id, $usergroups1[0][0]);
 844         $this->assertEquals($group2->id, $usergroups2[0][0]);
 845
 846         // Now, test with groupings.
 847         $grouping1 = $generator->create_grouping(array('courseid' => $course1->id));
 848         $grouping2 = $generator->create_grouping(array('courseid' => $course2->id));
 849
 850         // Assign the groups to grouping.
 851         groups_assign_grouping($grouping1->id, $group1->id);
 852         groups_assign_grouping($grouping2->id, $group2->id);
 853         groups_assign_grouping($grouping2->id, $group3->id);
 854
 855         // Test with grouping.
 856         $usergroups1 = groups_get_user_groups($course1->id, $user1->id);
 857         $usergroups2 = groups_get_user_groups($course2->id, $user2->id);
 858         $this->assertArrayHasKey($grouping1->id, $usergroups1);
 859         $this->assertArrayHasKey($grouping2->id, $usergroups2);
 860
 861         // Test user without a group.
 862         $usergroups1 = groups_get_user_groups($course2->id, $user3->id);
 863         $this->assertCount(0, $usergroups1[0]);
 864
 865         // Test with userid = 0.
 866         $usergroups1 = groups_get_user_groups($course1->id, 0);
 867         $usergroups2 = groups_get_user_groups($course2->id, 0);
 868         $this->assertCount(0, $usergroups1[0]);
 869         $this->assertCount(0, $usergroups2[0]);
 870
 871         // Test with courseid = 0.
 872         $usergroups1 = groups_get_user_groups(0, $user1->id);
 873         $usergroups2 = groups_get_user_groups(0, $user2->id);
 874         $this->assertCount(0, $usergroups1[0]);
 875         $this->assertCount(0, $usergroups2[0]);
 876     }
 877
 878     /**
 879      * Create dummy groups array for use in menu tests
 880      * @param int $number
 881      * @return array
 882      */
 883     protected function make_group_list($number) {
 884         $testgroups = array();
 885         for ($a = 0; $a < $number; $a++) {
 886             $grp = new stdClass();
 887             $grp->id = 100 + $a;
 888             $grp->name = 'test group ' . $grp->id;
 889             $testgroups[$grp->id] = $grp;
 890         }
 891         return $testgroups;
 892     }
 893
 894     public function test_groups_sort_menu_options_empty() {
 895         $this->assertEquals(array(), groups_sort_menu_options(array(), array()));
 896     }
 897
 898     public function test_groups_sort_menu_options_allowed_goups_only() {
 899         $this->assertEquals(array(
 900             100 => 'test group 100',
 901             101 => 'test group 101',
 902         ), groups_sort_menu_options($this->make_group_list(2), array()));
 903     }
 904
 905     public function test_groups_sort_menu_options_user_goups_only() {
 906         $this->assertEquals(array(
 907             100 => 'test group 100',
 908             101 => 'test group 101',
 909         ), groups_sort_menu_options(array(), $this->make_group_list(2)));
 910     }
 911
 912     public function test_groups_sort_menu_options_user_both() {
 913         $this->assertEquals(array(
 914             1 => array(get_string('mygroups', 'group') => array(
 915                 100 => 'test group 100',
 916                 101 => 'test group 101',
 917             )),
 918             2 => array(get_string('othergroups', 'group') => array(
 919                 102 => 'test group 102',
 920                 103 => 'test group 103',
 921             )),
 922         ), groups_sort_menu_options($this->make_group_list(4), $this->make_group_list(2)));
 923     }
 924
 925     public function test_groups_sort_menu_options_user_both_many_groups() {
 926         $this->assertEquals(array(
 927             1 => array(get_string('mygroups', 'group') => array(
 928                 100 => 'test group 100',
 929                 101 => 'test group 101',
 930             )),
 931             2 => array (get_string('othergroups', 'group') => array(
 932                 102 => 'test group 102',
 933                 103 => 'test group 103',
 934                 104 => 'test group 104',
 935                 105 => 'test group 105',
 936                 106 => 'test group 106',
 937                 107 => 'test group 107',
 938                 108 => 'test group 108',
 939                 109 => 'test group 109',
 940                 110 => 'test group 110',
 941                 111 => 'test group 111',
 942                 112 => 'test group 112',
 943             )),
 944         ), groups_sort_menu_options($this->make_group_list(13), $this->make_group_list(2)));
 945     }
 946
 947     /**
 948      * Tests for groups_user_groups_visible.
 949      */
 950     public function test_groups_user_groups_visible() {
 951         global $CFG, $DB;
 952
 953         $generator = $this->getDataGenerator();
 954         $this->resetAfterTest();
 955         $this->setAdminUser();
 956
 957         // Create a course category, course and groups.
 958         $cat = $generator->create_category(array('parent' => 0));
 959         $course = $generator->create_course(array('category' => $cat->id));
 960         $coursecontext = context_course::instance($course->id);
 961         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 962         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 963         $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 964         $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 965
 966         // Create cm.
 967         $assign = $generator->create_module("assign", array('course' => $course->id));
 968         $cm = get_coursemodule_from_instance("assign", $assign->id);
 969
 970         // Create users.
 971         $user1 = $generator->create_user(); // Normal user.
 972         $user2 = $generator->create_user(); // Normal user.
 973         $user3 = $generator->create_user(); // Teacher, access all groups.
 974         $user4 = $generator->create_user(); // Normal user.
 975
 976         // Enrol users into the course.
 977         $generator->enrol_user($user1->id, $course->id);
 978         $generator->enrol_user($user2->id, $course->id);
 979         $generator->enrol_user($user4->id, $course->id);
 980
 981         // Assign groups.
 982         // User1 and User4 share groups.
 983         groups_add_member($group1, $user1);
 984         groups_add_member($group2, $user2);
 985         groups_add_member($group1, $user4);
 986
 987         // Give capability at course level to the user to access all groups.
 988         $role = $DB->get_field("role", "id", array("shortname" => "manager"));
 989         $generator->enrol_user($user3->id, $course->id, $role);
 990         // Make sure the user has the capability.
 991         assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $role, $coursecontext->id);
 992
 993         // Normal users in different groups.
 994         $this->setUser($user1);
 995
 996         // No groups , not forced.
 997         $result = groups_user_groups_visible($course, $user2->id);
 998         $this->assertTrue($result);
 999
1000         $result = groups_user_groups_visible($course, $user2->id);
1001         $this->assertTrue($result); // Cm with no groups.
1002
1003         $cm->groupmode = SEPARATEGROUPS;
1004         $result = groups_user_groups_visible($course, $user2->id, $cm);
1005         $this->assertFalse($result); // Cm with separate groups.
1006
1007         $cm->groupmode = VISIBLEGROUPS;
1008         $result = groups_user_groups_visible($course, $user2->id, $cm);
1009         $this->assertTrue($result); // Cm with visible groups.
1010
1011         // No groups, forced.
1012         $course->groupmode = NOGROUPS;
1013         $course->groupmodeforce = true;
1014         update_course($course);
1015         $result = groups_user_groups_visible($course, $user2->id);
1016         $this->assertTrue($result);
1017
1018         $result = groups_user_groups_visible($course, $user2->id);
1019         $this->assertTrue($result); // Cm with no groups.
1020
1021         $cm->groupmode = SEPARATEGROUPS;
1022         $result = groups_user_groups_visible($course, $user2->id, $cm);
1023         $this->assertTrue($result); // Cm with separate groups.
1024
1025         $cm->groupmode = SEPARATEGROUPS;
1026         $result = groups_user_groups_visible($course, $user2->id);
1027         $this->assertTrue($result); // Cm with visible groups.
1028
1029         // Visible groups, forced.
1030         $course->groupmode = VISIBLEGROUPS;
1031         $course->groupmodeforce = true;
1032         update_course($course);
1033         $result = groups_user_groups_visible($course, $user2->id);
1034         $this->assertTrue($result);
1035
1036         $cm->groupmode = NOGROUPS;
1037         $result = groups_user_groups_visible($course, $user2->id, $cm);
1038         $this->assertTrue($result); // Cm with no groups.
1039
1040         $cm->groupmode = SEPARATEGROUPS;
1041         $result = groups_user_groups_visible($course, $user2->id, $cm);
1042         $this->assertTrue($result); // Cm with separate groups.
1043
1044         $cm->groupmode = VISIBLEGROUPS;
1045         $result = groups_user_groups_visible($course, $user2->id, $cm);
1046         $this->assertTrue($result); // Cm with visible groups.
1047
1048         // Visible groups, not forced.
1049         $course->groupmode = VISIBLEGROUPS;
1050         $course->groupmodeforce = false;
1051         update_course($course);
1052         $result = groups_user_groups_visible($course, $user2->id);
1053         $this->assertTrue($result);
1054
1055         $cm->groupmode = NOGROUPS;
1056         $result = groups_user_groups_visible($course, $user2->id);
1057         $this->assertTrue($result); // Cm with no groups.
1058
1059         $cm->groupmode = SEPARATEGROUPS;
1060         $result = groups_user_groups_visible($course, $user2->id, $cm);
1061         $this->assertFalse($result); // Cm with separate groups.
1062
1063         $cm->groupmode = VISIBLEGROUPS;
1064         $result = groups_user_groups_visible($course, $user2->id, $cm);
1065         $this->assertTrue($result); // Cm with visible groups.
1066
1067         // Separate groups, forced.
1068         $course->groupmode = SEPARATEGROUPS;
1069         $course->groupmodeforce = true;
1070         update_course($course);
1071         $result = groups_user_groups_visible($course, $user2->id);
1072         $this->assertFalse($result);
1073
1074         $result = groups_user_groups_visible($course, $user3->id);
1075         $this->assertFalse($result); // Requesting all groups.
1076
1077         $cm->groupmode = NOGROUPS;
1078         $result = groups_user_groups_visible($course, $user2->id, $cm);
1079         $this->assertFalse($result); // Cm with no groups.
1080
1081         $cm->groupmode = SEPARATEGROUPS;
1082         $result = groups_user_groups_visible($course, $user2->id, $cm);
1083         $this->assertFalse($result); // Cm with separate groups.
1084
1085         $result = groups_user_groups_visible($course, $user3->id, $cm);
1086         $this->assertTrue($result);
1087
1088         $cm->groupmode = VISIBLEGROUPS;
1089         $result = groups_user_groups_visible($course, $user2->id, $cm);
1090         $this->assertFalse($result); // Cm with visible groups.
1091
1092         // Separate groups, not forced.
1093         $course->groupmode = SEPARATEGROUPS;
1094         $course->groupmodeforce = false;
1095         update_course($course);
1096         $result = groups_user_groups_visible($course, $user2->id);
1097         $this->assertFalse($result);
1098
1099         $result = groups_user_groups_visible($course, $user3->id);
1100         $this->assertFalse($result); // Requesting all groups.
1101
1102         $cm->groupmode = NOGROUPS;
1103         $result = groups_user_groups_visible($course, $user2->id, $cm);
1104         $this->assertTrue($result); // Cm with no groups.
1105
1106         $cm->groupmode = SEPARATEGROUPS;
1107         $result = groups_user_groups_visible($course, $user2->id, $cm);
1108         $this->assertFalse($result); // Cm with separate groups.
1109
1110         $cm->groupmode = VISIBLEGROUPS;
1111         $result = groups_user_groups_visible($course, $user2->id, $cm);
1112         $this->assertTrue($result); // Cm with visible groups.
1113
1114         // Users sharing groups.
1115
1116         // No groups , not forced.
1117         $course->groupmode = NOGROUPS;
1118         $course->groupmodeforce = false;
1119         update_course($course);
1120
1121         $result = groups_user_groups_visible($course, $user4->id);
1122         $this->assertTrue($result);
1123
1124         $result = groups_user_groups_visible($course, $user4->id);
1125         $this->assertTrue($result); // Cm with no groups.
1126
1127         $cm->groupmode = SEPARATEGROUPS;
1128         $result = groups_user_groups_visible($course, $user4->id, $cm);
1129         $this->assertTrue($result); // Cm with separate groups.
1130
1131         $cm->groupmode = VISIBLEGROUPS;
1132         $result = groups_user_groups_visible($course, $user4->id, $cm);
1133         $this->assertTrue($result); // Cm with visible groups.
1134
1135         // No groups, forced.
1136         $course->groupmode = NOGROUPS;
1137         $course->groupmodeforce = true;
1138         update_course($course);
1139         $result = groups_user_groups_visible($course, $user4->id);
1140         $this->assertTrue($result);
1141
1142         $result = groups_user_groups_visible($course, $user4->id);
1143         $this->assertTrue($result); // Cm with no groups.
1144
1145         $cm->groupmode = SEPARATEGROUPS;
1146         $result = groups_user_groups_visible($course, $user4->id, $cm);
1147         $this->assertTrue($result); // Cm with separate groups.
1148
1149         $cm->groupmode = SEPARATEGROUPS;
1150         $result = groups_user_groups_visible($course, $user4->id);
1151         $this->assertTrue($result); // Cm with visible groups.
1152
1153         // Visible groups, forced.
1154         $course->groupmode = VISIBLEGROUPS;
1155         $course->groupmodeforce = true;
1156         update_course($course);
1157         $result = groups_user_groups_visible($course, $user4->id);
1158         $this->assertTrue($result);
1159
1160         $cm->groupmode = NOGROUPS;
1161         $result = groups_user_groups_visible($course, $user4->id, $cm);
1162         $this->assertTrue($result); // Cm with no groups.
1163
1164         $cm->groupmode = SEPARATEGROUPS;
1165         $result = groups_user_groups_visible($course, $user4->id, $cm);
1166         $this->assertTrue($result); // Cm with separate groups.
1167
1168         $cm->groupmode = VISIBLEGROUPS;
1169         $result = groups_user_groups_visible($course, $user4->id, $cm);
1170         $this->assertTrue($result); // Cm with visible groups.
1171
1172         // Visible groups, not forced.
1173         $course->groupmode = VISIBLEGROUPS;
1174         $course->groupmodeforce = false;
1175         update_course($course);
1176         $result = groups_user_groups_visible($course, $user4->id);
1177         $this->assertTrue($result);
1178
1179         $cm->groupmode = NOGROUPS;
1180         $result = groups_user_groups_visible($course, $user4->id);
1181         $this->assertTrue($result); // Cm with no groups.
1182
1183         $cm->groupmode = SEPARATEGROUPS;
1184         $result = groups_user_groups_visible($course, $user4->id, $cm);
1185         $this->assertTrue($result); // Cm with separate groups.
1186
1187         $cm->groupmode = VISIBLEGROUPS;
1188         $result = groups_user_groups_visible($course, $user4->id, $cm);
1189         $this->assertTrue($result); // Cm with visible groups.
1190
1191         // Separate groups, forced.
1192         $course->groupmode = SEPARATEGROUPS;
1193         $course->groupmodeforce = true;
1194         update_course($course);
1195         $result = groups_user_groups_visible($course, $user4->id);
1196         $this->assertTrue($result);
1197
1198         $result = groups_user_groups_visible($course, $user3->id);
1199         $this->assertFalse($result); // Requesting all groups.
1200
1201         $cm->groupmode = NOGROUPS;
1202         $result = groups_user_groups_visible($course, $user4->id, $cm);
1203         $this->assertTrue($result); // Cm with no groups.
1204
1205         $cm->groupmode = SEPARATEGROUPS;
1206         $result = groups_user_groups_visible($course, $user4->id, $cm);
1207         $this->assertTrue($result); // Cm with separate groups.
1208
1209         $result = groups_user_groups_visible($course, $user3->id, $cm);
1210         $this->assertTrue($result);
1211
1212         $cm->groupmode = VISIBLEGROUPS;
1213         $result = groups_user_groups_visible($course, $user4->id, $cm);
1214         $this->assertTrue($result); // Cm with visible groups.
1215
1216         // Separate groups, not forced.
1217         $course->groupmode = SEPARATEGROUPS;
1218         $course->groupmodeforce = false;
1219         update_course($course);
1220         $result = groups_user_groups_visible($course, $user4->id);
1221         $this->assertTrue($result);
1222
1223         $result = groups_user_groups_visible($course, $user3->id);
1224         $this->assertFalse($result); // Requesting all groups.
1225
1226         $cm->groupmode = NOGROUPS;
1227         $result = groups_user_groups_visible($course, $user4->id, $cm);
1228         $this->assertTrue($result); // Cm with no groups.
1229
1230         $cm->groupmode = SEPARATEGROUPS;
1231         $result = groups_user_groups_visible($course, $user4->id, $cm);
1232         $this->assertTrue($result); // Cm with separate groups.
1233
1234         $cm->groupmode = VISIBLEGROUPS;
1235         $result = groups_user_groups_visible($course, $user4->id, $cm);
1236         $this->assertTrue($result); // Cm with visible groups.
1237
1238         // For teacher with access all groups.
1239
1240         // No groups , not forced.
1241         $course->groupmode = NOGROUPS;
1242         $course->groupmodeforce = false;
1243         update_course($course);
1244
1245         $this->setUser($user3);
1246
1247         $result = groups_user_groups_visible($course, $user1->id);
1248         $this->assertTrue($result);
1249         $result = groups_user_groups_visible($course, $user1->id);
1250         $this->assertTrue($result); // Requesting all groups.
1251
1252         $result = groups_user_groups_visible($course, $user1->id);
1253         $this->assertTrue($result); // Cm with no groups.
1254
1255         $cm->groupmode = SEPARATEGROUPS;
1256         $result = groups_user_groups_visible($course, $user1->id, $cm);
1257         $this->assertTrue($result); // Cm with separate groups.
1258         $result = groups_user_groups_visible($course, $user2->id, $cm);
1259         $this->assertTrue($result); // Cm with separate groups.
1260
1261         $cm->groupmode = VISIBLEGROUPS;
1262         $result = groups_user_groups_visible($course, $user1->id, $cm);
1263         $this->assertTrue($result); // Cm with visible groups.
1264
1265         // No groups, forced.
1266         $course->groupmode = NOGROUPS;
1267         $course->groupmodeforce = true;
1268         update_course($course);
1269         $result = groups_user_groups_visible($course, $user1->id);
1270         $this->assertTrue($result);
1271         $result = groups_user_groups_visible($course, $user1->id);
1272         $this->assertTrue($result); // Requesting all groups.
1273
1274         $result = groups_user_groups_visible($course, $user1->id);
1275         $this->assertTrue($result); // Cm with no groups.
1276
1277         $cm->groupmode = SEPARATEGROUPS;
1278         $result = groups_user_groups_visible($course, $user1->id, $cm);
1279         $this->assertTrue($result); // Cm with separate groups.
1280         $result = groups_user_groups_visible($course, $user2->id, $cm);
1281         $this->assertTrue($result); // Cm with separate groups.
1282
1283         $cm->groupmode = SEPARATEGROUPS;
1284         $result = groups_user_groups_visible($course, $user1->id);
1285         $this->assertTrue($result); // Cm with visible groups.
1286
1287         // Visible groups, forced.
1288         $course->groupmode = VISIBLEGROUPS;
1289         $course->groupmodeforce = true;
1290         update_course($course);
1291         $result = groups_user_groups_visible($course, $user1->id);
1292         $this->assertTrue($result);
1293         $result = groups_user_groups_visible($course, $user1->id);
1294         $this->assertTrue($result); // Requesting all groups.
1295
1296         $cm->groupmode = NOGROUPS;
1297         $result = groups_user_groups_visible($course, $user1->id, $cm);
1298         $this->assertTrue($result); // Cm with no groups.
1299
1300         $cm->groupmode = SEPARATEGROUPS;
1301         $result = groups_user_groups_visible($course, $user1->id, $cm);
1302         $this->assertTrue($result); // Cm with separate groups.
1303         $result = groups_user_groups_visible($course, $user2->id, $cm);
1304         $this->assertTrue($result); // Cm with separate groups.
1305
1306         $cm->groupmode = VISIBLEGROUPS;
1307         $result = groups_user_groups_visible($course, $user1->id, $cm);
1308         $this->assertTrue($result); // Cm with visible groups.
1309
1310         // Visible groups, not forced.
1311         $course->groupmode = VISIBLEGROUPS;
1312         $course->groupmodeforce = false;
1313         update_course($course);
1314         $result = groups_user_groups_visible($course, $user1->id);
1315         $this->assertTrue($result);
1316         $result = groups_user_groups_visible($course, $user1->id);
1317         $this->assertTrue($result); // Requesting all groups.
1318
1319         $cm->groupmode = NOGROUPS;
1320         $result = groups_user_groups_visible($course, $user1->id);
1321         $this->assertTrue($result); // Cm with no groups.
1322
1323         $cm->groupmode = SEPARATEGROUPS;
1324         $result = groups_user_groups_visible($course, $user1->id, $cm);
1325         $this->assertTrue($result); // Cm with separate groups.
1326         $result = groups_user_groups_visible($course, $user2->id, $cm);
1327         $this->assertTrue($result); // Cm with separate groups.
1328
1329         $cm->groupmode = VISIBLEGROUPS;
1330         $result = groups_user_groups_visible($course, $user1->id, $cm);
1331         $this->assertTrue($result); // Cm with visible groups.
1332
1333         // Separate groups, forced.
1334         $course->groupmode = SEPARATEGROUPS;
1335         $course->groupmodeforce = true;
1336         update_course($course);
1337         $result = groups_user_groups_visible($course, $user1->id);
1338         $this->assertTrue($result);
1339         $result = groups_user_groups_visible($course, $user2->id);
1340         $this->assertTrue($result);
1341         $result = groups_user_groups_visible($course, $user2->id);
1342         $this->assertTrue($result); // Requesting all groups.
1343         $result = groups_user_groups_visible($course, $user3->id);
1344         $this->assertTrue($result); // Requesting all groups.
1345         $result = groups_user_groups_visible($course, $user3->id);
1346         $this->assertTrue($result);
1347
1348         $cm->groupmode = NOGROUPS;
1349         $result = groups_user_groups_visible($course, $user1->id, $cm);
1350         $this->assertTrue($result); // Cm with no groups.
1351
1352         $cm->groupmode = SEPARATEGROUPS;
1353         $result = groups_user_groups_visible($course, $user1->id, $cm);
1354         $this->assertTrue($result); // Cm with separate groups.
1355         $result = groups_user_groups_visible($course, $user2->id, $cm);
1356         $this->assertTrue($result); // Cm with separate groups.
1357         $result = groups_user_groups_visible($course, $user3->id, $cm);
1358         $this->assertTrue($result);
1359
1360         $cm->groupmode = VISIBLEGROUPS;
1361         $result = groups_user_groups_visible($course, $user1->id, $cm);
1362         $this->assertTrue($result); // Cm with visible groups.
1363
1364         // Separate groups, not forced.
1365         $course->groupmode = SEPARATEGROUPS;
1366         $course->groupmodeforce = false;
1367         update_course($course);
1368         $result = groups_user_groups_visible($course, $user1->id);
1369         $this->assertTrue($result);
1370         $result = groups_user_groups_visible($course, $user2->id);
1371         $this->assertTrue($result);
1372         $result = groups_user_groups_visible($course, $user2->id);
1373         $this->assertTrue($result); // Requesting all groups.
1374         $result = groups_user_groups_visible($course, $user3->id);
1375         $this->assertTrue($result); // Requesting all groups.
1376
1377         $cm->groupmode = NOGROUPS;
1378         $result = groups_user_groups_visible($course, $user1->id, $cm);
1379         $this->assertTrue($result); // Cm with no groups.
1380
1381         $cm->groupmode = SEPARATEGROUPS;
1382         $result = groups_user_groups_visible($course, $user1->id, $cm);
1383         $this->assertTrue($result); // Cm with separate groups.
1384         $result = groups_user_groups_visible($course, $user2->id, $cm);
1385         $this->assertTrue($result); // Cm with separate groups.
1386
1387         $cm->groupmode = VISIBLEGROUPS;
1388         $result = groups_user_groups_visible($course, $user1->id, $cm);
1389         $this->assertTrue($result); // Cm with visible groups.
1390     }
1391
1392     /**
1393      * Tests for groups_get_groups_members() method.
1394      */
1395     public function test_groups_get_groups_members() {
1396         $this->resetAfterTest(true);
1397         $generator = $this->getDataGenerator();
1398
1399         // Create courses.
1400         $course1 = $generator->create_course();
1401         $course2 = $generator->create_course();
1402
1403         // Create users.
1404         $user1 = $generator->create_user();
1405         $user2 = $generator->create_user();
1406         $user3 = $generator->create_user();
1407
1408         // Enrol users.
1409         $generator->enrol_user($user1->id, $course1->id);
1410         $generator->enrol_user($user1->id, $course2->id);
1411         $generator->enrol_user($user2->id, $course2->id);
1412         $generator->enrol_user($user3->id, $course2->id);
1413
1414         // Create groups.
1415         $group1 = $generator->create_group(array('courseid' => $course1->id));
1416         $group2 = $generator->create_group(array('courseid' => $course2->id));
1417         $group3 = $generator->create_group(array('courseid' => $course2->id));
1418
1419         // Assign users to groups.
1420         $this->assertTrue($generator->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id)));
1421         $this->assertTrue($generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id)));
1422         $this->assertTrue($generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user2->id)));
1423
1424         // Test get_groups_members (with extra field and ordering).
1425         $members = groups_get_groups_members([$group1->id, $group2->id], ['lastaccess'], 'u.id ASC');
1426         $this->assertCount(2, $members);
1427         $this->assertEquals([$user1->id, $user2->id], array_keys($members));
1428         $this->assertTrue(isset($members[$user1->id]->lastaccess));
1429         $this->assertTrue(isset($members[$user2->id]->lastaccess));
1430
1431         // Group with just one.
1432         $members = groups_get_groups_members([$group1->id]);
1433         $this->assertCount(1, $members);
1434         $this->assertEquals($user1->id, $members[$user1->id]->id);
1435
1436         // Test the info matches group membership for the entire course.
1437         $groups  = groups_get_all_groups($course1->id, 0, 0, 'g.*', true);
1438         $group1withmembers = array_pop($groups);
1439
1440         // Compare the sorted keys of both arrays (should be list of user ids).
1441         $members = array_keys($members);
1442         sort($members);
1443         $group1members = array_keys($group1withmembers->members);
1444         sort($group1members);
1445         $this->assertEquals($members, $group1members);
1446
1447         // Group with just one plus empty group.
1448         $members = groups_get_groups_members([$group1->id, $group3->id]);
1449         $this->assertCount(1, $members);
1450         $this->assertEquals($user1->id, $members[$user1->id]->id);
1451
1452         // Empty group.
1453         $members = groups_get_groups_members([$group3->id]);
1454         $this->assertCount(0, $members);
1455
1456         // Test groups_get_members.
1457         $members = groups_get_members($group2->id, 'u.*', 'u.id ASC');
1458         $this->assertCount(2, $members);
1459         $this->assertEquals([$user1->id, $user2->id], array_keys($members));
1460
1461         // Test the info matches group membership for the entire course.
1462         $groups  = groups_get_all_groups($course2->id, 0, 0, 'g.*', true);
1463         $group2withmembers = $groups[$group2->id];
1464
1465         // Compare the sorted keys of both arrays (should be list of user ids).
1466         $members = array_keys($members);
1467         sort($members);
1468         $group2members = array_keys($group2withmembers->members);
1469         sort($group2members);
1470         $this->assertEquals($members, $group2members);
1471
1472     }
1473
1474     /**
1475      * Tests for groups_get_activity_shared_group_members() method.
1476      */
1477     public function test_groups_get_activity_shared_group_members() {
1478         $this->resetAfterTest(true);
1479         $generator = $this->getDataGenerator();
1480
1481         // Create courses.
1482         $course = $generator->create_course();
1483
1484         // Create cm.
1485         $assign = $generator->create_module("assign", array('course' => $course->id));
1486         $cm = get_coursemodule_from_instance("assign", $assign->id);
1487
1488         // Create users.
1489         $user1 = $generator->create_user();
1490         $user2 = $generator->create_user();
1491         $user3 = $generator->create_user();
1492         $user4 = $generator->create_user();
1493
1494         // Enrol users.
1495         $generator->enrol_user($user1->id, $course->id);
1496         $generator->enrol_user($user2->id, $course->id);
1497         $generator->enrol_user($user3->id, $course->id);
1498         $generator->enrol_user($user4->id, $course->id);
1499
1500         // Create groups.
1501         $group1 = $generator->create_group(array('courseid' => $course->id));
1502         $group2 = $generator->create_group(array('courseid' => $course->id));
1503         $group3 = $generator->create_group(array('courseid' => $course->id));
1504
1505         // Assign users to groups.
1506         $generator->create_group_member(array('groupid' => $group1->id, 'userid' => $user1->id));
1507         $generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id));
1508         $generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user2->id));
1509         $generator->create_group_member(array('groupid' => $group3->id, 'userid' => $user3->id));
1510
1511         // Retrieve users sharing groups with user1.
1512         $members = groups_get_activity_shared_group_members($cm, $user1->id);
1513         $this->assertCount(2, $members);
1514         $this->assertEquals([$user1->id, $user2->id], array_keys($members), '', 0.0, 10, true);
1515
1516         // Retrieve users sharing groups with user2.
1517         $members = groups_get_activity_shared_group_members($cm, $user2->id);
1518         $this->assertCount(2, $members);
1519         $this->assertEquals([$user1->id, $user2->id], array_keys($members), '', 0.0, 10, true);
1520
1521         // Retrieve users sharing groups with user3.
1522         $members = groups_get_activity_shared_group_members($cm, $user3->id);
1523         $this->assertCount(1, $members);
1524         $this->assertEquals($user3->id, $members[$user3->id]->id);
1525
1526         // Retrieve users sharing groups with user without groups (user4).
1527         $members = groups_get_activity_shared_group_members($cm, $user4->id);
1528         $this->assertCount(0, $members);
1529
1530         // Now, create a different activity using groupings.
1531         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 1'));
1532         // Skip group 2.
1533         groups_assign_grouping($grouping->id, $group1->id);
1534         groups_assign_grouping($grouping->id, $group3->id);
1535
1536         $assign = $generator->create_module("assign", array('course' => $course->id, 'groupingid' => $grouping->id));
1537         $cm = get_coursemodule_from_instance("assign", $assign->id);
1538
1539         // Since the activity is forced to groupings (groups 1 and 3), I don't see members of group 2.
1540         $members = groups_get_activity_shared_group_members($cm, $user1->id);
1541         $this->assertCount(1, $members);
1542         $this->assertEquals($user1->id, $members[$user1->id]->id);
1543
1544         // Add user1 to group 3 (in the grouping).
1545         $generator->create_group_member(array('groupid' => $group3->id, 'userid' => $user1->id));
1546         $members = groups_get_activity_shared_group_members($cm, $user1->id);
1547         $this->assertCount(2, $members);    // Now I see members of group 3.
1548         $this->assertEquals([$user1->id, $user3->id], array_keys($members), '', 0.0, 10, true);
1549     }
1550
1551     /**
1552      * Test groups_get_all_groups_for_courses() method.
1553      */
1554     public function test_groups_get_all_groups_for_courses_no_courses() {
1555         $this->resetAfterTest(true);
1556         $generator = $this->getDataGenerator();
1557
1558         $this->assertEquals([], groups_get_all_groups_for_courses([]));
1559     }
1560
1561     /**
1562      * Test groups_get_all_groups_for_courses() method.
1563      */
1564     public function test_groups_get_all_groups_for_courses_with_courses() {
1565         global $DB;
1566
1567         $this->resetAfterTest(true);
1568         $generator = $this->getDataGenerator();
1569
1570         // Create courses.
1571         $course1 = $generator->create_course(); // no groups.
1572         $course2 = $generator->create_course(); // one group, no members.
1573         $course3 = $generator->create_course(); // one group, one member.
1574         $course4 = $generator->create_course(); // one group, multiple members.
1575         $course5 = $generator->create_course(); // two groups, no members.
1576         $course6 = $generator->create_course(); // two groups, one member.
1577         $course7 = $generator->create_course(); // two groups, multiple members.
1578
1579         $courses = [$course1, $course2, $course3, $course4, $course5, $course6, $course7];
1580         // Create users.
1581         $user1 = $generator->create_user();
1582         $user2 = $generator->create_user();
1583         $user3 = $generator->create_user();
1584         $user4 = $generator->create_user();
1585
1586         // Enrol users.
1587         foreach ($courses as $course) {
1588             $generator->enrol_user($user1->id, $course->id);
1589             $generator->enrol_user($user2->id, $course->id);
1590             $generator->enrol_user($user3->id, $course->id);
1591             $generator->enrol_user($user4->id, $course->id);
1592         }
1593
1594         // Create groups.
1595         $group1 = $generator->create_group(array('courseid' => $course2->id)); // no members.
1596         $group2 = $generator->create_group(array('courseid' => $course3->id)); // one member.
1597         $group3 = $generator->create_group(array('courseid' => $course4->id)); // multiple members.
1598         $group4 = $generator->create_group(array('courseid' => $course5->id)); // no members.
1599         $group5 = $generator->create_group(array('courseid' => $course5->id)); // no members.
1600         $group6 = $generator->create_group(array('courseid' => $course6->id)); // one member.
1601         $group7 = $generator->create_group(array('courseid' => $course6->id)); // one member.
1602         $group8 = $generator->create_group(array('courseid' => $course7->id)); // multiple members.
1603         $group9 = $generator->create_group(array('courseid' => $course7->id)); // multiple members.
1604
1605         // Assign users to groups.
1606         $generator->create_group_member(array('groupid' => $group2->id, 'userid' => $user1->id));
1607         $generator->create_group_member(array('groupid' => $group3->id, 'userid' => $user1->id));
1608         $generator->create_group_member(array('groupid' => $group3->id, 'userid' => $user2->id));
1609         $generator->create_group_member(array('groupid' => $group6->id, 'userid' => $user1->id));
1610         $generator->create_group_member(array('groupid' => $group7->id, 'userid' => $user1->id));
1611         $generator->create_group_member(array('groupid' => $group8->id, 'userid' => $user1->id));
1612         $generator->create_group_member(array('groupid' => $group8->id, 'userid' => $user2->id));
1613         $generator->create_group_member(array('groupid' => $group9->id, 'userid' => $user1->id));
1614         $generator->create_group_member(array('groupid' => $group9->id, 'userid' => $user2->id));
1615
1616         // The process of modifying group members changes the timemodified of the group.
1617         // Refresh the group records.
1618         $group1 = $DB->get_record('groups', ['id' => $group1->id]);
1619         $group2 = $DB->get_record('groups', ['id' => $group2->id]);
1620         $group3 = $DB->get_record('groups', ['id' => $group3->id]);
1621         $group4 = $DB->get_record('groups', ['id' => $group4->id]);
1622         $group5 = $DB->get_record('groups', ['id' => $group5->id]);
1623         $group6 = $DB->get_record('groups', ['id' => $group6->id]);
1624         $group7 = $DB->get_record('groups', ['id' => $group7->id]);
1625         $group8 = $DB->get_record('groups', ['id' => $group8->id]);
1626         $group9 = $DB->get_record('groups', ['id' => $group9->id]);
1627
1628         $result = groups_get_all_groups_for_courses($courses);
1629         $assertpropertiesmatch = function($expected, $actual) {
1630             $props = get_object_vars($expected);
1631
1632             foreach ($props as $name => $val) {
1633                 $got = $actual->{$name};
1634                 $this->assertEquals(
1635                     $val,
1636                     $actual->{$name},
1637                     "Failed asserting that {$got} equals {$val} for property {$name}"
1638                 );
1639             }
1640         };
1641
1642         // Course 1 has no groups.
1643         $this->assertEquals([], $result[$course1->id]);
1644
1645         // Course 2 has one group with no members.
1646         $coursegroups = $result[$course2->id];
1647         $coursegroup = $coursegroups[$group1->id];
1648         $this->assertCount(1, $coursegroups);
1649         $this->assertEquals([], $coursegroup->members);
1650         $assertpropertiesmatch($group1, $coursegroup);
1651
1652         // Course 3 has one group with one member.
1653         $coursegroups = $result[$course3->id];
1654         $coursegroup = $coursegroups[$group2->id];
1655         $groupmember1 = $coursegroup->members[$user1->id];
1656         $this->assertCount(1, $coursegroups);
1657         $this->assertCount(1, $coursegroup->members);
1658         $assertpropertiesmatch($group2, $coursegroup);
1659         $this->assertEquals($user1->id, $groupmember1->userid);
1660
1661         // Course 4 has one group with multiple members.
1662         $coursegroups = $result[$course4->id];
1663         $coursegroup = $coursegroups[$group3->id];
1664         $groupmember1 = $coursegroup->members[$user1->id];
1665         $groupmember2 = $coursegroup->members[$user2->id];
1666         $this->assertCount(1, $coursegroups);
1667         $this->assertCount(2, $coursegroup->members);
1668         $assertpropertiesmatch($group3, $coursegroup);
1669         $this->assertEquals($user1->id, $groupmember1->userid);
1670         $this->assertEquals($user2->id, $groupmember2->userid);
1671
1672         // Course 5 has multiple groups with no members.
1673         $coursegroups = $result[$course5->id];
1674         $coursegroup1 = $coursegroups[$group4->id];
1675         $coursegroup2 = $coursegroups[$group5->id];
1676         $this->assertCount(2, $coursegroups);
1677         $this->assertEquals([], $coursegroup1->members);
1678         $this->assertEquals([], $coursegroup2->members);
1679         $assertpropertiesmatch($group4, $coursegroup1);
1680         $assertpropertiesmatch($group5, $coursegroup2);
1681
1682         // Course 6 has multiple groups with one member.
1683         $coursegroups = $result[$course6->id];
1684         $coursegroup1 = $coursegroups[$group6->id];
1685         $coursegroup2 = $coursegroups[$group7->id];
1686         $group1member1 = $coursegroup1->members[$user1->id];
1687         $group2member1 = $coursegroup2->members[$user1->id];
1688         $this->assertCount(2, $coursegroups);
1689         $this->assertCount(1, $coursegroup1->members);
1690         $this->assertCount(1, $coursegroup2->members);
1691         $assertpropertiesmatch($group6, $coursegroup1);
1692         $assertpropertiesmatch($group7, $coursegroup2);
1693         $this->assertEquals($user1->id, $group1member1->userid);
1694         $this->assertEquals($user1->id, $group2member1->userid);
1695
1696         // Course 7 has multiple groups with multiple members.
1697         $coursegroups = $result[$course7->id];
1698         $coursegroup1 = $coursegroups[$group8->id];
1699         $coursegroup2 = $coursegroups[$group9->id];
1700         $group1member1 = $coursegroup1->members[$user1->id];
1701         $group1member2 = $coursegroup1->members[$user2->id];
1702         $group2member1 = $coursegroup2->members[$user1->id];
1703         $group2member2 = $coursegroup2->members[$user2->id];
1704         $this->assertCount(2, $coursegroups);
1705         $this->assertCount(2, $coursegroup1->members);
1706         $this->assertCount(2, $coursegroup2->members);
1707         $assertpropertiesmatch($group8, $coursegroup1);
1708         $assertpropertiesmatch($group9, $coursegroup2);
1709         $this->assertEquals($user1->id, $group1member1->userid);
1710         $this->assertEquals($user2->id, $group1member2->userid);
1711         $this->assertEquals($user1->id, $group2member1->userid);
1712         $this->assertEquals($user2->id, $group2member2->userid);
1713     }
1714 }