WebSVN – Moodle – Diff – /lib/tests/completionlib_test.php

  * @copyright  2008 Sam Marshall
  * @copyright  2013 Frédéric Massart
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  * @coversDefaultClass \completion_info
  */
-class completionlib_test extends advanced_testcase {
+final class completionlib_test extends advanced_testcase {
     protected $course;
     protected $user;
     protected $module1;
     protected $module2;
      * @param  float   $delta
      * @param  integer $maxDepth
      * @param  boolean $canonicalize
      * @param  boolean $ignoreCase
      */
-    public static function assertEquals($expected, $actual, string $message = '', float $delta = 0, int $maxDepth = 10,
+    public static function assertCompletionEquals($expected, $actual, string $message = '', float $delta = 0, int $maxDepth = 10,
                                         bool $canonicalize = false, bool $ignoreCase = false): void {
         // Nasty cheating hack: prevent random failures on timemodified field.
         if (is_array($actual) && (is_object($expected) || is_array($expected))) {
             $actual = (object) $actual;
             $expected = (object) $expected;
         global $CFG;
         $this->mock_setup();
         // Config alone.
         $CFG->enablecompletion = COMPLETION_DISABLED;
-        $this->assertEquals(COMPLETION_DISABLED, completion_info::is_enabled_for_site());
+        $this->assertCompletionEquals(COMPLETION_DISABLED, completion_info::is_enabled_for_site());
         $CFG->enablecompletion = COMPLETION_ENABLED;
-        $this->assertEquals(COMPLETION_ENABLED, completion_info::is_enabled_for_site());
+        $this->assertCompletionEquals(COMPLETION_ENABLED, completion_info::is_enabled_for_site());
         // Course.
         $course = (object)array('id' => 13);
         $c = new completion_info($course);
         $course->enablecompletion = COMPLETION_DISABLED;
-        $this->assertEquals(COMPLETION_DISABLED, $c->is_enabled());
+        $this->assertCompletionEquals(COMPLETION_DISABLED, $c->is_enabled());
         $course->enablecompletion = COMPLETION_ENABLED;
-        $this->assertEquals(COMPLETION_ENABLED, $c->is_enabled());
+        $this->assertCompletionEquals(COMPLETION_ENABLED, $c->is_enabled());
         $CFG->enablecompletion = COMPLETION_DISABLED;
-        $this->assertEquals(COMPLETION_DISABLED, $c->is_enabled());
+        $this->assertCompletionEquals(COMPLETION_DISABLED, $c->is_enabled());
         // Course and CM.
         $cm = new stdClass();
         $cm->completion = COMPLETION_TRACKING_MANUAL;
-        $this->assertEquals(COMPLETION_DISABLED, $c->is_enabled($cm));
+        $this->assertCompletionEquals(COMPLETION_DISABLED, $c->is_enabled($cm));
         $CFG->enablecompletion = COMPLETION_ENABLED;
         $course->enablecompletion = COMPLETION_DISABLED;
-        $this->assertEquals(COMPLETION_DISABLED, $c->is_enabled($cm));
+        $this->assertCompletionEquals(COMPLETION_DISABLED, $c->is_enabled($cm));
         $course->enablecompletion = COMPLETION_ENABLED;
-        $this->assertEquals(COMPLETION_TRACKING_MANUAL, $c->is_enabled($cm));
+        $this->assertCompletionEquals(COMPLETION_TRACKING_MANUAL, $c->is_enabled($cm));
         $cm->completion = COMPLETION_TRACKING_NONE;
-        $this->assertEquals(COMPLETION_TRACKING_NONE, $c->is_enabled($cm));
+        $this->assertCompletionEquals(COMPLETION_TRACKING_NONE, $c->is_enabled($cm));
         $cm->completion = COMPLETION_TRACKING_AUTOMATIC;
-        $this->assertEquals(COMPLETION_TRACKING_AUTOMATIC, $c->is_enabled($cm));
+        $this->assertCompletionEquals(COMPLETION_TRACKING_AUTOMATIC, $c->is_enabled($cm));
+    }
             ->with($cm)
             ->will($this->returnValue(true));
         $c->expects($this->exactly(1)) // Pretend the user has the required capability for overriding completion statuses.
             ->method('user_can_override_completion')
             ->will($this->returnValue(true));
-        $c->expects($this->exactly(2))
+        $getinvocations = $this->exactly(2);
+        $c->expects($getinvocations)
             ->method('get_data')
             ->with($cm, false, 100)
-            ->willReturnOnConsecutiveCalls($current1, $current2);
+            ->willReturnCallback(function () use ($getinvocations, $current1, $current2) {
+                return match (self::getInvocationCount($getinvocations)) {
+=> $current1,
+=> $current2,
+                    default => $this->fail('Unexpected invocation count'),
+                };
+            });
         $changed1 = clone($current1);
         $changed1->timemodified = time();
         $changed1->completionstate = COMPLETION_COMPLETE;
         $changed1->overrideby = 314159;
         $comparewith1 = new phpunit_constraint_object_is_equal_with_exceptions($changed1);
         $changed2->timemodified = time();
         $changed2->overrideby = null;
         $changed2->completionstate = COMPLETION_INCOMPLETE;
         $comparewith2 = new phpunit_constraint_object_is_equal_with_exceptions($changed2);
         $comparewith2->add_exception('timemodified', 'assertGreaterThanOrEqual');
-        $c->expects($this->exactly(2))
+        $setinvocations = $this->exactly(2);
+        $c->expects($setinvocations)
             ->method('internal_set_data')
+            ->willReturnCallback(function ($comparecm, $comparewith) use (
-            ->withConsecutive(
+                $setinvocations,
+                $cm,
-                array($cm, $comparewith1),
+                $comparewith1,
-                array($cm, $comparewith2)
+                $comparewith2
+            ): void {
+                switch (self::getInvocationCount($setinvocations)) {
+                    case 1:
+                        $this->assertCompletionEquals($cm, $comparecm);
+                        $comparewith1->evaluate($comparewith);
+                        break;
+                    case 2:
+                        $this->assertCompletionEquals($cm, $comparecm);
+                        $comparewith2->evaluate($comparewith);
+                        break;
+                    default:
+                        $this->fail('Unexpected invocation count');
+                }
-            );
+            });
         $c->update_state($cm, COMPLETION_COMPLETE, 100, true);
         // And confirm that the status can be changed back to incomplete without an override.
         $c->update_state($cm, COMPLETION_INCOMPLETE, 100);
     /**
      * Data provider for test_internal_get_state().
+     *
      * @return array[]
      */
-    public function internal_get_state_provider() {
+    public static function internal_get_state_provider(): array {
         return [
             'View required, but not viewed yet' => [
                 COMPLETION_VIEW_REQUIRED, 1, '', COMPLETION_INCOMPLETE
             ],
             'View not required and not viewed yet' => [
+        }
         // If view is required, but they haven't viewed it yet.
         $current = (object)['viewed' => COMPLETION_NOT_VIEWED];
         $completioninfo = new completion_info($this->course);
-        $this->assertEquals($expectedstate, $completioninfo->internal_get_state($cm, $userid, $current));
+        $this->assertCompletionEquals($expectedstate, $completioninfo->internal_get_state($cm, $userid, $current));
+    }
     /**
      * Provider for the test_internal_get_state_with_grade_criteria.
+     *
      * @return array
      */
-    public function internal_get_state_with_grade_criteria_provider() {
+    public static function internal_get_state_with_grade_criteria_provider(): array {
         return [
             "Passing grade enabled and achieve. State should be COMPLETION_COMPLETE_PASS" => [
+                [
             $assign->save_grade($userid, $data);
+        }
         // The target user already received a grade, so internal_get_state should be already complete.
         $completioninfo = new completion_info($this->course);
-        $this->assertEquals($expectedstate, $completioninfo->internal_get_state($cm, $userid, null));
+        $this->assertCompletionEquals($expectedstate, $completioninfo->internal_get_state($cm, $userid, null));
+    }
     /**
         ];
         $assign->save_grade($userid, $data);
         // The target user already received a grade, so internal_get_state should be already complete.
         $completioninfo = new completion_info($this->course);
-        $this->assertEquals(COMPLETION_COMPLETE, $completioninfo->internal_get_state($cm, $userid, null));
+        $this->assertCompletionEquals(COMPLETION_COMPLETE, $completioninfo->internal_get_state($cm, $userid, null));
         // As the teacher which does not have a grade in this cm, internal_get_state should return incomplete.
-        $this->assertEquals(COMPLETION_INCOMPLETE, $completioninfo->internal_get_state($cm, $teacher->id, null));
+        $this->assertCompletionEquals(COMPLETION_INCOMPLETE, $completioninfo->internal_get_state($cm, $teacher->id, null));
+    }
         $completioninfo = new completion_info($this->course);
         // Fetch completion for the user who hasn't made a choice yet.
         $completion = $completioninfo->internal_get_state($cminfo, $this->user->id, COMPLETION_INCOMPLETE);
-        $this->assertEquals(COMPLETION_INCOMPLETE, $completion);
+        $this->assertCompletionEquals(COMPLETION_INCOMPLETE, $completion);
         // Have the user make a choice.
         $choicewithoptions = choice_get_choice($choice->id);
         $optionids = array_keys($choicewithoptions->option);
         choice_user_submit_response($optionids[0], $choice, $this->user->id, $this->course, $cminfo);
         $completion = $completioninfo->internal_get_state($cminfo, $this->user->id, COMPLETION_INCOMPLETE);
-        $this->assertEquals(COMPLETION_COMPLETE, $completion);
+        $this->assertCompletionEquals(COMPLETION_COMPLETE, $completion);
+    }
         $DB->expects($this->once())
             ->method('get_field_sql')
             ->will($this->returnValue(666));
         $c = new completion_info($course);
-        $this->assertEquals(666, $c->count_user_data($cm));
+        $this->assertCompletionEquals(666, $c->count_user_data($cm));
+    }
     /**
             ->method('get_tracked_users')
             ->will($this->returnValue(array(
             (object)array('id' => 100, 'firstname' => 'Woot', 'lastname' => 'Plugh'),
             (object)array('id' => 201, 'firstname' => 'Vroom', 'lastname' => 'Xyzzy'))));
+        $updateinvocations = $this->exactly(3);
-        $c->expects($this->exactly(3))
+        $c->expects($updateinvocations)
+            ->method('update_state')
+            ->willReturnCallback(function ($comparecm, $state, $userid) use ($updateinvocations, $cm): void {
+                $this->assertCompletionEquals($cm, $comparecm);
+                $this->assertCompletionEquals(COMPLETION_UNKNOWN, $state);
-            ->method('update_state')
+                switch (self::getInvocationCount($updateinvocations)) {
-            ->withConsecutive(
+                    case 1:
+                        $this->assertCompletionEquals(100, $userid);
+                        break;
-                array($cm, COMPLETION_UNKNOWN, 100),
+                    case 2:
+                        $this->assertCompletionEquals(101, $userid);
+                        break;
-                array($cm, COMPLETION_UNKNOWN, 101),
+                    case 3:
+                        $this->assertCompletionEquals(201, $userid);
+                        break;
+                    default:
+                        $this->fail('Unexpected invocation count');
-                array($cm, COMPLETION_UNKNOWN, 201)
+                }
-            );
+            });
         $c->reset_all_state($cm);
+    }
     /**
      * Data provider for test_get_data().
      *
      * @return array[]
      */
-    public function get_data_provider() {
+    public static function get_data_provider(): array {
         return [
             'No completion record' => [
         $completioninfo = new completion_info($this->course);
         $result = $completioninfo->get_data($cm, $wholecourse, $user->id);
         // Course module ID of the returned completion data must match this activity's course module ID.
-        $this->assertEquals($cm->id, $result->coursemoduleid);
+        $this->assertCompletionEquals($cm->id, $result->coursemoduleid);
         // User ID of the returned completion data must match the user's ID.
-        $this->assertEquals($user->id, $result->userid);
+        $this->assertCompletionEquals($user->id, $result->userid);
         // The completion state of the returned completion data must match the expected completion state.
-        $this->assertEquals($completion, $result->completionstate);
+        $this->assertCompletionEquals($completion, $result->completionstate);
         // If the user has no completion record, then the default record should be returned.
         if (!$hasrecord) {
-            $this->assertEquals(0, $result->id);
+            $this->assertCompletionEquals(0, $result->id);
+        }
             $this->assertTrue(property_exists($result, 'viewed'));
             $this->assertTrue(property_exists($result, 'overrideby'));
             $this->assertTrue(property_exists($result, 'timemodified'));
             $this->assertFalse(property_exists($result, 'other_cm_completion_data_fetched'));
-            $this->assertEquals($testcm->id, $result->coursemoduleid);
+            $this->assertCompletionEquals($testcm->id, $result->coursemoduleid);
-            $this->assertEquals($this->user->id, $result->userid);
+            $this->assertCompletionEquals($this->user->id, $result->userid);
             $results[$testcm->id] = $result;
         // The data should match when fetching modules individually.
         (cache::make('core', 'completion'))->purge();
         foreach ($modinfo->cms as $testcm) {
             $result = $completioninfo->get_data($testcm, false);
-            $this->assertEquals($result, $results[$testcm->id]);
+            $this->assertCompletionEquals($result, $results[$testcm->id]);
+        }
+    }
         ];
         $completiondatabeforeview = $completioninfo->get_completion_data($cm->id, $this->user->id, $defaultdata);
         $this->assertTrue(array_key_exists('viewed', $completiondatabeforeview));
         $this->assertTrue(array_key_exists('coursemoduleid', $completiondatabeforeview));
-        $this->assertEquals(0, $completiondatabeforeview['viewed']);
+        $this->assertCompletionEquals(0, $completiondatabeforeview['viewed']);
-        $this->assertEquals($cm->id, $completiondatabeforeview['coursemoduleid']);
+        $this->assertCompletionEquals($cm->id, $completiondatabeforeview['coursemoduleid']);
         // Mark as completed before viewing it.
         $completioninfo->update_state($cm, COMPLETION_COMPLETE, $this->user->id, true);
         $completiondatabeforeview = $completioninfo->get_completion_data($cm->id, $this->user->id, $defaultdata);
-        $this->assertEquals(0, $completiondatabeforeview['viewed']);
+        $this->assertCompletionEquals(0, $completiondatabeforeview['viewed']);
         // Set viewed.
         $completioninfo->set_module_viewed($cm, $this->user->id);
         $completiondata = $completioninfo->get_completion_data($cm->id, $this->user->id, $defaultdata);
         $this->assertTrue(array_key_exists('viewed', $completiondata));
         $this->assertTrue(array_key_exists('coursemoduleid', $completiondata));
-        $this->assertEquals(1, $completiondata['viewed']);
+        $this->assertCompletionEquals(1, $completiondata['viewed']);
-        $this->assertEquals($cm->id, $completiondatabeforeview['coursemoduleid']);
+        $this->assertCompletionEquals($cm->id, $completiondatabeforeview['coursemoduleid']);
         $completioninfo->reset_all_state($cm);
         $completiondataafterreset = $completioninfo->get_completion_data($cm->id, $this->user->id, $defaultdata);
         $this->assertTrue(array_key_exists('viewed', $completiondataafterreset));
         $this->assertTrue(array_key_exists('coursemoduleid', $completiondataafterreset));
         // Check that fetching data for a module with custom completion provides its info.
         $choicecompletiondata = $method->invoke($completioninfo, $cmchoice, $user->id);
         $this->assertArrayHasKey('customcompletion', $choicecompletiondata);
         $this->assertArrayHasKey('completionsubmit', $choicecompletiondata['customcompletion']);
-        $this->assertEquals(COMPLETION_INCOMPLETE, $choicecompletiondata['customcompletion']['completionsubmit']);
+        $this->assertCompletionEquals(COMPLETION_INCOMPLETE, $choicecompletiondata['customcompletion']['completionsubmit']);
         // Mock a choice answer so user has completed the requirement.
         $choicemockinfo = [
             'choiceid' => $cmchoice->instance,
             'userid' => $this->user->id
         ];
         $DB->insert_record('choice_answers', $choicemockinfo, false);
         // Confirm fetching again reflects the completion.
         $choicecompletiondata = $method->invoke($completioninfo, $cmchoice, $user->id);
-        $this->assertEquals(COMPLETION_COMPLETE, $choicecompletiondata['customcompletion']['completionsubmit']);
+        $this->assertCompletionEquals(COMPLETION_COMPLETE, $choicecompletiondata['customcompletion']['completionsubmit']);
         // Check that fetching data for a module with no custom completion still provides its grade completion status.
         $workshopcompletiondata = $method->invoke($completioninfo, $cmworkshop, $user->id);
         $this->assertArrayHasKey('completiongrade', $workshopcompletiondata);
         $this->assertArrayHasKey('passgrade', $workshopcompletiondata);
         $this->assertArrayNotHasKey('customcompletion', $workshopcompletiondata);
-        $this->assertEquals(COMPLETION_INCOMPLETE, $workshopcompletiondata['completiongrade']);
+        $this->assertCompletionEquals(COMPLETION_INCOMPLETE, $workshopcompletiondata['completiongrade']);
         $data->viewed = COMPLETION_NOT_VIEWED;
         $data->overrideby = null;
         $c->internal_set_data($cm, $data);
         $d1 = $DB->get_field('course_modules_completion', 'id', array('coursemoduleid' => $cm->id));
-        $this->assertEquals($d1, $data->id);
+        $this->assertCompletionEquals($d1, $data->id);
         $cache = cache::make('core', 'completion');
         // Cache was not set for another user.
         $cachevalue = $cache->get("{$data->userid}_{$cm->course}");
-        $this->assertEquals([
+        $this->assertCompletionEquals([
             'cacherev' => $this->course->cacherev,
             $cm->id => array_merge(
                 (array) $data,
                 ['other_cm_completion_data_fetched' => true]
         $d2->viewed = COMPLETION_NOT_VIEWED;
         $d2->overrideby = null;
         $c->internal_set_data($cm2, $d2);
         // Cache for current user returns the data.
         $cachevalue = $cache->get($data->userid . '_' . $cm->course);
-        $this->assertEquals(array_merge(
+        $this->assertCompletionEquals(array_merge(
             (array) $data,
             ['other_cm_completion_data_fetched' => true]
         ), $cachevalue[$cm->id]);
         // Cache for another user is not filled.
-        $this->assertEquals(false, $cache->get($d2->userid . '_' . $cm2->course));
+        $this->assertCompletionEquals(false, $cache->get($d2->userid . '_' . $cm2->course));
         // 3) Test where it THINKS the data is new (from cache) but actually in the database it has been set since.
         $forum3 = $this->getDataGenerator()->create_module('forum', array('course' => $this->course->id), $completionauto);
         $this->assertEmpty($actual);
         $data->coursemoduleid = $cm->id;
         $c->internal_set_data($cm, $data);
         $actual = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($actual));
+        $this->assertCompletionEquals(1, count($actual));
-        $this->assertEquals($this->user->id, reset($actual)->userid);
+        $this->assertCompletionEquals($this->user->id, reset($actual)->userid);
         $data->userid = $newuser2->id;
         $c->internal_set_data($cm, $data, true);
         $actual = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($actual));
+        $this->assertCompletionEquals(1, count($actual));
-        $this->assertEquals($this->user->id, reset($actual)->userid);
+        $this->assertCompletionEquals($this->user->id, reset($actual)->userid);
+    }
         $progress2 = (object)array('userid' => 201, 'coursemoduleid' => 14);
         $DB->expects($this->once())
             ->method('get_recordset_sql')
             ->will($this->returnValue(new core_completionlib_fake_recordset(array($progress1, $progress2))));
-        $this->assertEquals(array(
+        $this->assertCompletionEquals(array(
 => (object)array('id' => 100, 'firstname' => 'Woot', 'lastname' => 'Plugh',
                     'progress' => array(13 => $progress1)),
 => (object)array('id' => 201, 'firstname' => 'Vroom', 'lastname' => 'Xyzzy',
                     'progress' => array(14 => $progress2)),
+        }
         $c->expects($this->once())
             ->method('get_tracked_users')
             ->with(true,  3,  0,  '',  '',  '',  null)
             ->will($this->returnValue($tracked));
+        $inorequalsinvocations = $this->exactly(2);
-        $DB->expects($this->exactly(2))
+        $DB->expects($inorequalsinvocations)
             ->method('get_in_or_equal')
+            ->willReturnCallback(function ($paramids) use ($inorequalsinvocations, $ids) {
+                switch (self::getInvocationCount($inorequalsinvocations)) {
-            ->withConsecutive(
+                    case 1:
-                array(array_slice($ids, 0, 1000)),
+                        $this->assertCompletionEquals(array_slice($ids, 0, 1000), $paramids);
-                array(array_slice($ids, 1000))
+                        return [' IN whatever', []];
-            )
+                    case 2:
+                        $this->assertCompletionEquals(array_slice($ids, 1000), $paramids);
-            ->willReturnOnConsecutiveCalls(
+                        return [' IN whatever2', []];
-                array(' IN whatever', array()),
+                    default:
+                        $this->fail('Unexpected invocation count');
+                }
+            });
-                array(' IN whatever2', array()));
+        $getinvocations = $this->exactly(2);
-        $DB->expects($this->exactly(2))
+        $DB->expects($getinvocations)
             ->method('get_recordset_sql')
-            ->willReturnOnConsecutiveCalls(
+            ->willReturnCallback(function () use ($getinvocations, $progress) {
+                return match (self::getInvocationCount($getinvocations)) {
-                new core_completionlib_fake_recordset(array_slice($progress, 0, 1000)),
+=> new core_completionlib_fake_recordset(array_slice($progress, 0, 1000)),
-                new core_completionlib_fake_recordset(array_slice($progress, 1000)));
+=> new core_completionlib_fake_recordset(array_slice($progress, 1000)),
+                    default => $this->fail('Unexpected invocation count'),
+                };
+            });
         $result = $c->get_progress_all(true, 3);
         $resultok = true;
         $item->hidden = 0;
         $grade->rawgrade = 4.0;
         $grade->finalgrade = null;
         // Grade has pass mark and is not hidden,  user passes.
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE_PASS,
             completion_info::internal_get_grade_state($item, $grade));
         // Same but user fails.
         $grade->rawgrade = 3.9;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE_FAIL,
             completion_info::internal_get_grade_state($item, $grade));
         // User fails on raw grade but passes on final.
         $grade->finalgrade = 4.0;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE_PASS,
             completion_info::internal_get_grade_state($item, $grade));
         // Item is hidden.
         $item->hidden = 1;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE,
             completion_info::internal_get_grade_state($item, $grade));
         // Item isn't hidden but has no pass mark.
         $item->hidden = 0;
         $item->gradepass = 0;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE,
             completion_info::internal_get_grade_state($item, $grade));
         // Item is hidden, but returnpassfail is true and the grade is passing.
         $item->hidden = 1;
         $item->gradepass = 4;
         $grade->finalgrade = 5.0;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE_PASS,
             completion_info::internal_get_grade_state($item, $grade, true));
         // Item is hidden, but returnpassfail is true and the grade is failing.
         $item->hidden = 1;
         $item->gradepass = 4;
         $grade->finalgrade = 3.0;
-        $this->assertEquals(
+        $this->assertCompletionEquals(
             COMPLETION_COMPLETE_FAIL_HIDDEN,
             completion_info::internal_get_grade_state($item, $grade, true));
         // Item is not hidden, but returnpassfail is true and the grade is failing.
         $completionauto = array('completion' => COMPLETION_TRACKING_AUTOMATIC);
         $forum = $this->getDataGenerator()->create_module('forum', array('course' => $this->course->id), $completionauto);
         $c = new completion_info($this->course);
         $activities = $c->get_activities();
-        $this->assertEquals(1, count($activities));
+        $this->assertCompletionEquals(1, count($activities));
         $this->assertTrue(isset($activities[$forum->cmid]));
-        $this->assertEquals($activities[$forum->cmid]->name, $forum->name);
+        $this->assertCompletionEquals($activities[$forum->cmid]->name, $forum->name);
         $current = $c->get_data($activities[$forum->cmid], false, $this->user->id);
         $current->completionstate = COMPLETION_COMPLETE;
         $current->timemodified = time();
         $sink = $this->redirectEvents();
         $c->internal_set_data($activities[$forum->cmid], $current);
         $events = $sink->get_events();
         $event = reset($events);
         $this->assertInstanceOf('\core\event\course_module_completion_updated', $event);
-        $this->assertEquals($forum->cmid,
+        $this->assertCompletionEquals($forum->cmid,
             $event->get_record_snapshot('course_modules_completion', $event->objectid)->coursemoduleid);
-        $this->assertEquals($current, $event->get_record_snapshot('course_modules_completion', $event->objectid));
+        $this->assertCompletionEquals($current, $event->get_record_snapshot('course_modules_completion', $event->objectid));
-        $this->assertEquals(context_module::instance($forum->cmid), $event->get_context());
+        $this->assertCompletionEquals(context_module::instance($forum->cmid), $event->get_context());
-        $this->assertEquals($USER->id, $event->userid);
+        $this->assertCompletionEquals($USER->id, $event->userid);
-        $this->assertEquals($this->user->id, $event->relateduserid);
+        $this->assertCompletionEquals($this->user->id, $event->relateduserid);
         $this->assertInstanceOf('moodle_url', $event->get_url());
+    }
         $ccompletion->mark_complete();
         $events = $sink->get_events();
         $event = reset($events);
         $this->assertInstanceOf('\core\event\course_completed', $event);
-        $this->assertEquals($this->course->id, $event->get_record_snapshot('course_completions', $event->objectid)->course);
+        $this->assertCompletionEquals($this->course->id, $event->get_record_snapshot('course_completions', $event->objectid)->course);
-        $this->assertEquals($this->course->id, $event->courseid);
+        $this->assertCompletionEquals($this->course->id, $event->courseid);
-        $this->assertEquals($USER->id, $event->userid);
+        $this->assertCompletionEquals($USER->id, $event->userid);
-        $this->assertEquals($this->user->id, $event->relateduserid);
+        $this->assertCompletionEquals($this->user->id, $event->relateduserid);
-        $this->assertEquals(context_course::instance($this->course->id), $event->get_context());
+        $this->assertCompletionEquals(context_course::instance($this->course->id), $event->get_context());
         $this->assertInstanceOf('moodle_url', $event->get_url());
+    }
         $sink->close();
         $this->assertCount(1, $messages);
         $message = array_pop($messages);
-        $this->assertEquals(core_user::get_noreply_user()->id, $message->useridfrom);
+        $this->assertCompletionEquals(core_user::get_noreply_user()->id, $message->useridfrom);
-        $this->assertEquals($this->user->id, $message->useridto);
+        $this->assertCompletionEquals($this->user->id, $message->useridto);
-        $this->assertEquals('coursecompleted', $message->eventtype);
+        $this->assertCompletionEquals('coursecompleted', $message->eventtype);
-        $this->assertEquals(get_string('coursecompleted', 'completion'), $message->subject);
+        $this->assertCompletionEquals(get_string('coursecompleted', 'completion'), $message->subject);
         $this->assertStringContainsString($this->course->fullname, $message->fullmessage);
+    }
         $events = $sink->get_events();
         $event = array_pop($events);
         $sink->close();
         $this->assertInstanceOf('\core\event\course_completion_updated', $event);
-        $this->assertEquals($this->course->id, $event->courseid);
+        $this->assertCompletionEquals($this->course->id, $event->courseid);
-        $this->assertEquals($coursecontext, $event->get_context());
+        $this->assertCompletionEquals($coursecontext, $event->get_context());
         $this->assertInstanceOf('moodle_url', $event->get_url());
+    }
     /**
      * Data provider for test_get_grade_completion().
+     *
      * @return array[]
      */
-    public function get_grade_completion_provider() {
+    public static function get_grade_completion_provider(): array {
         return [
             'Grade not required' => [false, false, null, null, null],
             'Grade required, but has no grade yet' => [true, false, null, null, COMPLETION_INCOMPLETE],
             'Grade required, grade received' => [true, true, null, null, COMPLETION_COMPLETE],
             'Grade required, passing grade received' => [true, true, 70, null, COMPLETION_COMPLETE_PASS],
         $completioninfo = new completion_info($this->course);
         if ($expectedexception) {
             $this->expectException($expectedexception);
+        }
         $gradecompletion = $completioninfo->get_grade_completion($cm, $this->user->id);
-        $this->assertEquals($expectedresult, $gradecompletion);
+        $this->assertCompletionEquals($expectedresult, $gradecompletion);
+    }
     /**
      * Test the return value for cases when the activity module does not have associated grade_item.
             'iteminstance' => $assign->id,
         ]);
         // Without the grade_item, the activity is considered incomplete.
         $completioninfo = new completion_info($this->course);
-        $this->assertEquals(COMPLETION_INCOMPLETE, $completioninfo->get_grade_completion($cm, $this->user->id));
+        $this->assertCompletionEquals(COMPLETION_INCOMPLETE, $completioninfo->get_grade_completion($cm, $this->user->id));
         // Once the activity is graded, the grade_item is automatically created.
         $assigninstance = new assign($cm->context, $cm, $this->course);
         $grade = $assigninstance->get_user_grade($this->user->id, true);
         $grade->grade = 40;
         $assigninstance->update_grade($grade);
         // The implicitly created grade_item does not have grade to pass defined so it is not distinguished.
-        $this->assertEquals(COMPLETION_COMPLETE, $completioninfo->get_grade_completion($cm, $this->user->id));
+        $this->assertCompletionEquals(COMPLETION_COMPLETE, $completioninfo->get_grade_completion($cm, $this->user->id));
+    }
         // We're testing a private method, so we need to setup reflector magic.
         $method = new ReflectionMethod($ccompletion, '_save');
         $completionid = $method->invoke($ccompletion);
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(count($completions), 1);
+        $this->assertCompletionEquals(count($completions), 1);
-        $this->assertEquals(reset($completions)->id, $completionid);
+        $this->assertCompletionEquals(reset($completions)->id, $completionid);
         $ccompletion->id = 0;
         $method = new ReflectionMethod($ccompletion, '_save');
         $completions = $DB->get_records('course_completions');
         $this->assertEmpty($completions);
         $completionid = $ccompletion->mark_enrolled();
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(count($completions), 1);
+        $this->assertCompletionEquals(count($completions), 1);
-        $this->assertEquals(reset($completions)->id, $completionid);
+        $this->assertCompletionEquals(reset($completions)->id, $completionid);
         $ccompletion->id = 0;
         $completionid = $ccompletion->mark_enrolled();
         $this->assertDebuggingCalled('Can not update data object, no id!');
         $this->assertNull($completionid);
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
+    }
         $completions = $DB->get_records('course_completions');
         $this->assertEmpty($completions);
         $completionid = $ccompletion->mark_inprogress();
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
-        $this->assertEquals(reset($completions)->id, $completionid);
+        $this->assertCompletionEquals(reset($completions)->id, $completionid);
         $ccompletion->id = 0;
         $completionid = $ccompletion->mark_inprogress();
         $this->assertDebuggingCalled('Can not update data object, no id!');
         $this->assertNull($completionid);
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
+    }
         $completions = $DB->get_records('course_completions');
         $this->assertEmpty($completions);
         $completionid = $ccompletion->mark_complete();
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
-        $this->assertEquals(reset($completions)->id, $completionid);
+        $this->assertCompletionEquals(reset($completions)->id, $completionid);
         $ccompletion->id = 0;
         $completionid = $ccompletion->mark_complete();
         $this->assertNull($completionid);
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
+    }
         $completions = $DB->get_records('course_completions');
         $this->assertEmpty($completions);
         $completionid = $completion->mark_complete($record['timecompleted']);
         $completions = $DB->get_records('course_completions');
-        $this->assertEquals(1, count($completions));
+        $this->assertCompletionEquals(1, count($completions));
-        $this->assertEquals(reset($completions)->id, $completionid);
+        $this->assertCompletionEquals(reset($completions)->id, $completionid);
+    }
     /**
         $this->assertFalse($DB->record_exists_select('course_modules_viewed',
             'coursemoduleid IN (SELECT id FROM {course_modules} WHERE course=:course)',
             ['course' => $this->course->id]
         ));
+    }
+    /**
+     * Data provider for test_count_modules_completed().
+     *
+     * @return array[]
+     */
+    public static function count_modules_completed_provider(): array {
+        return [
+            'Multiple users with two different modules but only one completed' => [
+                'existinguser' => true,
+                'totalusers' => 3,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_COMPLETE,
+                    ],
+                    [
+                        'name' => 'choice',
+                        'completionstate' => COMPLETION_INCOMPLETE,
+                    ],
+                ],
+                'expectedcount' => 1,
+            ],
+            'Multiple users with three different modules but only two completed' => [
+                'existinguser' => true,
+                'totalusers' => 4,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_COMPLETE,
+                    ],
+                    [
+                        'name' => 'choice',
+                        'completionstate' => COMPLETION_INCOMPLETE,
+                    ],
+                    [
+                        'name' => 'workshop',
+                        'completionstate' => COMPLETION_COMPLETE,
+                    ],
+                ],
+                'expectedcount' => 2,
+            ],
+            'Multiple users with one completion each' => [
+                'existinguser' => true,
+                'totalusers' => 5,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_COMPLETE,
+                    ],
+                ],
+                'expectedcount' => 1,
+            ],
+            'One user with one completion' => [
+                'existinguser' => true,
+                'totalusers' => 1,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_COMPLETE,
+                    ],
+                ],
+                'expectedcount' => 1,
+            ],
+            'Multiple users without completion' => [
+                'existinguser' => true,
+                'totalusers' => 3,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_INCOMPLETE,
+                    ],
+                ],
+                'expectedcount' => 0,
+            ],
+            'Non-existing user' => [
+                'existinguser' => false,
+                'totalusers' => 1,
+                'modules' => [
+                    [
+                        'name' => 'assign',
+                        'completionstate' => COMPLETION_INCOMPLETE,
+                    ],
+                ],
+                'expectedcount' => 0,
+            ],
+        ];
+    }
+    /**
+     * Test for count_modules_completed().
+     *
+     * @dataProvider count_modules_completed_provider
+     * @param bool $existinguser Whether the given user exists or not.
+     * @param int $totalusers The amount of users to check completion.
+     * @param array $modules The course modules with its completion state.
+     * @param int $expectedcount Expected total of modules completed.
+     * @covers ::count_modules_completed
+     */
+    public function test_count_modules_completed(bool $existinguser, int $totalusers, array $modules,
+        int $expectedcount): void {
+        global $DB;
+        $this->setAdminUser();
+        $this->setup_data();
+        // Loop through the provided modules array and set the id key based on the generated module.
+        $modules = array_map(function(array $module): array {
+            $generator = $this->getDataGenerator()->get_plugin_generator('mod_' . $module['name']);
+            $modinstance = $generator->create_instance([
+                'course' => $this->course->id,
+                'completion' => COMPLETION_TRACKING_AUTOMATIC,
+                'completionsubmit' => true,
+            ]);
+            $cminstance = get_coursemodule_from_instance($module['name'], $modinstance->id);
+            $module['id'] = $cminstance->id;
+            return $module;
+        }, $modules);
+        $completion = new completion_info($this->course);
+        if ($existinguser) {
+            // Create users, assign them to a course and define the completion record.
+            for ($i = 0; $i < $totalusers; $i++) {
+                $user = $this->getDataGenerator()->create_user();
+                $this->getDataGenerator()->enrol_user($user->id, $this->course->id);
+                $users[] = $user;
+                foreach ($modules as $module) {
+                    $cmcompletionrecords[] = (object)[
+                        'coursemoduleid' => $module['id'],
+                        'userid' => $user->id,
+                        'completionstate' => $module['completionstate'],
+                        'timemodified' => 0,
+                    ];
+                }
+            }
+            $DB->insert_records('course_modules_completion', $cmcompletionrecords);
+            foreach ($users as $user) {
+                $this->assertEquals($expectedcount, $completion->count_modules_completed($user->id));
+            }
+        } else {
+            $nonexistinguserid = 123;
+            $this->assertEquals($expectedcount, $completion->count_modules_completed($nonexistinguserid));
+        }
+    }
+}
 class core_completionlib_fake_recordset implements Iterator {
     protected $closed;

Proyectos de Subversion Moodle

(root)/lib/tests/completionlib_test.php – Rev 11 → 1441