Search moodle.org's
Developer Documentation

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
  •    1  <?php
       2  // This file is part of Moodle - http://moodle.org/
       3  //
       4  // Moodle is free software: you can redistribute it and/or modify
       5  // it under the terms of the GNU General Public License as published by
       6  // the Free Software Foundation, either version 3 of the License, or
       7  // (at your option) any later version.
       8  //
       9  // Moodle is distributed in the hope that it will be useful,
      10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12  // GNU General Public License for more details.
      13  //
      14  // You should have received a copy of the GNU General Public License
      15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
      16  
      17  /**
      18   * Unit tests for core targets.
      19   *
      20   * @package   core_course
      21   * @copyright 2019 Victor Deniz <victor@moodle.com>
      22   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
      23   */
      24  
      25  defined('MOODLE_INTERNAL') || die();
      26  global $CFG;
      27  
      28  require_once($CFG->dirroot . '/completion/criteria/completion_criteria.php');
      29  require_once($CFG->dirroot . '/completion/criteria/completion_criteria_activity.php');
      30  require_once($CFG->dirroot . '/lib/grade/grade_item.php');
      31  require_once($CFG->dirroot . '/lib/grade/grade_grade.php');
      32  require_once($CFG->dirroot . '/lib/grade/grade_category.php');
      33  require_once($CFG->dirroot . '/lib/grade/constants.php');
      34  
      35  /**
      36   * Unit tests for core targets.
      37   *
      38   * @package   core_course
      39   * @copyright 2019 Victor Deniz <victor@moodle.com>
      40   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
      41   */
      42  class core_analytics_targets_testcase extends advanced_testcase {
      43  
      44      /**
      45       * Provides course params for the {@link self::test_core_target_course_completion_analysable()} method.
      46       *
      47       * @return array
      48       */
      49      public function analysable_provider() {
      50  
      51          $now = new DateTime("now", core_date::get_server_timezone_object());
      52          $year = $now->format('Y');
      53          $month = $now->format('m');
      54  
      55          return [
      56              'coursenotyetstarted' => [
      57                  'params' => [
      58                      'enablecompletion' => 1,
      59                      'startdate' => mktime(0, 0, 0, 10, 24, $year + 1)
      60                  ],
      61                  'isvalid' => get_string('coursenotyetstarted', 'course')
      62              ],
      63              'coursenostudents' => [
      64                  'params' => [
      65                      'enablecompletion' => 1,
      66                      'startdate' => mktime(0, 0, 0, 10, 24, $year - 2),
      67                      'enddate' => mktime(0, 0, 0, 10, 24, $year - 1)
      68                  ],
      69                  'isvalid' => get_string('nocoursestudents', 'course')
      70              ],
      71              'coursenosections' => [
      72                  'params' => [
      73                      'enablecompletion' => 1,
      74                      'format' => 'social',
      75                      'students' => true
      76                  ],
      77                  'isvalid' => get_string('nocoursesections', 'course')
      78              ],
      79              'coursenoendtime' => [
      80                  'params' => [
      81                      'enablecompletion' => 1,
      82                      'format' => 'topics',
      83                      'enddate' => 0,
      84                      'students' => true
      85                  ],
      86                  'isvalid' => get_string('nocourseendtime', 'course')
      87              ],
      88              'courseendbeforestart' => [
      89                  'params' => [
      90                      'enablecompletion' => 1,
      91                      'enddate' => mktime(0, 0, 0, 10, 23, $year - 2),
      92                      'students' => true
      93                  ],
      94                  'isvalid' => get_string('errorendbeforestart', 'course')
      95              ],
      96              'coursetoolong' => [
      97                  'params' => [
      98                      'enablecompletion' => 1,
      99                      'startdate' => mktime(0, 0, 0, 10, 24, $year - 2),
     100                      'enddate' => mktime(0, 0, 0, 10, 23, $year),
     101                      'students' => true
     102                  ],
     103                  'isvalid' => get_string('coursetoolong', 'course')
     104              ],
     105              'coursealreadyfinished' => [
     106                  'params' => [
     107                      'enablecompletion' => 1,
     108                      'startdate' => mktime(0, 0, 0, 10, 24, $year - 2),
     109                      'enddate' => mktime(0, 0, 0, 10, 23, $year - 1),
     110                      'students' => true
     111                  ],
     112                  'isvalid' => get_string('coursealreadyfinished', 'course'),
     113                  'fortraining' => false
     114              ],
     115              'coursenotyetfinished' => [
     116                  'params' => [
     117                      'enablecompletion' => 1,
     118                      'startdate' => mktime(0, 0, 0, $month - 1, 24, $year),
     119                      'enddate' => mktime(0, 0, 0, $month + 2, 23, $year),
     120                      'students' => true
     121                  ],
     122                  'isvalid' => get_string('coursenotyetfinished', 'course')
     123              ],
     124              'coursenocompletion' => [
     125                  'params' => [
     126                      'enablecompletion' => 0,
     127                      'startdate' => mktime(0, 0, 0, $month - 2, 24, $year),
     128                      'enddate' => mktime(0, 0, 0, $month - 1, 23, $year),
     129                      'students' => true
     130                  ],
     131                  'isvalid' => get_string('completionnotenabledforcourse', 'completion')
     132              ],
     133              'coursehiddentraining' => [
     134                  'params' => [
     135                      'enablecompletion' => 1,
     136                      'startdate' => mktime(0, 0, 0, $month - 1, 24, $year - 1),
     137                      'enddate' => mktime(0, 0, 0, $month - 1, 23, $year),
     138                      'students' => true,
     139                      'visible' => '0',
     140                  ],
     141                  'isvalid' => true,
     142              ],
     143              'coursehiddenprediction' => [
     144                  'params' => [
     145                      'enablecompletion' => 1,
     146                      'startdate' => mktime(0, 0, 0, $month - 1, 24, $year),
     147                      'enddate' => mktime(0, 0, 0, $month - 1, 23, $year + 1),
     148                      'students' => true,
     149                      'visible' => '0',
     150                  ],
     151                  'isvalid' => get_string('hiddenfromstudents'),
     152                  'fortraining' => false
     153              ],
     154          ];
     155      }
     156  
     157      /**
     158       * Provides enrolment params for the {@link self::test_core_target_course_completion_samples()} method.
     159       *
     160       * @return array
     161       */
     162      public function sample_provider() {
     163          $now = time();
     164          return [
     165              'enrolmentendbeforecourse' => [
     166                  'coursestart' => $now,
     167                  'courseend' => $now + (WEEKSECS * 8),
     168                  'timestart' => $now,
     169                  'timeend' => $now - DAYSECS,
     170                  'isvalidfortraining' => false,
     171                  'isvalidforprediction' => false
     172              ],
     173              'enrolmenttoolong' => [
     174                  'coursestart' => $now,
     175                  'courseend' => $now + (WEEKSECS * 8),
     176                  'timestart' => $now - (YEARSECS + (WEEKSECS * 8)),
     177                  'timeend' => $now + (WEEKSECS * 8),
     178                  'isvalidfortraining' => false,
     179                  'isvalidforprediction' => false
     180              ],
     181              'enrolmentstartaftercourse' => [
     182                  'coursestart' => $now,
     183                  'courseend' => $now + (WEEKSECS * 8),
     184                  'timestart' => $now + (WEEKSECS * 9),
     185                  'timeend' => $now + (WEEKSECS * 10),
     186                  'isvalidfortraining' => false,
     187                  'isvalidforprediction' => false
     188              ],
     189              'enrolmentstartsafternow' => [
     190                  'coursestart' => $now,
     191                  'courseend' => $now + (WEEKSECS * 8),
     192                  'timestart' => $now + (WEEKSECS * 2),
     193                  'timeend' => $now + (WEEKSECS * 7),
     194                  'isvalidfortraining' => false,
     195                  'isvalidforprediction' => false
     196              ],
     197              'enrolmentfinishedbeforenow' => [
     198                  'coursestart' => $now - (WEEKSECS * 4),
     199                  'courseend' => $now - (WEEKSECS * 1),
     200                  'timestart' => $now - (WEEKSECS * 3),
     201                  'timeend' => $now - (WEEKSECS * 2),
     202                  'isvalidfortraining' => true,
     203                  'isvalidforprediction' => false
     204              ],
     205          ];
     206      }
     207  
     208      /**
     209       * Provides enrolment params for the {@link self::test_core_target_course_completion_samples()} method.
     210       *
     211       * @return array
     212       */
     213      public function active_during_analysis_time_provider() {
     214          $now = time();
     215  
     216          return [
     217              'enrol-after-end' => [
     218                  'starttime' => $now,
     219                  'endtime' => $now + WEEKSECS,
     220                  'timestart' => $now + (WEEKSECS * 2),
     221                  'timeend' => $now + (WEEKSECS * 3),
     222                  'nullcalculation' => true,
     223              ],
     224              'enrol-before-start' => [
     225                  'starttime' => $now + (WEEKSECS * 2),
     226                  'endtime' => $now + (WEEKSECS * 3),
     227                  'timestart' => $now,
     228                  'timeend' => $now + WEEKSECS,
     229                  'nullcalculation' => true,
     230              ],
     231              'enrol-active-exact-match' => [
     232                  'starttime' => $now,
     233                  'endtime' => $now + (WEEKSECS * 1),
     234                  'timestart' => $now,
     235                  'timeend' => $now + (WEEKSECS * 1),
     236                  'nullcalculation' => false,
     237              ],
     238              'enrol-active' => [
     239                  'starttime' => $now + WEEKSECS,
     240                  'endtime' => $now + (WEEKSECS * 2),
     241                  'timestart' => $now,
     242                  'timeend' => $now + (WEEKSECS * 3),
     243                  'nullcalculation' => false,
     244              ],
     245              'enrol-during-analysis-active-just-for-a-while' => [
     246                  'starttime' => $now,
     247                  'endtime' => $now + (WEEKSECS * 10),
     248                  'timestart' => $now + WEEKSECS,
     249                  'timeend' => $now + (WEEKSECS * 2),
     250                  'nullcalculation' => true,
     251              ],
     252              'enrol-during-analysis-mostly-active' => [
     253                  'starttime' => $now,
     254                  'endtime' => $now + (WEEKSECS * 20),
     255                  'timestart' => $now + WEEKSECS,
     256                  'timeend' => $now + (WEEKSECS * 19),
     257                  'nullcalculation' => false,
     258              ],
     259              'enrol-partly-active-starts-before' => [
     260                  'starttime' => $now + WEEKSECS,
     261                  'endtime' => $now + (WEEKSECS * 10),
     262                  'timestart' => $now,
     263                  'timeend' => $now + (WEEKSECS * 2),
     264                  'nullcalculation' => true,
     265              ],
     266              'enrol-mostly-active-starts-before' => [
     267                  'starttime' => $now + WEEKSECS,
     268                  'endtime' => $now + (WEEKSECS * 10),
     269                  'timestart' => $now,
     270                  'timeend' => $now + (WEEKSECS * 9),
     271                  'nullcalculation' => false,
     272              ],
     273              'enrol-partly-active-ends-afterwards' => [
     274                  'starttime' => $now,
     275                  'endtime' => $now + (WEEKSECS * 10),
     276                  'timestart' => $now + (WEEKSECS * 9),
     277                  'timeend' => $now + (WEEKSECS * 11),
     278                  'nullcalculation' => true,
     279              ],
     280              'enrol-mostly-active-ends-afterwards' => [
     281                  'starttime' => $now,
     282                  'endtime' => $now + (WEEKSECS * 10),
     283                  'timestart' => $now + WEEKSECS,
     284                  'timeend' => $now + (WEEKSECS * 11),
     285                  'nullcalculation' => false,
     286              ],
     287              'enrol-partly-active-no-enrolment-end' => [
     288                  'starttime' => $now,
     289                  'endtime' => $now + (WEEKSECS * 10),
     290                  'timestart' => $now + (WEEKSECS * 9),
     291                  'timeend' => false,
     292                  'nullcalculation' => true,
     293              ],
     294              'enrol-mostly-active-no-enrolment-end-false' => [
     295                  'starttime' => $now,
     296                  'endtime' => $now + (WEEKSECS * 10),
     297                  'timestart' => $now + WEEKSECS,
     298                  'timeend' => false,
     299                  'nullcalculation' => false,
     300              ],
     301              'enrol-mostly-active-no-enrolment-end-zero' => [
     302                  'starttime' => $now,
     303                  'endtime' => $now + (WEEKSECS * 10),
     304                  'timestart' => $now + WEEKSECS,
     305                  'timeend' => 0,
     306                  'nullcalculation' => false,
     307              ],
     308              'enrol-no-enrolment-start-false' => [
     309                  'starttime' => $now,
     310                  'endtime' => $now + (WEEKSECS * 10),
     311                  'timestart' => false,
     312                  'timeend' => $now + (WEEKSECS * 9),
     313                  'nullcalculation' => false,
     314              ],
     315              'enrol-no-enrolment-start-zero' => [
     316                  'starttime' => $now,
     317                  'endtime' => $now + (WEEKSECS * 10),
     318                  'timestart' => 0,
     319                  'timeend' => $now + (WEEKSECS * 9),
     320                  'nullcalculation' => false,
     321              ],
     322              'no-start' => [
     323                  'starttime' => 0,
     324                  'endtime' => $now + (WEEKSECS * 2),
     325                  'timestart' => $now + WEEKSECS,
     326                  'timeend' => $now + (WEEKSECS * 3),
     327                  'nullcalculation' => false,
     328              ],
     329              'no-end' => [
     330                  'starttime' => $now,
     331                  'endtime' => 0,
     332                  'timestart' => $now + (WEEKSECS * 2),
     333                  'timeend' => $now + (WEEKSECS * 3),
     334                  'nullcalculation' => false,
     335              ]
     336          ];
     337      }
     338  
     339      /**
     340       * Test the conditions of a valid analysable, both common and specific to this target (course_completion).
     341       *
     342       * @dataProvider analysable_provider
     343       * @param mixed $courseparams Course data
     344       * @param true|string $isvalid True when analysable is valid, string when it is not
     345       * @param boolean $fortraining True if the course is for training the model
     346       */
     347      public function test_core_target_course_completion_analysable($courseparams, $isvalid, $fortraining = true) {
     348          global $DB;
     349  
     350          $this->resetAfterTest(true);
     351  
     352          try {
     353              $course = $this->getDataGenerator()->create_course($courseparams);
     354          } catch (moodle_exception $e) {
     355              $course = $this->getDataGenerator()->create_course();
     356              $courserecord = $courseparams;
     357              $courserecord['id'] = $course->id;
     358              unset($courserecord['students']);
     359  
     360              $DB->update_record_raw('course', $courserecord);
     361              $course = get_course($course->id);
     362          }
     363          $user = $this->getDataGenerator()->create_user();
     364  
     365          if (!empty($courseparams['enablecompletion'])) {
     366              $assign = $this->getDataGenerator()->create_module('assign', ['course' => $course->id, 'completion' => 1]);
     367              $cm = get_coursemodule_from_id('assign', $assign->cmid);
     368  
     369              $criteriadata = (object) [
     370                  'id' => $course->id,
     371                  'criteria_activity' => [
     372                      $cm->id => 1
     373                  ]
     374              ];
     375              $criterion = new completion_criteria_activity();
     376              $criterion->update_config($criteriadata);
     377          }
     378  
     379          $target = new \core_course\analytics\target\course_completion();
     380  
     381          // Test valid analysables.
     382  
     383          if (!empty($courseparams['students'])) {
     384              // Enroll user in course.
     385              $this->getDataGenerator()->enrol_user($user->id, $course->id);
     386          }
     387  
     388          $analysable = new \core_analytics\course($course);
     389          $this->assertEquals($isvalid, $target->is_valid_analysable($analysable, $fortraining));
     390      }
     391  
     392      /**
     393       * Test the conditions of a valid sample, both common and specific to this target (course_completion).
     394       *
     395       * @dataProvider sample_provider
     396       * @param int $coursestart Course start date
     397       * @param int $courseend Course end date
     398       * @param int $timestart Enrol start date
     399       * @param int $timeend Enrol end date
     400       * @param boolean $isvalidfortraining True when sample is valid for training, false when it is not
     401       * @param boolean $isvalidforprediction True when sample is valid for prediction, false when it is not
     402       */
     403      public function test_core_target_course_completion_samples($coursestart, $courseend, $timestart, $timeend,
     404              $isvalidfortraining, $isvalidforprediction) {
     405  
     406          $this->resetAfterTest(true);
     407  
     408          $courserecord = new stdClass();
     409          $courserecord->startdate = $coursestart;
     410          $courserecord->enddate = $courseend;
     411  
     412          $user = $this->getDataGenerator()->create_user();
     413          $course = $this->getDataGenerator()->create_course($courserecord);
     414          $this->getDataGenerator()->enrol_user($user->id, $course->id, null, 'manual', $timestart, $timeend);
     415  
     416          $target = new \core_course\analytics\target\course_completion();
     417          $analyser = new \core\analytics\analyser\student_enrolments(1, $target, [], [], []);
     418          $analysable = new \core_analytics\course($course);
     419  
     420          $class = new ReflectionClass('\core\analytics\analyser\student_enrolments');
     421          $method = $class->getMethod('get_all_samples');
     422          $method->setAccessible(true);
     423  
     424          list($sampleids, $samplesdata) = $method->invoke($analyser, $analysable);
     425          $target->add_sample_data($samplesdata);
     426          $sampleid = reset($sampleids);
     427  
     428          $this->assertEquals($isvalidfortraining, $target->is_valid_sample($sampleid, $analysable, true));
     429          $this->assertEquals($isvalidforprediction, $target->is_valid_sample($sampleid, $analysable, false));
     430      }
     431  
     432      /**
     433       * Test the conditions of a valid calculation (course_completion).
     434       *
     435       * @dataProvider active_during_analysis_time_provider
     436       * @param int $starttime Analysis start time
     437       * @param int $endtime Analysis end time
     438       * @param int $timestart Enrol start date
     439       * @param int $timeend Enrol end date
     440       * @param boolean $nullcalculation Whether the calculation should be null or not
     441       */
     442      public function test_core_target_course_completion_active_during_analysis_time($starttime, $endtime, $timestart, $timeend,
     443              $nullcalculation) {
     444  
     445          $this->resetAfterTest(true);
     446  
     447          $user = $this->getDataGenerator()->create_user();
     448          $course = $this->getDataGenerator()->create_course();
     449          $this->getDataGenerator()->enrol_user($user->id, $course->id, null, 'manual', $timestart, $timeend);
     450  
     451          $target = new \core_course\analytics\target\course_completion();
     452          $analyser = new \core\analytics\analyser\student_enrolments(1, $target, [], [], []);
     453          $analysable = new \core_analytics\course($course);
     454  
     455          $class = new ReflectionClass('\core\analytics\analyser\student_enrolments');
     456          $method = $class->getMethod('get_all_samples');
     457          $method->setAccessible(true);
     458  
     459          list($sampleids, $samplesdata) = $method->invoke($analyser, $analysable);
     460          $target->add_sample_data($samplesdata);
     461          $sampleid = reset($sampleids);
     462  
     463          $reftarget = new ReflectionObject($target);
     464          $refmethod = $reftarget->getMethod('calculate_sample');
     465          $refmethod->setAccessible(true);
     466  
     467          if ($nullcalculation) {
     468              $this->assertNull($refmethod->invoke($target, $sampleid, $analysable, $starttime, $endtime));
     469          } else {
     470              $this->assertNotNull($refmethod->invoke($target, $sampleid, $analysable, $starttime, $endtime));
     471          }
     472      }
     473  
     474      /**
     475       * Setup user, framework, competencies and course competencies.
     476       */
     477      protected function setup_competencies_environment() {
     478          $this->resetAfterTest(true);
     479          $now = time();
     480          $this->setAdminUser();
     481          $dg = $this->getDataGenerator();
     482          $lpg = $dg->get_plugin_generator('core_competency');
     483  
     484          $course = $dg->create_course(array('startdate' => $now - WEEKSECS, 'enddate' => $now - DAYSECS));
     485          $coursenocompetencies = $dg->create_course(array('startdate' => $now - WEEKSECS, 'enddate' => $now - DAYSECS));
     486  
     487          $u1 = $dg->create_user();
     488          $this->getDataGenerator()->enrol_user($u1->id, $course->id);
     489          $this->getDataGenerator()->enrol_user($u1->id, $coursenocompetencies->id);
     490          $f1 = $lpg->create_framework();
     491          $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
     492          $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
     493          $c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
     494          $c4 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
     495          $cc1 = $lpg->create_course_competency(array('competencyid' => $c1->get('id'), 'courseid' => $course->id,
     496              'ruleoutcome' => \core_competency\course_competency::OUTCOME_NONE));
     497          $cc2 = $lpg->create_course_competency(array('competencyid' => $c2->get('id'), 'courseid' => $course->id,
     498              'ruleoutcome' => \core_competency\course_competency::OUTCOME_EVIDENCE));
     499          $cc3 = $lpg->create_course_competency(array('competencyid' => $c3->get('id'), 'courseid' => $course->id,
     500              'ruleoutcome' => \core_competency\course_competency::OUTCOME_RECOMMEND));
     501          $cc4 = $lpg->create_course_competency(array('competencyid' => $c4->get('id'), 'courseid' => $course->id,
     502              'ruleoutcome' => \core_competency\course_competency::OUTCOME_COMPLETE));
     503  
     504          return array(
     505              'course' => $course,
     506              'coursenocompetencies' => $coursenocompetencies,
     507              'user' => $u1,
     508              'course_competencies' => array($cc1, $cc2, $cc3, $cc4)
     509          );
     510      }
     511  
     512       /**
     513        * Test the specific conditions of a valid analysable for the course_competencies target.
     514        */
     515      public function test_core_target_course_competencies_analysable() {
     516  
     517          $data = $this->setup_competencies_environment();
     518  
     519          $analysable = new \core_analytics\course($data['course']);
     520          $target = new \core_course\analytics\target\course_competencies();
     521  
     522          $this->assertTrue($target->is_valid_analysable($analysable));
     523  
     524          $analysable = new \core_analytics\course($data['coursenocompetencies']);
     525          $this->assertEquals(get_string('nocompetenciesincourse', 'tool_lp'), $target->is_valid_analysable($analysable));
     526      }
     527  
     528      /**
     529       * Test the target value calculation.
     530       */
     531      public function test_core_target_course_competencies_calculate() {
     532  
     533          $data = $this->setup_competencies_environment();
     534  
     535          $target = new \core_course\analytics\target\course_competencies();
     536          $analyser = new \core\analytics\analyser\student_enrolments(1, $target, [], [], []);
     537          $analysable = new \core_analytics\course($data['course']);
     538  
     539          $class = new ReflectionClass('\core\analytics\analyser\student_enrolments');
     540          $method = $class->getMethod('get_all_samples');
     541          $method->setAccessible(true);
     542  
     543          list($sampleids, $samplesdata) = $method->invoke($analyser, $analysable);
     544          $target->add_sample_data($samplesdata);
     545          $sampleid = reset($sampleids);
     546  
     547          $class = new ReflectionClass('\core_course\analytics\target\course_competencies');
     548          $method = $class->getMethod('calculate_sample');
     549          $method->setAccessible(true);
     550  
     551          // Method calculate_sample() returns 1 when the user has not achieved all the competencies assigned to the course.
     552          $this->assertEquals(1, $method->invoke($target, $sampleid, $analysable));
     553  
     554          // Grading of all the competences assigned to the course, in such way that the user achieves them all.
     555          foreach ($data['course_competencies'] as $competency) {
     556              \core_competency\api::grade_competency_in_course($data['course']->id, $data['user']->id,
     557                      $competency->get('competencyid'), 3, 'Unit test');
     558          }
     559          // Method calculate_sample() returns 0 when the user has achieved all the competencies assigned to the course.
     560          $this->assertEquals(0, $method->invoke($target, $sampleid, $analysable));
     561      }
     562  
     563      /**
     564       * Test the specific conditions of a valid analysable for the course_gradetopass target.
     565       */
     566      public function test_core_target_course_gradetopass_analysable() {
     567          global $DB;
     568  
     569          $this->resetAfterTest(true);
     570          $now = time();
     571  
     572          $dg = $this->getDataGenerator();
     573  
     574          // Course without grade to pass set.
     575          $course1 = $dg->create_course(array('startdate' => $now - WEEKSECS, 'enddate' => $now - DAYSECS));
     576          $student1 = $dg->create_user();
     577          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
     578          $dg->enrol_user($student1->id, $course1->id, $studentrole->id);
     579  
     580          $analysable = new \core_analytics\course($course1);
     581          $target = new \core_course\analytics\target\course_gradetopass();
     582          $this->assertEquals(get_string('gradetopassnotset', 'course'), $target->is_valid_analysable($analysable));
     583  
     584          // Set grade to pass.
     585          $courseitem = grade_item::fetch_course_item($course1->id);
     586          $courseitem->gradepass = 50;
     587          $DB->update_record('grade_items', $courseitem);
     588          // Since the grade to pass value is cached in the target, a new one it is instanciated.
     589          $target = new \core_course\analytics\target\course_gradetopass();
     590          $this->assertTrue($target->is_valid_analysable($analysable));
     591  
     592      }
     593  
     594      /**
     595       * Test the target value calculation of the course_gradetopass target.
     596       */
     597      public function test_core_target_course_gradetopass_calculate() {
     598          global $DB;
     599  
     600          $this->resetAfterTest(true);
     601  
     602          $dg = $this->getDataGenerator();
     603          $course1 = $dg->create_course();
     604          // Set grade to pass.
     605          $student1 = $dg->create_user();
     606          $student2 = $dg->create_user();
     607          $student3 = $dg->create_user();
     608          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
     609          $dg->enrol_user($student1->id, $course1->id, $studentrole->id);
     610          $dg->enrol_user($student2->id, $course1->id, $studentrole->id);
     611          $dg->enrol_user($student3->id, $course1->id, $studentrole->id);
     612  
     613          // get_all_samples() does not guarantee any order, so let's
     614          // explicitly define the expectations here for later comparing.
     615          // Expectations format being array($userid => expectation, ...)
     616          $expectations = [];
     617  
     618          $courseitem = grade_item::fetch_course_item($course1->id);
     619          // Student1 (< gradepass) fails, so it's non achieved sample.
     620          $courseitem->update_final_grade($student1->id, 30);
     621          $expectations[$student1->id] = 1;
     622  
     623          // Student2 (> gradepass) passes, so it's achieved sample.
     624          $courseitem->update_final_grade($student2->id, 60);
     625          $expectations[$student2->id] = 0;
     626  
     627          // Student 3 (has no grade) fails, so it's non achieved sample.
     628          $expectations[$student3->id] = 1;
     629  
     630          $courseitem->gradepass = 50;
     631          $DB->update_record('grade_items', $courseitem);
     632  
     633          $target = new \core_course\analytics\target\course_gradetopass();
     634          $analyser = new \core\analytics\analyser\student_enrolments(1, $target, [], [], []);
     635          $analysable = new \core_analytics\course($course1);
     636  
     637          $class = new ReflectionClass('\core\analytics\analyser\student_enrolments');
     638          $method = $class->getMethod('get_all_samples');
     639          $method->setAccessible(true);
     640  
     641          list($sampleids, $samplesdata) = $method->invoke($analyser, $analysable);
     642          $target->add_sample_data($samplesdata);
     643  
     644          $class = new ReflectionClass('\core_course\analytics\target\course_gradetopass');
     645          $method = $class->getMethod('calculate_sample');
     646          $method->setAccessible(true);
     647  
     648          // Verify all the expectations are fulfilled.
     649          foreach ($sampleids as $sampleid => $key) {
     650              $this->assertEquals($expectations[$samplesdata[$key]['user']->id], $method->invoke($target, $sampleid, $analysable));
     651          }
     652      }
     653  }