2 // This file is part of Moodle - http://moodle.org/
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.
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.
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/>.
18 * Tests groups subsystems.
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
27 defined('MOODLE_INTERNAL') ||
die();
30 * Unit tests for lib/grouplib.php
33 class core_grouplib_testcase
extends advanced_testcase
{
35 public function test_groups_get_group_by_idnumber() {
36 $this->resetAfterTest(true);
38 $generator = $this->getDataGenerator();
40 // Create a course category and course.
41 $cat = $generator->create_category(array('parent' => 0));
42 $course = $generator->create_course(array('category' => $cat->id
));
44 $idnumber1 = 'idnumber1';
45 $idnumber2 = 'idnumber2';
48 * Test with an empty and a null idnumber.
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));
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));
60 * Test with a valid idnumber.
62 // There is no matching idnumber at present.
63 $this->assertFalse(groups_get_group_by_idnumber($course->id
, $idnumber1));
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));
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));
74 * Test with another idnumber.
76 // There is no matching idnumber at present.
77 $this->assertFalse(groups_get_group_by_idnumber($course->id
, $idnumber2));
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));
84 * Group idnumbers are unique within a course so test that we don't
85 * retrieve groups for the first course.
88 // Create a second course.
89 $course = $generator->create_course(array('category' => $cat->id
));
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));
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));
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));
103 $group = $generator->create_group(array('courseid' => $course->id
, 'idnumber' => $idnumber2));
104 $this->assertEquals($group, groups_get_group_by_idnumber($course->id
, $idnumber2));
107 public function test_groups_get_grouping_by_idnumber() {
108 $this->resetAfterTest(true);
110 $generator = $this->getDataGenerator();
112 // Create a course category and course.
113 $cat = $generator->create_category(array('parent' => 0));
114 $course = $generator->create_course(array('category' => $cat->id
));
116 $idnumber1 = 'idnumber1';
117 $idnumber2 = 'idnumber2';
120 * Test with an empty and a null idnumber.
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));
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));
132 * Test with a valid idnumber
134 // There is no matching idnumber at present.
135 $this->assertFalse(groups_get_grouping_by_idnumber($course->id
, $idnumber1));
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));
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));
146 * Test with another idnumber.
148 // There is no matching idnumber at present.
149 $this->assertFalse(groups_get_grouping_by_idnumber($course->id
, $idnumber2));
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));
156 * Grouping idnumbers are unique within a course so test that we don't
157 * retrieve groupings for the first course.
160 // Create a second course.
161 $course = $generator->create_course(array('category' => $cat->id
));
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));
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));
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));
175 $grouping = $generator->create_grouping(array('courseid' => $course->id
, 'idnumber' => $idnumber2));
176 $this->assertEquals($grouping, groups_get_grouping_by_idnumber($course->id
, $idnumber2));
180 public function test_groups_get_members_ids_sql() {
183 $this->resetAfterTest(true);
185 $generator = $this->getDataGenerator();
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
,
197 $this->assertNotEquals($instance, false);
199 // Enrol the user in the course.
200 $plugin->enrol_user($instance, $student->id
, $role->id
);
202 list($sql, $params) = groups_get_members_ids_sql($group->id
, true);
204 // Test an empty group.
205 $users = $DB->get_records_sql($sql, $params);
207 $this->assertFalse(array_key_exists($student->id
, $users));
208 groups_add_member($group->id
, $student->id
);
210 // Test with a group member.
211 $users = $DB->get_records_sql($sql, $params);
212 $this->assertTrue(array_key_exists($student->id
, $users));
215 public function test_groups_get_group_by_name() {
216 $this->resetAfterTest(true);
218 $generator = $this->getDataGenerator();
220 // Create a course category and course.
221 $cat = $generator->create_category(array('parent' => 0));
222 $course = $generator->create_course(array('category' => $cat->id
));
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));
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));
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));
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));
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));
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));
256 * Group idnumbers are unique within a course so test that we don't
257 * retrieve groups for the first course.
260 // Create a second course.
261 $course = $generator->create_course(array('category' => $cat->id
));
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));
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));
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));
275 $group2 = $generator->create_group(array('courseid' => $course->id
, 'name' => $name2));
276 $this->assertEquals($group2->id
, groups_get_group_by_name($course->id
, $name2));
279 public function test_groups_get_grouping() {
280 $this->resetAfterTest(true);
282 $generator = $this->getDataGenerator();
284 // Create a course category and course.
285 $cat = $generator->create_category(array('parent' => 0));
286 $course = $generator->create_course(array('category' => $cat->id
));
288 $name1 = 'Grouping 1';
289 $name2 = 'Grouping 2';
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));
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));
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));
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));
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));
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));
320 * Group idnumbers are unique within a course so test that we don't
321 * retrieve groups for the first course.
324 // Create a second course.
325 $course = $generator->create_course(array('category' => $cat->id
));
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));
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));
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));
339 $group2 = $generator->create_grouping(array('courseid' => $course->id
, 'name' => $name2));
340 $this->assertEquals($group2->id
, groups_get_grouping_by_name($course->id
, $name2));
343 public function test_groups_get_course_data() {
344 $this->resetAfterTest(true);
346 $generator = $this->getDataGenerator();
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'));
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
));
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);
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
);
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
);
382 // Test a group-id is mapped correctly.
383 $this->assertSame($group3->name
, $data->groups
[$group3->id
]->name
);
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
));
389 // Test a grouping-id is mapped correctly.
390 $this->assertEquals($grouping2->name
, $data->groupings
[$grouping2->id
]->name
);
392 // Test that all of the mappings are correct.
399 foreach ($data->mappings
as $mapping) {
400 if ($mapping->groupingid
=== $grouping1->id
) {
402 $this->assertContains($mapping->groupid
, array($group1->id
, $group2->id
));
403 } else if ($mapping->groupingid
=== $grouping2->id
) {
405 $this->assertContains($mapping->groupid
, array($group3->id
, $group4->id
));
407 $this->fail('Unexpected groupingid');
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;
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);
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);
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);
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);
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
);
458 * Tests for groups_group_visible.
460 public function test_groups_group_visible() {
463 $generator = $this->getDataGenerator();
464 $this->resetAfterTest();
465 $this->setAdminUser();
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'));
477 $assign = $generator->create_module("assign", array('course' => $course->id
));
478 $cm = get_coursemodule_from_instance("assign", $assign->id
);
481 $user1 = $generator->create_user();
482 $user2 = $generator->create_user();
483 $user3 = $generator->create_user();
485 // Enrol users into the course.
486 $generator->enrol_user($user1->id
, $course->id
);
487 $generator->enrol_user($user2->id
, $course->id
);
490 groups_add_member($group1, $user2);
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
);
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.
504 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
505 $this->assertTrue($result); // Cm with no groups.
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.
513 $cm->groupmode
= VISIBLEGROUPS
;
514 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
515 $this->assertTrue($result); // Cm with visible groups.
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.
526 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
527 $this->assertTrue($result); // Cm with no groups.
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.
535 $cm->groupmode
= SEPARATEGROUPS
;
536 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
537 $this->assertTrue($result); // Cm with visible groups.
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.
548 $cm->groupmode
= NOGROUPS
;
549 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
550 $this->assertTrue($result); // Cm with no groups.
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.
558 $cm->groupmode
= VISIBLEGROUPS
;
559 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
560 $this->assertTrue($result); // Cm with visible groups.
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.
571 $cm->groupmode
= NOGROUPS
;
572 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
573 $this->assertTrue($result); // Cm with no groups.
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.
581 $cm->groupmode
= VISIBLEGROUPS
;
582 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
583 $this->assertTrue($result); // Cm with visible groups.
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.
600 $cm->groupmode
= NOGROUPS
;
601 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
602 $this->assertFalse($result); // Cm with no groups.
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.
612 $cm->groupmode
= VISIBLEGROUPS
;
613 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
614 $this->assertFalse($result); // Cm with visible groups.
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.
629 $cm->groupmode
= NOGROUPS
;
630 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
631 $this->assertTrue($result); // Cm with no groups.
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.
639 $cm->groupmode
= VISIBLEGROUPS
;
640 $result = groups_group_visible($group1->id
, $course, $cm, $user1->id
);
641 $this->assertTrue($result); // Cm with visible groups.
644 function test_groups_get_groupmode() {
646 $generator = $this->getDataGenerator();
647 $this->resetAfterTest();
648 $this->setAdminUser();
650 // Create a course with no groups forcing.
651 $course1 = $generator->create_course();
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
));
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
);
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
]));
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
);
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
]));
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
);
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
]));
713 * Tests for groups_allgroups_course_menu() .
715 public function test_groups_allgroups_course_menu() {
718 $this->resetAfterTest();
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);
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);
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);
742 $this->setAdminUser();
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);
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);
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);
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
]);
776 * This unit test checks that groups_get_all_groups returns groups in
777 * alphabetical order even if they are in a grouping.
779 public function test_groups_ordering() {
780 $generator = $this->getDataGenerator();
781 $this->resetAfterTest();
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'));
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'));
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
));
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
);
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
);
808 * Tests for groups_get_user_groups() method.
810 public function test_groups_get_user_groups() {
811 $this->resetAfterTest(true);
812 $generator = $this->getDataGenerator();
815 $course1 = $generator->create_course();
816 $course2 = $generator->create_course();
819 $user1 = $generator->create_user();
820 $user2 = $generator->create_user();
821 $user3 = $generator->create_user();
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
);
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
));
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
)));
839 $usergroups1 = groups_get_user_groups($course1->id
, $user1->id
);
840 $usergroups2 = groups_get_user_groups($course2->id
, $user2->id
);;
842 // Assert return data.
843 $this->assertEquals($group1->id
, $usergroups1[0][0]);
844 $this->assertEquals($group2->id
, $usergroups2[0][0]);
846 // Now, test with groupings.
847 $grouping1 = $generator->create_grouping(array('courseid' => $course1->id
));
848 $grouping2 = $generator->create_grouping(array('courseid' => $course2->id
));
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
);
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);
861 // Test user without a group.
862 $usergroups1 = groups_get_user_groups($course2->id
, $user3->id
);
863 $this->assertCount(0, $usergroups1[0]);
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]);
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]);
879 * Create dummy groups array for use in menu tests
883 protected function make_group_list($number) {
884 $testgroups = array();
885 for ($a = 0; $a < $number; $a++
) {
886 $grp = new stdClass();
888 $grp->name
= 'test group ' . $grp->id
;
889 $testgroups[$grp->id
] = $grp;
894 public function test_groups_sort_menu_options_empty() {
895 $this->assertEquals(array(), groups_sort_menu_options(array(), array()));
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()));
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)));
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',
918 2 => array(get_string('othergroups', 'group') => array(
919 102 => 'test group 102',
920 103 => 'test group 103',
922 ), groups_sort_menu_options($this->make_group_list(4), $this->make_group_list(2)));
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',
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',
944 ), groups_sort_menu_options($this->make_group_list(13), $this->make_group_list(2)));
948 * Tests for groups_user_groups_visible.
950 public function test_groups_user_groups_visible() {
953 $generator = $this->getDataGenerator();
954 $this->resetAfterTest();
955 $this->setAdminUser();
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'));
967 $assign = $generator->create_module("assign", array('course' => $course->id
));
968 $cm = get_coursemodule_from_instance("assign", $assign->id
);
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.
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
);
982 // User1 and User4 share groups.
983 groups_add_member($group1, $user1);
984 groups_add_member($group2, $user2);
985 groups_add_member($group1, $user4);
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
);
993 // Normal users in different groups.
994 $this->setUser($user1);
996 // No groups , not forced.
997 $result = groups_user_groups_visible($course, $user2->id
);
998 $this->assertTrue($result);
1000 $result = groups_user_groups_visible($course, $user2->id
);
1001 $this->assertTrue($result); // Cm with no groups.
1003 $cm->groupmode
= SEPARATEGROUPS
;
1004 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1005 $this->assertFalse($result); // Cm with separate groups.
1007 $cm->groupmode
= VISIBLEGROUPS
;
1008 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1009 $this->assertTrue($result); // Cm with visible groups.
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);
1018 $result = groups_user_groups_visible($course, $user2->id
);
1019 $this->assertTrue($result); // Cm with no groups.
1021 $cm->groupmode
= SEPARATEGROUPS
;
1022 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1023 $this->assertTrue($result); // Cm with separate groups.
1025 $cm->groupmode
= SEPARATEGROUPS
;
1026 $result = groups_user_groups_visible($course, $user2->id
);
1027 $this->assertTrue($result); // Cm with visible groups.
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);
1036 $cm->groupmode
= NOGROUPS
;
1037 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1038 $this->assertTrue($result); // Cm with no groups.
1040 $cm->groupmode
= SEPARATEGROUPS
;
1041 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1042 $this->assertTrue($result); // Cm with separate groups.
1044 $cm->groupmode
= VISIBLEGROUPS
;
1045 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1046 $this->assertTrue($result); // Cm with visible groups.
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);
1055 $cm->groupmode
= NOGROUPS
;
1056 $result = groups_user_groups_visible($course, $user2->id
);
1057 $this->assertTrue($result); // Cm with no groups.
1059 $cm->groupmode
= SEPARATEGROUPS
;
1060 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1061 $this->assertFalse($result); // Cm with separate groups.
1063 $cm->groupmode
= VISIBLEGROUPS
;
1064 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1065 $this->assertTrue($result); // Cm with visible groups.
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);
1074 $result = groups_user_groups_visible($course, $user3->id
);
1075 $this->assertFalse($result); // Requesting all groups.
1077 $cm->groupmode
= NOGROUPS
;
1078 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1079 $this->assertFalse($result); // Cm with no groups.
1081 $cm->groupmode
= SEPARATEGROUPS
;
1082 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1083 $this->assertFalse($result); // Cm with separate groups.
1085 $result = groups_user_groups_visible($course, $user3->id
, $cm);
1086 $this->assertTrue($result);
1088 $cm->groupmode
= VISIBLEGROUPS
;
1089 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1090 $this->assertFalse($result); // Cm with visible groups.
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);
1099 $result = groups_user_groups_visible($course, $user3->id
);
1100 $this->assertFalse($result); // Requesting all groups.
1102 $cm->groupmode
= NOGROUPS
;
1103 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1104 $this->assertTrue($result); // Cm with no groups.
1106 $cm->groupmode
= SEPARATEGROUPS
;
1107 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1108 $this->assertFalse($result); // Cm with separate groups.
1110 $cm->groupmode
= VISIBLEGROUPS
;
1111 $result = groups_user_groups_visible($course, $user2->id
, $cm);
1112 $this->assertTrue($result); // Cm with visible groups.
1114 // Users sharing groups.
1116 // No groups , not forced.
1117 $course->groupmode
= NOGROUPS
;
1118 $course->groupmodeforce
= false;
1119 update_course($course);
1121 $result = groups_user_groups_visible($course, $user4->id
);
1122 $this->assertTrue($result);
1124 $result = groups_user_groups_visible($course, $user4->id
);
1125 $this->assertTrue($result); // Cm with no groups.
1127 $cm->groupmode
= SEPARATEGROUPS
;
1128 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1129 $this->assertTrue($result); // Cm with separate groups.
1131 $cm->groupmode
= VISIBLEGROUPS
;
1132 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1133 $this->assertTrue($result); // Cm with visible groups.
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);
1142 $result = groups_user_groups_visible($course, $user4->id
);
1143 $this->assertTrue($result); // Cm with no groups.
1145 $cm->groupmode
= SEPARATEGROUPS
;
1146 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1147 $this->assertTrue($result); // Cm with separate groups.
1149 $cm->groupmode
= SEPARATEGROUPS
;
1150 $result = groups_user_groups_visible($course, $user4->id
);
1151 $this->assertTrue($result); // Cm with visible groups.
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);
1160 $cm->groupmode
= NOGROUPS
;
1161 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1162 $this->assertTrue($result); // Cm with no groups.
1164 $cm->groupmode
= SEPARATEGROUPS
;
1165 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1166 $this->assertTrue($result); // Cm with separate groups.
1168 $cm->groupmode
= VISIBLEGROUPS
;
1169 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1170 $this->assertTrue($result); // Cm with visible groups.
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);
1179 $cm->groupmode
= NOGROUPS
;
1180 $result = groups_user_groups_visible($course, $user4->id
);
1181 $this->assertTrue($result); // Cm with no groups.
1183 $cm->groupmode
= SEPARATEGROUPS
;
1184 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1185 $this->assertTrue($result); // Cm with separate groups.
1187 $cm->groupmode
= VISIBLEGROUPS
;
1188 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1189 $this->assertTrue($result); // Cm with visible groups.
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);
1198 $result = groups_user_groups_visible($course, $user3->id
);
1199 $this->assertFalse($result); // Requesting all groups.
1201 $cm->groupmode
= NOGROUPS
;
1202 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1203 $this->assertTrue($result); // Cm with no groups.
1205 $cm->groupmode
= SEPARATEGROUPS
;
1206 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1207 $this->assertTrue($result); // Cm with separate groups.
1209 $result = groups_user_groups_visible($course, $user3->id
, $cm);
1210 $this->assertTrue($result);
1212 $cm->groupmode
= VISIBLEGROUPS
;
1213 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1214 $this->assertTrue($result); // Cm with visible groups.
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);
1223 $result = groups_user_groups_visible($course, $user3->id
);
1224 $this->assertFalse($result); // Requesting all groups.
1226 $cm->groupmode
= NOGROUPS
;
1227 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1228 $this->assertTrue($result); // Cm with no groups.
1230 $cm->groupmode
= SEPARATEGROUPS
;
1231 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1232 $this->assertTrue($result); // Cm with separate groups.
1234 $cm->groupmode
= VISIBLEGROUPS
;
1235 $result = groups_user_groups_visible($course, $user4->id
, $cm);
1236 $this->assertTrue($result); // Cm with visible groups.
1238 // For teacher with access all groups.
1240 // No groups , not forced.
1241 $course->groupmode
= NOGROUPS
;
1242 $course->groupmodeforce
= false;
1243 update_course($course);
1245 $this->setUser($user3);
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.
1252 $result = groups_user_groups_visible($course, $user1->id
);
1253 $this->assertTrue($result); // Cm with no groups.
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.
1261 $cm->groupmode
= VISIBLEGROUPS
;
1262 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1263 $this->assertTrue($result); // Cm with visible groups.
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.
1274 $result = groups_user_groups_visible($course, $user1->id
);
1275 $this->assertTrue($result); // Cm with no groups.
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.
1283 $cm->groupmode
= SEPARATEGROUPS
;
1284 $result = groups_user_groups_visible($course, $user1->id
);
1285 $this->assertTrue($result); // Cm with visible groups.
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.
1296 $cm->groupmode
= NOGROUPS
;
1297 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1298 $this->assertTrue($result); // Cm with no groups.
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.
1306 $cm->groupmode
= VISIBLEGROUPS
;
1307 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1308 $this->assertTrue($result); // Cm with visible groups.
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.
1319 $cm->groupmode
= NOGROUPS
;
1320 $result = groups_user_groups_visible($course, $user1->id
);
1321 $this->assertTrue($result); // Cm with no groups.
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.
1329 $cm->groupmode
= VISIBLEGROUPS
;
1330 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1331 $this->assertTrue($result); // Cm with visible groups.
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);
1348 $cm->groupmode
= NOGROUPS
;
1349 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1350 $this->assertTrue($result); // Cm with no groups.
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);
1360 $cm->groupmode
= VISIBLEGROUPS
;
1361 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1362 $this->assertTrue($result); // Cm with visible groups.
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.
1377 $cm->groupmode
= NOGROUPS
;
1378 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1379 $this->assertTrue($result); // Cm with no groups.
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.
1387 $cm->groupmode
= VISIBLEGROUPS
;
1388 $result = groups_user_groups_visible($course, $user1->id
, $cm);
1389 $this->assertTrue($result); // Cm with visible groups.