public function test_list_participants()
 {
     global $CFG, $DB;
     $this->create_extra_users();
     $this->setUser($this->editingteachers[0]);
     $assign = $this->create_instance(array('grade' => 100));
     $this->assertEquals(self::DEFAULT_STUDENT_COUNT + self::EXTRA_STUDENT_COUNT, count($assign->list_participants(null, true)));
     // Teacher with user preference set should see suspended users as well.
     set_user_preference('grade_report_showonlyactiveenrol', false);
     $assign = $this->create_instance(array('grade' => 100));
     $this->assertEquals(self::DEFAULT_STUDENT_COUNT + self::EXTRA_STUDENT_COUNT + self::EXTRA_SUSPENDED_COUNT, count($assign->list_participants(null, true)));
     // Non-editing teacher should not see suspended users, even if user preference is set.
     $this->setUser($this->teachers[0]);
     set_user_preference('grade_report_showonlyactiveenrol', false);
     $assign = $this->create_instance(array('grade' => 100));
     $this->assertEquals(self::DEFAULT_STUDENT_COUNT + self::EXTRA_STUDENT_COUNT, count($assign->list_participants(null, true)));
     // Turn on availability and a group restriction, and check that it doesn't
     // show users who aren't in the group.
     $CFG->enableavailability = true;
     $specialgroup = $this->getDataGenerator()->create_group(array('courseid' => $this->course->id));
     $assign = $this->create_instance(array('grade' => 100, 'availability' => json_encode(\core_availability\tree::get_root_json(array(\availability_group\condition::get_json($specialgroup->id))))));
     groups_add_member($specialgroup, $this->students[0]);
     groups_add_member($specialgroup, $this->students[1]);
     $this->assertEquals(2, count($assign->list_participants(null, true)));
 }
Example #2
0
 /**
  * Tests the filter_users (bulk checking) function. Also tests the SQL
  * variant get_user_list_sql.
  */
 public function test_filter_users()
 {
     global $DB;
     $this->resetAfterTest();
     // Erase static cache before test.
     condition::wipe_static_cache();
     // Make a test course and some users.
     $generator = $this->getDataGenerator();
     $course = $generator->create_course();
     $roleids = $DB->get_records_menu('role', null, '', 'shortname, id');
     $teacher = $generator->create_user();
     $generator->enrol_user($teacher->id, $course->id, $roleids['editingteacher']);
     $allusers = array($teacher->id => $teacher);
     $students = array();
     for ($i = 0; $i < 3; $i++) {
         $student = $generator->create_user();
         $students[$i] = $student;
         $generator->enrol_user($student->id, $course->id, $roleids['student']);
         $allusers[$student->id] = $student;
     }
     $info = new \core_availability\mock_info($course);
     // Make test groups.
     $group1 = $generator->create_group(array('courseid' => $course->id));
     $group2 = $generator->create_group(array('courseid' => $course->id));
     // Assign students to groups as follows (teacher is not in a group):
     // 0: no groups.
     // 1: in group 1.
     // 2: in group 2.
     groups_add_member($group1, $students[1]);
     groups_add_member($group2, $students[2]);
     // Test 'any group' condition.
     $checker = new \core_availability\capability_checker($info->get_context());
     $cond = new condition((object) array());
     $result = array_keys($cond->filter_user_list($allusers, false, $info, $checker));
     ksort($result);
     $expected = array($teacher->id, $students[1]->id, $students[2]->id);
     $this->assertEquals($expected, $result);
     // Test it with get_user_list_sql.
     list($sql, $params) = $cond->get_user_list_sql(false, $info, true);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals($expected, $result);
     // Test NOT version (note that teacher can still access because AAG works
     // both ways).
     $result = array_keys($cond->filter_user_list($allusers, true, $info, $checker));
     ksort($result);
     $expected = array($teacher->id, $students[0]->id);
     $this->assertEquals($expected, $result);
     // Test with get_user_list_sql.
     list($sql, $params) = $cond->get_user_list_sql(true, $info, true);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals($expected, $result);
     // Test specific group.
     $cond = new condition((object) array('id' => (int) $group1->id));
     $result = array_keys($cond->filter_user_list($allusers, false, $info, $checker));
     ksort($result);
     $expected = array($teacher->id, $students[1]->id);
     $this->assertEquals($expected, $result);
     list($sql, $params) = $cond->get_user_list_sql(false, $info, true);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals($expected, $result);
     $result = array_keys($cond->filter_user_list($allusers, true, $info, $checker));
     ksort($result);
     $expected = array($teacher->id, $students[0]->id, $students[2]->id);
     $this->assertEquals($expected, $result);
     list($sql, $params) = $cond->get_user_list_sql(true, $info, true);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals($expected, $result);
 }
