[Summary view] [Print] [Text view]

   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   * @package    core_grades
  19   * @category   phpunit
  20   * @copyright  nicolas@moodle.com
  21   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  22   */
  23  
  24  defined('MOODLE_INTERNAL') || die();
  25  
  26  require_once (__DIR__.'/fixtures/lib.php');
  27  
  28  
  29  class core_grade_grade_testcase extends grade_base_testcase {
  30  
  31      public function test_grade_grade() {
  32          $this->sub_test_grade_grade_construct();
  33          $this->sub_test_grade_grade_insert();
  34          $this->sub_test_grade_grade_update();
  35          $this->sub_test_grade_grade_fetch();
  36          $this->sub_test_grade_grade_fetch_all();
  37          $this->sub_test_grade_grade_load_grade_item();
  38          $this->sub_test_grade_grade_standardise_score();
  39          $this->sub_test_grade_grade_is_locked();
  40          $this->sub_test_grade_grade_set_hidden();
  41          $this->sub_test_grade_grade_is_hidden();
  42      }
  43  
  44      protected function sub_test_grade_grade_construct() {
  45          $params = new stdClass();
  46  
  47          $params->itemid = $this->grade_items[0]->id;
  48          $params->userid = 1;
  49          $params->rawgrade = 88;
  50          $params->rawgrademax = 110;
  51          $params->rawgrademin = 18;
  52  
  53          $grade_grade = new grade_grade($params, false);
  54          $this->assertEquals($params->itemid, $grade_grade->itemid);
  55          $this->assertEquals($params->rawgrade, $grade_grade->rawgrade);
  56      }
  57  
  58      protected function sub_test_grade_grade_insert() {
  59          $grade_grade = new grade_grade();
  60          $this->assertTrue(method_exists($grade_grade, 'insert'));
  61  
  62          $grade_grade->itemid = $this->grade_items[0]->id;
  63          $grade_grade->userid = 10;
  64          $grade_grade->rawgrade = 88;
  65          $grade_grade->rawgrademax = 110;
  66          $grade_grade->rawgrademin = 18;
  67  
  68          // Check the grade_item's needsupdate variable first.
  69          $grade_grade->load_grade_item();
  70          $this->assertEmpty($grade_grade->grade_item->needsupdate);
  71  
  72          $grade_grade->insert();
  73  
  74          $last_grade_grade = end($this->grade_grades);
  75  
  76          $this->assertEquals($grade_grade->id, $last_grade_grade->id + 1);
  77  
  78          // Timecreated will only be set if the grade was submitted by an activity module.
  79          $this->assertTrue(empty($grade_grade->timecreated));
  80          // Timemodified will only be set if the grade was submitted by an activity module.
  81          $this->assertTrue(empty($grade_grade->timemodified));
  82  
  83          // Keep our collection the same as is in the database.
  84          $this->grade_grades[] = $grade_grade;
  85      }
  86  
  87      protected function sub_test_grade_grade_update() {
  88          $grade_grade = new grade_grade($this->grade_grades[0], false);
  89          $this->assertTrue(method_exists($grade_grade, 'update'));
  90      }
  91  
  92      protected function sub_test_grade_grade_fetch() {
  93          $grade_grade = new grade_grade();
  94          $this->assertTrue(method_exists($grade_grade, 'fetch'));
  95  
  96          $grades = grade_grade::fetch(array('id'=>$this->grade_grades[0]->id));
  97          $this->assertEquals($this->grade_grades[0]->id, $grades->id);
  98          $this->assertEquals($this->grade_grades[0]->rawgrade, $grades->rawgrade);
  99      }
 100  
 101      protected function sub_test_grade_grade_fetch_all() {
 102          $grade_grade = new grade_grade();
 103          $this->assertTrue(method_exists($grade_grade, 'fetch_all'));
 104  
 105          $grades = grade_grade::fetch_all(array());
 106          $this->assertEquals(count($this->grade_grades), count($grades));
 107      }
 108  
 109      protected function sub_test_grade_grade_load_grade_item() {
 110          $grade_grade = new grade_grade($this->grade_grades[0], false);
 111          $this->assertTrue(method_exists($grade_grade, 'load_grade_item'));
 112          $this->assertNull($grade_grade->grade_item);
 113          $this->assertNotEmpty($grade_grade->itemid);
 114          $this->assertNotNull($grade_grade->load_grade_item());
 115          $this->assertNotNull($grade_grade->grade_item);
 116          $this->assertEquals($this->grade_items[0]->id, $grade_grade->grade_item->id);
 117      }
 118  
 119  
 120      protected function sub_test_grade_grade_standardise_score() {
 121          $this->assertEquals(4, round(grade_grade::standardise_score(6, 0, 7, 0, 5)));
 122          $this->assertEquals(40, grade_grade::standardise_score(50, 30, 80, 0, 100));
 123      }
 124  
 125  
 126      /*
 127       * Disabling this test: the set_locked() arguments have been modified, rendering these tests useless until they are re-written
 128  
 129      protected function test_grade_grade_set_locked() {
 130          $grade_item = new grade_item($this->grade_items[0]);
 131          $grade = new grade_grade($grade_item->get_final(1));
 132          $this->assertTrue(method_exists($grade, 'set_locked'));
 133  
 134          $this->assertTrue(empty($grade_item->locked));
 135          $this->assertTrue(empty($grade->locked));
 136  
 137          $this->assertTrue($grade->set_locked(true));
 138          $this->assertFalse(empty($grade->locked));
 139          $this->assertTrue($grade->set_locked(false));
 140          $this->assertTrue(empty($grade->locked));
 141  
 142          $this->assertTrue($grade_item->set_locked(true, true));
 143          $grade = new grade_grade($grade_item->get_final(1));
 144  
 145          $this->assertFalse(empty($grade->locked));
 146          $this->assertFalse($grade->set_locked(true, false));
 147  
 148          $this->assertTrue($grade_item->set_locked(true, false));
 149          $grade = new grade_grade($grade_item->get_final(1));
 150  
 151          $this->assertTrue($grade->set_locked(true, false));
 152      }
 153      */
 154  
 155      protected function sub_test_grade_grade_is_locked() {
 156          $grade = new grade_grade($this->grade_grades[0], false);
 157          $this->assertTrue(method_exists($grade, 'is_locked'));
 158  
 159          $this->assertFalse($grade->is_locked());
 160          $grade->locked = time();
 161          $this->assertTrue($grade->is_locked());
 162      }
 163  
 164      protected function sub_test_grade_grade_set_hidden() {
 165          $grade = new grade_grade($this->grade_grades[0], false);
 166          $grade_item = new grade_item($this->grade_items[0], false);
 167          $this->assertTrue(method_exists($grade, 'set_hidden'));
 168  
 169          $this->assertEquals(0, $grade_item->hidden);
 170          $this->assertEquals(0, $grade->hidden);
 171  
 172          $grade->set_hidden(0);
 173          $this->assertEquals(0, $grade->hidden);
 174  
 175          $grade->set_hidden(1);
 176          $this->assertEquals(1, $grade->hidden);
 177  
 178          $grade->set_hidden(0);
 179          $this->assertEquals(0, $grade->hidden);
 180      }
 181  
 182      protected function sub_test_grade_grade_is_hidden() {
 183          $grade = new grade_grade($this->grade_grades[0], false);
 184          $this->assertTrue(method_exists($grade, 'is_hidden'));
 185  
 186          $this->assertFalse($grade->is_hidden());
 187          $grade->hidden = 1;
 188          $this->assertTrue($grade->is_hidden());
 189  
 190          $grade->hidden = time()-666;
 191          $this->assertFalse($grade->is_hidden());
 192  
 193          $grade->hidden = time()+666;
 194          $this->assertTrue($grade->is_hidden());
 195      }
 196  
 197      public function test_flatten_dependencies() {
 198          // First test a simple normal case.
 199          $a = array(1 => array(2, 3), 2 => array(), 3 => array(4), 4 => array());
 200          $b = array();
 201          $expecteda = array(1 => array(2, 3, 4), 2 => array(), 3 => array(4), 4 => array());
 202          $expectedb = array(1 => 1);
 203  
 204          test_grade_grade_flatten_dependencies_array::test_flatten_dependencies_array($a, $b);
 205          $this->assertSame($expecteda, $a);
 206          $this->assertSame($expectedb, $b);
 207  
 208          // Edge case - empty arrays.
 209          $a = $b = $expecteda = $expectedb = array();
 210  
 211          test_grade_grade_flatten_dependencies_array::test_flatten_dependencies_array($a, $b);
 212          $this->assertSame($expecteda, $a);
 213          $this->assertSame($expectedb, $b);
 214  
 215          // Circular dependency.
 216          $a = array(1 => array(2), 2 => array(3), 3 => array(1));
 217          $b = array();
 218          $expecteda = array(1 => array(1, 2, 3), 2 => array(1, 2, 3), 3 => array(1, 2, 3));
 219  
 220          test_grade_grade_flatten_dependencies_array::test_flatten_dependencies_array($a, $b);
 221          $this->assertSame($expecteda, $a);
 222          // Note - we don't test the depth when we got circular dependencies - the main thing we wanted to test was that there was
 223          // no ka-boom. The result would be hard to understand and doesn't matter.
 224  
 225          // Circular dependency 2.
 226          $a = array(1 => array(2), 2 => array(3), 3 => array(4), 4 => array(2, 1));
 227          $b = array();
 228          $expecteda = array(1 => array(1, 2, 3, 4), 2 => array(1, 2, 3, 4), 3 => array(1, 2, 3, 4), 4 => array(1, 2, 3, 4));
 229  
 230          test_grade_grade_flatten_dependencies_array::test_flatten_dependencies_array($a, $b);
 231          $this->assertSame($expecteda, $a);
 232      }
 233  
 234      public function test_grade_grade_min_max() {
 235          global $CFG;
 236          $initialminmaxtouse = $CFG->grade_minmaxtouse;
 237  
 238          $this->setAdminUser();
 239          $course = $this->getDataGenerator()->create_course();
 240          $user = $this->getDataGenerator()->create_user();
 241          $assignrecord = $this->getDataGenerator()->create_module('assign', array('course' => $course, 'grade' => 100));
 242          $cm = get_coursemodule_from_instance('assign', $assignrecord->id);
 243          $assigncontext = context_module::instance($cm->id);
 244          $assign = new assign($assigncontext, $cm, $course);
 245  
 246          // Fetch the assignment item.
 247          $giparams = array('itemtype' => 'mod', 'itemmodule' => 'assign', 'iteminstance' => $assignrecord->id,
 248                  'courseid' => $course->id, 'itemnumber' => 0);
 249          $gi = grade_item::fetch($giparams);
 250          $this->assertEquals(0, $gi->grademin);
 251          $this->assertEquals(100, $gi->grademax);
 252  
 253          // Give a grade to the student.
 254          $usergrade = $assign->get_user_grade($user->id, true);
 255          $usergrade->grade = 10;
 256          $assign->update_grade($usergrade);
 257  
 258          // Check the grade stored in gradebook.
 259          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 260          $this->assertEquals(10, $gg->rawgrade);
 261          $this->assertEquals(0, $gg->get_grade_min());
 262          $this->assertEquals(100, $gg->get_grade_max());
 263  
 264          // Change the min/max grade of the item.
 265          $gi->grademax = 50;
 266          $gi->grademin = 2;
 267          $gi->update();
 268  
 269          // Fetch the updated item.
 270          $gi = grade_item::fetch($giparams);
 271  
 272          // Now check the grade grade min/max with system setting.
 273          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 274          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting.
 275  
 276          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 277          $this->assertEquals(2, $gg->get_grade_min());
 278          $this->assertEquals(50, $gg->get_grade_max());
 279  
 280          // Now with other system setting.
 281          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 282          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting, and reset static cache.
 283          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 284          $this->assertEquals(0, $gg->get_grade_min());
 285          $this->assertEquals(100, $gg->get_grade_max());
 286  
 287          // Now with overriden setting in course.
 288          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 289          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_GRADE);
 290          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 291          $this->assertEquals(0, $gg->get_grade_min());
 292          $this->assertEquals(100, $gg->get_grade_max());
 293  
 294          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 295          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_ITEM);
 296          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 297          $this->assertEquals(2, $gg->get_grade_min());
 298          $this->assertEquals(50, $gg->get_grade_max());
 299  
 300          $CFG->grade_minmaxtouse = $initialminmaxtouse;
 301      }
 302  
 303      public function test_grade_grade_min_max_with_course_item() {
 304          global $CFG, $DB;
 305          $initialminmaxtouse = $CFG->grade_minmaxtouse;
 306  
 307          $this->setAdminUser();
 308          $course = $this->getDataGenerator()->create_course();
 309          $user = $this->getDataGenerator()->create_user();
 310          $gi = grade_item::fetch_course_item($course->id);
 311  
 312          // Fetch the category item.
 313          $this->assertEquals(0, $gi->grademin);
 314          $this->assertEquals(100, $gi->grademax);
 315  
 316          // Give a grade to the student.
 317          $gi->update_final_grade($user->id, 10);
 318  
 319          // Check the grade min/max stored in gradebook.
 320          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 321          $this->assertEquals(0, $gg->get_grade_min());
 322          $this->assertEquals(100, $gg->get_grade_max());
 323  
 324          // Change the min/max grade of the item.
 325          $gi->grademin = 2;
 326          $gi->grademax = 50;
 327          $gi->update();
 328  
 329          // Fetch the updated item.
 330          $gi = grade_item::fetch_course_item($course->id);
 331  
 332          // Now check the grade grade min/max with system setting.
 333          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 334          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting.
 335  
 336          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 337          $this->assertEquals(0, $gg->get_grade_min());
 338          $this->assertEquals(100, $gg->get_grade_max());
 339  
 340          // Now with other system setting.
 341          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 342          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting, and reset static cache.
 343          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 344          $this->assertEquals(0, $gg->get_grade_min());
 345          $this->assertEquals(100, $gg->get_grade_max());
 346  
 347          // Now with overriden setting in course.
 348          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 349          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_GRADE);
 350          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 351          $this->assertEquals(0, $gg->get_grade_min());
 352          $this->assertEquals(100, $gg->get_grade_max());
 353  
 354          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 355          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_ITEM);
 356          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 357          $this->assertEquals(0, $gg->get_grade_min());
 358          $this->assertEquals(100, $gg->get_grade_max());
 359  
 360          $CFG->grade_minmaxtouse = $initialminmaxtouse;
 361      }
 362  
 363      public function test_grade_grade_min_max_with_category_item() {
 364          global $CFG, $DB;
 365          $initialminmaxtouse = $CFG->grade_minmaxtouse;
 366  
 367          $this->setAdminUser();
 368          $course = $this->getDataGenerator()->create_course();
 369          $user = $this->getDataGenerator()->create_user();
 370          $coursegi = grade_item::fetch_course_item($course->id);
 371  
 372          // Create a category item.
 373          $gc = new grade_category(array('courseid' => $course->id, 'fullname' => 'test'), false);
 374          $gc->insert();
 375          $gi = $gc->get_grade_item();
 376          $gi->grademax = 100;
 377          $gi->grademin = 0;
 378          $gi->update();
 379  
 380          // Fetch the category item.
 381          $giparams = array('itemtype' => 'category', 'iteminstance' => $gc->id);
 382          $gi = grade_item::fetch($giparams);
 383          $this->assertEquals(0, $gi->grademin);
 384          $this->assertEquals(100, $gi->grademax);
 385  
 386          // Give a grade to the student.
 387          $gi->update_final_grade($user->id, 10);
 388  
 389          // Check the grade min/max stored in gradebook.
 390          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 391          $this->assertEquals(0, $gg->get_grade_min());
 392          $this->assertEquals(100, $gg->get_grade_max());
 393  
 394          // Change the min/max grade of the item.
 395          $gi->grademin = 2;
 396          $gi->grademax = 50;
 397          $gi->update();
 398  
 399          // Fetch the updated item.
 400          $gi = grade_item::fetch($giparams);
 401  
 402          // Now check the grade grade min/max with system setting.
 403          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 404          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting.
 405  
 406          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 407          $this->assertEquals(0, $gg->get_grade_min());
 408          $this->assertEquals(100, $gg->get_grade_max());
 409  
 410          // Now with other system setting.
 411          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 412          grade_set_setting($course->id, 'minmaxtouse', null); // Ensure no course setting, and reset static cache.
 413          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 414          $this->assertEquals(0, $gg->get_grade_min());
 415          $this->assertEquals(100, $gg->get_grade_max());
 416  
 417          // Now with overriden setting in course.
 418          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_ITEM;
 419          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_GRADE);
 420          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 421          $this->assertEquals(0, $gg->get_grade_min());
 422          $this->assertEquals(100, $gg->get_grade_max());
 423  
 424          $CFG->grade_minmaxtouse = GRADE_MIN_MAX_FROM_GRADE_GRADE;
 425          grade_set_setting($course->id, 'minmaxtouse', GRADE_MIN_MAX_FROM_GRADE_ITEM);
 426          $gg = grade_grade::fetch(array('userid' => $user->id, 'itemid' => $gi->id));
 427          $this->assertEquals(0, $gg->get_grade_min());
 428          $this->assertEquals(100, $gg->get_grade_max());
 429  
 430          $CFG->grade_minmaxtouse = $initialminmaxtouse;
 431      }
 432  }