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 events subsystems
  19  *
  20  * @package    core
  21  * @subpackage group
  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 class grouplib_testcase extends advanced_testcase {
  30
  31     public function test_groups_get_group_by_idnumber() {
  32         $this->resetAfterTest(true);
  33
  34         $generator = $this->getDataGenerator();
  35
  36         // Create a course category and course
  37         $cat = $generator->create_category(array('parent' => 0));
  38         $course = $generator->create_course(array('category' => $cat->id));
  39
  40         $idnumber1 = 'idnumber1';
  41         $idnumber2 = 'idnumber2';
  42
  43         /**
  44          * Test with an empty and a null idnumber
  45          */
  46         // An empty idnumber should always return a false value
  47         $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  48         $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  49
  50         // Even when a group exists which also has an empty idnumber
  51         $generator->create_group(array('courseid' => $course->id));
  52         $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  53         $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  54
  55         /**
  56          * Test with a valid idnumber
  57          */
  58         // There is no matching idnumber at present
  59         $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber1));
  60
  61         // We should now have a valid group returned by the idnumber search
  62         $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber1));
  63         $this->assertEquals(groups_get_group_by_idnumber($course->id, $idnumber1), $group);
  64
  65         // An empty idnumber should still return false
  66         $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  67         $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  68
  69         /**
  70          * Test with another idnumber
  71          */
  72         // There is no matching idnumber at present
  73         $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber2));
  74
  75         // We should now have a valid group returned by the idnumber search
  76         $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber2));
  77         $this->assertEquals(groups_get_group_by_idnumber($course->id, $idnumber2), $group);
  78
  79         /**
  80          * Group idnumbers are unique within a course so test that we don't
  81          * retrieve groups for the first course
  82          */
  83
  84         // Create a second course
  85         $course = $generator->create_course(array('category' => $cat->id));
  86
  87         // An empty idnumber should always return a false value
  88         $this->assertFalse(groups_get_group_by_idnumber($course->id, ''));
  89         $this->assertFalse(groups_get_group_by_idnumber($course->id, null));
  90
  91         // Our existing idnumbers shouldn't be returned here as we're in a different course
  92         $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber1));
  93         $this->assertFalse(groups_get_group_by_idnumber($course->id, $idnumber2));
  94
  95         // We should be able to reuse the idnumbers again since this is a different course
  96         $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber1));
  97         $this->assertEquals(groups_get_group_by_idnumber($course->id, $idnumber1), $group);
  98
  99         $group = $generator->create_group(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 100         $this->assertEquals(groups_get_group_by_idnumber($course->id, $idnumber2), $group);
 101     }
 102
 103     public function test_groups_get_grouping_by_idnumber() {
 104         $this->resetAfterTest(true);
 105
 106         $generator = $this->getDataGenerator();
 107
 108         // Create a course category and course
 109         $cat = $generator->create_category(array('parent' => 0));
 110         $course = $generator->create_course(array('category' => $cat->id));
 111
 112         $idnumber1 = 'idnumber1';
 113         $idnumber2 = 'idnumber2';
 114
 115         /**
 116          * Test with an empty and a null idnumber
 117          */
 118         // An empty idnumber should always return a false value
 119         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 120         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 121
 122         // Even when a grouping exists which also has an empty idnumber
 123         $generator->create_grouping(array('courseid' => $course->id));
 124         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 125         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 126
 127         /**
 128          * Test with a valid idnumber
 129          */
 130         // There is no matching idnumber at present
 131         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber1));
 132
 133         // We should now have a valid group returned by the idnumber search
 134         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber1));
 135         $this->assertEquals(groups_get_grouping_by_idnumber($course->id, $idnumber1), $grouping);
 136
 137         // An empty idnumber should still return false
 138         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 139         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 140
 141         /**
 142          * Test with another idnumber
 143          */
 144         // There is no matching idnumber at present
 145         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber2));
 146
 147         // We should now have a valid grouping returned by the idnumber search
 148         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 149         $this->assertEquals(groups_get_grouping_by_idnumber($course->id, $idnumber2), $grouping);
 150
 151         /**
 152          * Grouping idnumbers are unique within a course so test that we don't
 153          * retrieve groupings for the first course
 154          */
 155
 156         // Create a second course
 157         $course = $generator->create_course(array('category' => $cat->id));
 158
 159         // An empty idnumber should always return a false value
 160         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, ''));
 161         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, null));
 162
 163         // Our existing idnumbers shouldn't be returned here as we're in a different course
 164         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber1));
 165         $this->assertFalse(groups_get_grouping_by_idnumber($course->id, $idnumber2));
 166
 167         // We should be able to reuse the idnumbers again since this is a different course
 168         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber1));
 169         $this->assertEquals(groups_get_grouping_by_idnumber($course->id, $idnumber1), $grouping);
 170
 171         $grouping = $generator->create_grouping(array('courseid' => $course->id, 'idnumber' => $idnumber2));
 172         $this->assertEquals(groups_get_grouping_by_idnumber($course->id, $idnumber2), $grouping);
 173     }
 174
 175     public function test_groups_get_group_by_name() {
 176         $this->resetAfterTest(true);
 177
 178         $generator = $this->getDataGenerator();
 179
 180         // Create a course category and course
 181         $cat = $generator->create_category(array('parent' => 0));
 182         $course = $generator->create_course(array('category' => $cat->id));
 183
 184         $name1 = 'Name 1';
 185         $name2 = 'Name 2';
 186
 187         // Test with an empty and a null idnumber
 188         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 189         $this->assertFalse(groups_get_group_by_name($course->id, null));
 190
 191         // Even when a group exists.
 192         $generator->create_group(array('courseid' => $course->id));
 193         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 194         $this->assertFalse(groups_get_group_by_name($course->id, null));
 195
 196         // Test with a valid name, but one that doesn't exist yet.
 197         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 198         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 199
 200         // We should now have a valid group returned by the name search.
 201         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 202         $this->assertEquals(groups_get_group_by_name($course->id, $name1), $group1->id);
 203         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 204
 205         // We should now have a two valid groups returned by the name search.
 206         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 207         $this->assertEquals(groups_get_group_by_name($course->id, $name1), $group1->id);
 208         $this->assertEquals(groups_get_group_by_name($course->id, $name2), $group2->id);
 209
 210         // Delete a group.
 211         $this->assertTrue(groups_delete_group($group1));
 212         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 213         $this->assertEquals(groups_get_group_by_name($course->id, $name2), $group2->id);
 214
 215         /**
 216          * Group idnumbers are unique within a course so test that we don't
 217          * retrieve groups for the first course
 218          */
 219
 220         // Create a second course
 221         $course = $generator->create_course(array('category' => $cat->id));
 222
 223         // An empty name should always return a false value
 224         $this->assertFalse(groups_get_group_by_name($course->id, ''));
 225         $this->assertFalse(groups_get_group_by_name($course->id, null));
 226
 227         // Our existing names shouldn't be returned here as we're in a different course
 228         $this->assertFalse(groups_get_group_by_name($course->id, $name1));
 229         $this->assertFalse(groups_get_group_by_name($course->id, $name2));
 230
 231         // We should be able to reuse the idnumbers again since this is a different course
 232         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => $name1));
 233         $this->assertEquals(groups_get_group_by_name($course->id, $name1), $group1->id);
 234
 235         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => $name2));
 236         $this->assertEquals(groups_get_group_by_name($course->id, $name2), $group2->id);
 237     }
 238
 239     public function test_groups_get_grouping() {
 240         $this->resetAfterTest(true);
 241
 242         $generator = $this->getDataGenerator();
 243
 244         // Create a course category and course
 245         $cat = $generator->create_category(array('parent' => 0));
 246         $course = $generator->create_course(array('category' => $cat->id));
 247
 248         $name1 = 'Grouping 1';
 249         $name2 = 'Grouping 2';
 250
 251         // Test with an empty and a null idnumber
 252         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 253         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 254
 255         // Even when a group exists.
 256         $generator->create_group(array('courseid' => $course->id));
 257         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 258         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 259
 260         // Test with a valid name, but one that doesn't exist yet.
 261         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 262         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 263
 264         // We should now have a valid group returned by the name search.
 265         $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 266         $this->assertEquals(groups_get_grouping_by_name($course->id, $name1), $group1->id);
 267         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 268
 269         // We should now have a two valid groups returned by the name search.
 270         $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 271         $this->assertEquals(groups_get_grouping_by_name($course->id, $name1), $group1->id);
 272         $this->assertEquals(groups_get_grouping_by_name($course->id, $name2), $group2->id);
 273
 274         // Delete a group.
 275         $this->assertTrue(groups_delete_grouping($group1));
 276         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 277         $this->assertEquals(groups_get_grouping_by_name($course->id, $name2), $group2->id);
 278
 279         /**
 280          * Group idnumbers are unique within a course so test that we don't
 281          * retrieve groups for the first course
 282          */
 283
 284         // Create a second course
 285         $course = $generator->create_course(array('category' => $cat->id));
 286
 287         // An empty name should always return a false value
 288         $this->assertFalse(groups_get_grouping_by_name($course->id, ''));
 289         $this->assertFalse(groups_get_grouping_by_name($course->id, null));
 290
 291         // Our existing names shouldn't be returned here as we're in a different course
 292         $this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
 293         $this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
 294
 295         // We should be able to reuse the idnumbers again since this is a different course
 296         $group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
 297         $this->assertEquals(groups_get_grouping_by_name($course->id, $name1), $group1->id);
 298
 299         $group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
 300         $this->assertEquals(groups_get_grouping_by_name($course->id, $name2), $group2->id);
 301     }
 302
 303     public function test_groups_get_course_data() {
 304         $this->resetAfterTest(true);
 305
 306         $generator = $this->getDataGenerator();
 307
 308         // Create a course category and course
 309         $cat = $generator->create_category(array('parent' => 0));
 310         $course = $generator->create_course(array('category' => $cat->id));
 311         $grouping1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 1'));
 312         $grouping2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => 'Grouping 2'));
 313         $group1 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 1'));
 314         $group2 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 2'));
 315         $group3 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 3'));
 316         $group4 = $generator->create_group(array('courseid' => $course->id, 'name' => 'Group 4'));
 317
 318         // Assign the groups to groupings.
 319         $this->assertTrue(groups_assign_grouping($grouping1->id, $group1->id));
 320         $this->assertTrue(groups_assign_grouping($grouping1->id, $group2->id));
 321         $this->assertTrue(groups_assign_grouping($grouping2->id, $group3->id));
 322         $this->assertTrue(groups_assign_grouping($grouping2->id, $group4->id));
 323
 324         // Get the data.
 325         $data = groups_get_course_data($course->id);
 326         $this->assertInstanceOf('stdClass', $data);
 327         $this->assertObjectHasAttribute('groups', $data);
 328         $this->assertObjectHasAttribute('groupings', $data);
 329         $this->assertObjectHasAttribute('mappings', $data);
 330
 331         // Test we have the expected items returns.
 332         $this->assertCount(4, $data->groups);
 333         $this->assertCount(2, $data->groupings);
 334         $this->assertCount(4, $data->mappings);
 335
 336         // Check we have the expected groups.
 337         $this->assertContains($group1->id, array_keys($data->groups));
 338         $this->assertContains($group2->id, array_keys($data->groups));
 339         $this->assertContains($group3->id, array_keys($data->groups));
 340         $this->assertContains($group4->id, array_keys($data->groups));
 341
 342         // Test a group-id is mapped correctly.
 343         $this->assertEquals($group3->name, $data->groups[$group3->id]->name);
 344
 345         // Check we have the expected number of groupings.
 346         $this->assertContains($grouping1->id, array_keys($data->groupings));
 347         $this->assertContains($grouping2->id, array_keys($data->groupings));
 348
 349         // Test a grouping-id is mapped correctly.
 350         $this->assertEquals($grouping2->name, $data->groupings[$grouping2->id]->name);
 351
 352         // Test that all of the mappings are correct.
 353         $grouping1maps = 0;
 354         $grouping2maps = 0;
 355         $group1maps = 0;
 356         $group2maps = 0;
 357         $group3maps = 0;
 358         $group4maps = 0;
 359         foreach ($data->mappings as $mapping) {
 360             if ($mapping->groupingid === $grouping1->id) {
 361                 $grouping1maps++;
 362                 $this->assertContains($mapping->groupid, array($group1->id, $group2->id));
 363             } else if ($mapping->groupingid === $grouping2->id) {
 364                 $grouping2maps++;
 365                 $this->assertContains($mapping->groupid, array($group3->id, $group4->id));
 366             } else {
 367                 $this->fail('Unexpected groupingid');
 368             }
 369             switch ($mapping->groupid) {
 370                 case $group1->id : $group1maps++; break;
 371                 case $group2->id : $group2maps++; break;
 372                 case $group3->id : $group3maps++; break;
 373                 case $group4->id : $group4maps++; break;
 374             }
 375         }
 376         $this->assertEquals(2, $grouping1maps);
 377         $this->assertEquals(2, $grouping2maps);
 378         $this->assertEquals(1, $group1maps);
 379         $this->assertEquals(1, $group2maps);
 380         $this->assertEquals(1, $group3maps);
 381         $this->assertEquals(1, $group4maps);
 382
 383         // Test the groups_get_all_groups which uses this functionality.
 384         $groups  = groups_get_all_groups($course->id);
 385         $groupkeys = array_keys($groups);
 386         $this->assertCount(4, $groups);
 387         $this->assertContains($group1->id, $groupkeys);
 388         $this->assertContains($group2->id, $groupkeys);
 389         $this->assertContains($group3->id, $groupkeys);
 390         $this->assertContains($group4->id, $groupkeys);
 391
 392         $groups  = groups_get_all_groups($course->id, null, $grouping1->id);
 393         $groupkeys = array_keys($groups);
 394         $this->assertCount(2, $groups);
 395         $this->assertContains($group1->id, $groupkeys);
 396         $this->assertContains($group2->id, $groupkeys);
 397         $this->assertNotContains($group3->id, $groupkeys);
 398         $this->assertNotContains($group4->id, $groupkeys);
 399
 400         $groups  = groups_get_all_groups($course->id, null, $grouping2->id);
 401         $groupkeys = array_keys($groups);
 402         $this->assertCount(2, $groups);
 403         $this->assertNotContains($group1->id, $groupkeys);
 404         $this->assertNotContains($group2->id, $groupkeys);
 405         $this->assertContains($group3->id, $groupkeys);
 406         $this->assertContains($group4->id, $groupkeys);
 407     }
 408 }