Example #3
0
 /**
  * Tests get_user_list_sql.
  */
 public function test_get_user_list_sql()
 {
     global $DB;
     $this->resetAfterTest();
     $generator = $this->getDataGenerator();
     // Create a test course with 2 groups and users in each combination of them.
     $course = $generator->create_course();
     $group1 = $generator->create_group(array('courseid' => $course->id));
     $group2 = $generator->create_group(array('courseid' => $course->id));
     $userin1 = $generator->create_user();
     $userin2 = $generator->create_user();
     $userinboth = $generator->create_user();
     $userinneither = $generator->create_user();
     $studentroleid = $DB->get_field('role', 'id', array('shortname' => 'student'));
     foreach (array($userin1, $userin2, $userinboth, $userinneither) as $user) {
         $generator->enrol_user($user->id, $course->id, $studentroleid);
     }
     groups_add_member($group1, $userin1);
     groups_add_member($group2, $userin2);
     groups_add_member($group1, $userinboth);
     groups_add_member($group2, $userinboth);
     $info = new \core_availability\mock_info($course);
     // Tree with single group condition.
     $tree = new tree(tree::get_root_json(array(\availability_group\condition::get_json($group1->id))));
     list($sql, $params) = $tree->get_user_list_sql(false, $info, false);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals(array($userin1->id, $userinboth->id), $result);
     // Tree with 'AND' of both group conditions.
     $tree = new tree(tree::get_root_json(array(\availability_group\condition::get_json($group1->id), \availability_group\condition::get_json($group2->id))));
     list($sql, $params) = $tree->get_user_list_sql(false, $info, false);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals(array($userinboth->id), $result);
     // Tree with 'AND' of both group conditions.
     $tree = new tree(tree::get_root_json(array(\availability_group\condition::get_json($group1->id), \availability_group\condition::get_json($group2->id)), tree::OP_OR));
     list($sql, $params) = $tree->get_user_list_sql(false, $info, false);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals(array($userin1->id, $userin2->id, $userinboth->id), $result);
     // Check with flipped logic (NOT above level of tree).
     list($sql, $params) = $tree->get_user_list_sql(true, $info, false);
     $result = $DB->get_fieldset_sql($sql, $params);
     sort($result);
     $this->assertEquals(array($userinneither->id), $result);
 }
Example #4
0
 /**
  * Test convect fetching.
  */
 public function test_concept_fetching()
 {
     global $CFG, $DB;
     $this->resetAfterTest(true);
     $this->setAdminUser();
     $CFG->glossary_linkbydefault = 1;
     $CFG->glossary_linkentries = 0;
     // Create a test courses.
     $course1 = $this->getDataGenerator()->create_course();
     $course2 = $this->getDataGenerator()->create_course();
     $site = $DB->get_record('course', array('id' => SITEID));
     // Create a glossary.
     $glossary1a = $this->getDataGenerator()->create_module('glossary', array('course' => $course1->id, 'mainglossary' => 1, 'usedynalink' => 1));
     $glossary1b = $this->getDataGenerator()->create_module('glossary', array('course' => $course1->id, 'mainglossary' => 1, 'usedynalink' => 1));
     $glossary1c = $this->getDataGenerator()->create_module('glossary', array('course' => $course1->id, 'mainglossary' => 1, 'usedynalink' => 0));
     $glossary2 = $this->getDataGenerator()->create_module('glossary', array('course' => $course2->id, 'mainglossary' => 1, 'usedynalink' => 1));
     $glossary3 = $this->getDataGenerator()->create_module('glossary', array('course' => $site->id, 'mainglossary' => 1, 'usedynalink' => 1, 'globalglossary' => 1));
     /** @var mod_glossary_generator $generator */
     $generator = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
     $entry1a1 = $generator->create_content($glossary1a, array('concept' => 'first', 'usedynalink' => 1), array('prvni', 'erste'));
     $entry1a2 = $generator->create_content($glossary1a, array('concept' => 'A&B', 'usedynalink' => 1));
     $entry1a3 = $generator->create_content($glossary1a, array('concept' => 'neee', 'usedynalink' => 0));
     $entry1b1 = $generator->create_content($glossary1b, array('concept' => 'second', 'usedynalink' => 1));
     $entry1c1 = $generator->create_content($glossary1c, array('concept' => 'third', 'usedynalink' => 1));
     $entry31 = $generator->create_content($glossary3, array('concept' => 'global', 'usedynalink' => 1), array('globalni'));
     $cat1 = $generator->create_category($glossary1a, array('name' => 'special'), array($entry1a1, $entry1a2));
     \mod_glossary\local\concept_cache::reset_caches();
     $concepts1 = \mod_glossary\local\concept_cache::get_concepts($course1->id);
     $this->assertCount(3, $concepts1[0]);
     $this->arrayHasKey($concepts1[0], $glossary1a->id);
     $this->arrayHasKey($concepts1[0], $glossary1b->id);
     $this->arrayHasKey($concepts1[0], $glossary3->id);
     $this->assertCount(3, $concepts1[1]);
     $this->arrayHasKey($concepts1[1], $glossary1a->id);
     $this->arrayHasKey($concepts1[1], $glossary1b->id);
     $this->arrayHasKey($concepts1[0], $glossary3->id);
     $this->assertCount(5, $concepts1[1][$glossary1a->id]);
     foreach ($concepts1[1][$glossary1a->id] as $concept) {
         $this->assertSame(array('id', 'glossaryid', 'concept', 'casesensitive', 'category', 'fullmatch'), array_keys((array) $concept));
         if ($concept->concept === 'first') {
             $this->assertEquals($entry1a1->id, $concept->id);
             $this->assertEquals($glossary1a->id, $concept->glossaryid);
             $this->assertEquals(0, $concept->category);
         } else {
             if ($concept->concept === 'prvni') {
                 $this->assertEquals($entry1a1->id, $concept->id);
                 $this->assertEquals($glossary1a->id, $concept->glossaryid);
                 $this->assertEquals(0, $concept->category);
             } else {
                 if ($concept->concept === 'erste') {
                     $this->assertEquals($entry1a1->id, $concept->id);
                     $this->assertEquals($glossary1a->id, $concept->glossaryid);
                     $this->assertEquals(0, $concept->category);
                 } else {
                     if ($concept->concept === 'A&amp;B') {
                         $this->assertEquals($entry1a2->id, $concept->id);
                         $this->assertEquals($glossary1a->id, $concept->glossaryid);
                         $this->assertEquals(0, $concept->category);
                     } else {
                         if ($concept->concept === 'special') {
                             $this->assertEquals($cat1->id, $concept->id);
                             $this->assertEquals($glossary1a->id, $concept->glossaryid);
                             $this->assertEquals(1, $concept->category);
                         } else {
                             $this->fail('Unexpected concept: ' . $concept->concept);
                         }
                     }
                 }
             }
         }
     }
     $this->assertCount(1, $concepts1[1][$glossary1b->id]);
     foreach ($concepts1[1][$glossary1b->id] as $concept) {
         $this->assertSame(array('id', 'glossaryid', 'concept', 'casesensitive', 'category', 'fullmatch'), array_keys((array) $concept));
         if ($concept->concept === 'second') {
             $this->assertEquals($entry1b1->id, $concept->id);
             $this->assertEquals($glossary1b->id, $concept->glossaryid);
             $this->assertEquals(0, $concept->category);
         } else {
             $this->fail('Unexpected concept: ' . $concept->concept);
         }
     }
     $this->assertCount(2, $concepts1[1][$glossary3->id]);
     foreach ($concepts1[1][$glossary3->id] as $concept) {
         $this->assertSame(array('id', 'glossaryid', 'concept', 'casesensitive', 'category', 'fullmatch'), array_keys((array) $concept));
         if ($concept->concept === 'global') {
             $this->assertEquals($entry31->id, $concept->id);
             $this->assertEquals($glossary3->id, $concept->glossaryid);
             $this->assertEquals(0, $concept->category);
         } else {
             if ($concept->concept === 'globalni') {
                 $this->assertEquals($entry31->id, $concept->id);
                 $this->assertEquals($glossary3->id, $concept->glossaryid);
                 $this->assertEquals(0, $concept->category);
             } else {
                 $this->fail('Unexpected concept: ' . $concept->concept);
             }
         }
     }
     $concepts3 = \mod_glossary\local\concept_cache::get_concepts($site->id);
     $this->assertCount(1, $concepts3[0]);
     $this->arrayHasKey($concepts3[0], $glossary3->id);
     $this->assertCount(1, $concepts3[1]);
     $this->arrayHasKey($concepts3[0], $glossary3->id);
     foreach ($concepts3[1][$glossary3->id] as $concept) {
         $this->assertSame(array('id', 'glossaryid', 'concept', 'casesensitive', 'category', 'fullmatch'), array_keys((array) $concept));
         if ($concept->concept === 'global') {
             $this->assertEquals($entry31->id, $concept->id);
             $this->assertEquals($glossary3->id, $concept->glossaryid);
             $this->assertEquals(0, $concept->category);
         } else {
             if ($concept->concept === 'globalni') {
                 $this->assertEquals($entry31->id, $concept->id);
                 $this->assertEquals($glossary3->id, $concept->glossaryid);
                 $this->assertEquals(0, $concept->category);
             } else {
                 $this->fail('Unexpected concept: ' . $concept->concept);
             }
         }
     }
     $concepts2 = \mod_glossary\local\concept_cache::get_concepts($course2->id);
     $this->assertEquals($concepts3, $concepts2);
     // Test uservisible flag.
     set_config('enableavailability', 1);
     $glossary1d = $this->getDataGenerator()->create_module('glossary', array('course' => $course1->id, 'mainglossary' => 1, 'usedynalink' => 1, 'availability' => json_encode(\core_availability\tree::get_root_json(array(\availability_group\condition::get_json())))));
     $entry1d1 = $generator->create_content($glossary1d, array('concept' => 'membersonly', 'usedynalink' => 1));
     $user = $this->getDataGenerator()->create_user();
     $this->getDataGenerator()->enrol_user($user->id, $course1->id);
     $this->getDataGenerator()->enrol_user($user->id, $course2->id);
     \mod_glossary\local\concept_cache::reset_caches();
     $concepts1 = \mod_glossary\local\concept_cache::get_concepts($course1->id);
     $this->assertCount(4, $concepts1[0]);
     $this->assertCount(4, $concepts1[1]);
     $this->setUser($user);
     course_modinfo::clear_instance_cache();
     \mod_glossary\local\concept_cache::reset_caches();
     $concepts1 = \mod_glossary\local\concept_cache::get_concepts($course1->id);
     $this->assertCount(3, $concepts1[0]);
     $this->assertCount(3, $concepts1[1]);
 }
Example #5
0
 /**
  * Tests the update_all_dates function.
  */
 public function test_update_all_dates()
 {
     global $DB;
     $this->resetAfterTest();
     // Create a course with 3 pages.
     $generator = $this->getDataGenerator();
     $course = $generator->create_course();
     $rec = array('course' => $course);
     $page1 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
     $page2 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
     $page3 = $generator->get_plugin_generator('mod_page')->create_instance($rec);
     // Set the availability page 2 to a simple date condition. You can access
     // it from 1337 onwards.
     $simplecondition = tree::get_root_json(array(condition::get_json(condition::DIRECTION_FROM, 1337)));
     $DB->set_field('course_modules', 'availability', json_encode($simplecondition), array('id' => $page2->cmid));
     // Set page 3 to a complex set of conditions including a nested date condition.
     // You can access it until 1459, *or* after 2810 if you belong to a group.
     $complexcondition = tree::get_root_json(array(condition::get_json(condition::DIRECTION_UNTIL, 1459), tree::get_nested_json(array(condition::get_json(condition::DIRECTION_FROM, 2810), \availability_group\condition::get_json()))), tree::OP_OR);
     $DB->set_field('course_modules', 'availability', json_encode($complexcondition), array('id' => $page3->cmid));
     // Now use the update_all_dates function to move date forward 100000.
     condition::update_all_dates($course->id, 100000);
     // Get the expected conditions after adjusting time, and compare to database.
     $simplecondition->c[0]->t = 101337;
     $complexcondition->c[0]->t = 101459;
     $complexcondition->c[1]->c[0]->t = 102810;
     $this->assertEquals($simplecondition, json_decode($DB->get_field('course_modules', 'availability', array('id' => $page2->cmid))));
     $this->assertEquals($complexcondition, json_decode($DB->get_field('course_modules', 'availability', array('id' => $page3->cmid))));
     // The one without availability conditions should still be null.
     $this->assertNull($DB->get_field('course_modules', 'availability', array('id' => $page1->cmid)));
 }
 /**
  * Test upcoming deadlines restricted by group
  *
  * @throws \coding_exception
  */
 public function test_upcoming_deadlines_group()
 {
     global $DB;
     $this->resetAfterTest();
     $generator = $this->getDataGenerator();
     $course = $generator->create_course();
     $student1 = $generator->create_user();
     $student2 = $generator->create_user();
     $teacher = $generator->create_user();
     $group1 = $this->create_group($course->id, 'group1');
     $group2 = $this->create_group($course->id, 'group2');
     // Enrol students.
     $studentrole = $DB->get_record('role', array('shortname' => 'student'));
     foreach ([$student1, $student2] as $student) {
         $generator->enrol_user($student->id, $course->id, $studentrole->id);
     }
     // Enrol teacher.
     $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
     $generator->enrol_user($teacher->id, $course->id, $teacherrole->id);
     // Add students to groups.
     groups_add_member($group1, $student1);
     groups_add_member($group2, $student2);
     // Create assignment restricted to group1.
     $opts = ['availability' => json_encode(\core_availability\tree::get_root_json([\availability_group\condition::get_json($group1->id)]))];
     $duedate1 = time() + DAYSECS * 2;
     $this->create_assignment($course->id, $duedate1, $opts);
     // Create assignment restricted to group2.
     $opts = ['availability' => json_encode(\core_availability\tree::get_root_json([\availability_group\condition::get_json($group2->id)]))];
     $duedate2 = time() + DAYSECS * 3;
     $this->create_assignment($course->id, $duedate2, $opts);
     // Ensure student1 only has 1 deadline and that it is for group1.
     $stu1deadlines = local::upcoming_deadlines($student1->id);
     $this->assertCount(1, $stu1deadlines);
     $this->assertEquals($duedate1, reset($stu1deadlines)->timestart);
     // Ensure student2 only has 1 deadline and that it is for group2.
     $stu2deadlines = local::upcoming_deadlines($student2->id);
     $this->assertCount(1, $stu2deadlines);
     $this->assertEquals($duedate2, reset($stu2deadlines)->timestart);
     // Ensure teacher can see both deadlines.
     $tchdeadlines = local::upcoming_deadlines($teacher->id);
     $this->assertCount(2, $tchdeadlines);
 }