[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  [email protected]
  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  class core_grade_item_testcase extends grade_base_testcase {
  29      public function test_grade_item() {
  30          $this->sub_test_grade_item_construct();
  31          $this->sub_test_grade_item_insert();
  32          $this->sub_test_grade_item_delete();
  33          $this->sub_test_grade_item_update();
  34          $this->sub_test_grade_item_load_scale();
  35          $this->sub_test_grade_item_load_outcome();
  36          $this->sub_test_grade_item_qualifies_for_regrading();
  37          $this->sub_test_grade_item_force_regrading();
  38          $this->sub_test_grade_item_fetch();
  39          $this->sub_test_grade_item_fetch_all();
  40          $this->sub_test_grade_item_get_all_finals();
  41          $this->sub_test_grade_item_get_final();
  42          $this->sub_test_grade_item_get_sortorder();
  43          $this->sub_test_grade_item_set_sortorder();
  44          $this->sub_test_grade_item_move_after_sortorder();
  45          $this->sub_test_grade_item_get_name();
  46          $this->sub_test_grade_item_set_parent();
  47          $this->sub_test_grade_item_get_parent_category();
  48          $this->sub_test_grade_item_load_parent_category();
  49          $this->sub_test_grade_item_get_item_category();
  50          $this->sub_test_grade_item_load_item_category();
  51          $this->sub_test_grade_item_regrade_final_grades();
  52          $this->sub_test_grade_item_adjust_raw_grade();
  53          $this->sub_test_grade_item_set_locked();
  54          $this->sub_test_grade_item_is_locked();
  55          $this->sub_test_grade_item_set_hidden();
  56          $this->sub_test_grade_item_is_hidden();
  57          $this->sub_test_grade_item_is_category_item();
  58          $this->sub_test_grade_item_is_course_item();
  59          $this->sub_test_grade_item_fetch_course_item();
  60          $this->sub_test_grade_item_depends_on();
  61          $this->sub_test_refresh_grades();
  62          $this->sub_test_grade_item_is_calculated();
  63          $this->sub_test_grade_item_set_calculation();
  64          $this->sub_test_grade_item_get_calculation();
  65          $this->sub_test_grade_item_compute();
  66          $this->sub_test_update_final_grade();
  67          $this->sub_test_grade_item_can_control_visibility();
  68          $this->sub_test_grade_item_fix_sortorder();
  69      }
  70  
  71      protected function sub_test_grade_item_construct() {
  72          $params = new stdClass();
  73  
  74          $params->courseid = $this->courseid;
  75          $params->categoryid = $this->grade_categories[1]->id;
  76          $params->itemname = 'unittestgradeitem4';
  77          $params->itemtype = 'mod';
  78          $params->itemmodule = 'database';
  79          $params->iteminfo = 'Grade item used for unit testing';
  80  
  81          $grade_item = new grade_item($params, false);
  82  
  83          $this->assertEquals($params->courseid, $grade_item->courseid);
  84          $this->assertEquals($params->categoryid, $grade_item->categoryid);
  85          $this->assertEquals($params->itemmodule, $grade_item->itemmodule);
  86      }
  87  
  88      protected function sub_test_grade_item_insert() {
  89          $grade_item = new grade_item();
  90          $this->assertTrue(method_exists($grade_item, 'insert'));
  91  
  92          $grade_item->courseid = $this->courseid;
  93          $grade_item->categoryid = $this->grade_categories[1]->id;
  94          $grade_item->itemname = 'unittestgradeitem4';
  95          $grade_item->itemtype = 'mod';
  96          $grade_item->itemmodule = 'quiz';
  97          $grade_item->iteminfo = 'Grade item used for unit testing';
  98  
  99          $grade_item->insert();
 100  
 101          $last_grade_item = end($this->grade_items);
 102  
 103          $this->assertEquals($grade_item->id, $last_grade_item->id + 1);
 104          $this->assertEquals(18, $grade_item->sortorder);
 105  
 106          // Keep our reference collection the same as what is in the database.
 107          $this->grade_items[] = $grade_item;
 108      }
 109  
 110      protected function sub_test_grade_item_delete() {
 111          global $DB;
 112          $grade_item = new grade_item($this->grade_items[7], false); // Use a grade item not touched by previous (or future) tests.
 113          $this->assertTrue(method_exists($grade_item, 'delete'));
 114  
 115          $this->assertTrue($grade_item->delete());
 116  
 117          $this->assertFalse($DB->get_record('grade_items', array('id' => $grade_item->id)));
 118  
 119          // Keep our reference collection the same as the database.
 120          unset($this->grade_items[7]);
 121      }
 122  
 123      protected function sub_test_grade_item_update() {
 124          global $DB;
 125          $grade_item = new grade_item($this->grade_items[0], false);
 126          $this->assertTrue(method_exists($grade_item, 'update'));
 127  
 128          $grade_item->iteminfo = 'Updated info for this unittest grade_item';
 129  
 130          $this->assertTrue($grade_item->update());
 131  
 132          $grade_item->grademin = 14;
 133          $this->assertTrue($grade_item->qualifies_for_regrading());
 134          $this->assertTrue($grade_item->update());
 135  
 136          $iteminfo = $DB->get_field('grade_items', 'iteminfo', array('id' => $this->grade_items[0]->id));
 137          $this->assertEquals($grade_item->iteminfo, $iteminfo);
 138      }
 139  
 140      protected function sub_test_grade_item_load_scale() {
 141          $grade_item = new grade_item($this->grade_items[2], false);
 142          $this->assertTrue(method_exists($grade_item, 'load_scale'));
 143          $scale = $grade_item->load_scale();
 144          $this->assertFalse(empty($grade_item->scale));
 145          $this->assertEquals($scale->id, $this->grade_items[2]->scaleid);
 146      }
 147  
 148      protected function sub_test_grade_item_load_outcome() {
 149          $grade_item = new grade_item($this->grade_items[0], false);
 150          $this->assertTrue(method_exists($grade_item, 'load_outcome'));
 151          // TODO: add tests.
 152      }
 153  
 154      protected function sub_test_grade_item_qualifies_for_regrading() {
 155          $grade_item = new grade_item($this->grade_items[3], false); // Use a grade item not touched by previous tests.
 156          $this->assertTrue(method_exists($grade_item, 'qualifies_for_regrading'));
 157  
 158          $this->assertFalse($grade_item->qualifies_for_regrading());
 159  
 160          $grade_item->iteminfo = 'Updated info for this unittest grade_item';
 161  
 162          $this->assertFalse($grade_item->qualifies_for_regrading());
 163  
 164          $grade_item->grademin = 14;
 165  
 166          $this->assertTrue($grade_item->qualifies_for_regrading());
 167      }
 168  
 169      protected function sub_test_grade_item_force_regrading() {
 170          $grade_item = new grade_item($this->grade_items[3], false); // Use a grade item not touched by previous tests.
 171          $this->assertTrue(method_exists($grade_item, 'force_regrading'));
 172  
 173          $this->assertEquals(0, $grade_item->needsupdate);
 174  
 175          $grade_item->force_regrading();
 176          $this->assertEquals(1, $grade_item->needsupdate);
 177          $grade_item->update_from_db();
 178          $this->assertEquals(1, $grade_item->needsupdate);
 179      }
 180  
 181      protected function sub_test_grade_item_fetch() {
 182          $grade_item = new grade_item();
 183          $this->assertTrue(method_exists($grade_item, 'fetch'));
 184  
 185          // Not using $this->grade_items[0] as it's iteminfo was modified by sub_test_grade_item_qualifies_for_regrading().
 186          $grade_item = grade_item::fetch(array('id'=>$this->grade_items[1]->id));
 187          $this->assertEquals($this->grade_items[1]->id, $grade_item->id);
 188          $this->assertEquals($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
 189  
 190          $grade_item = grade_item::fetch(array('itemtype'=>$this->grade_items[1]->itemtype, 'itemmodule'=>$this->grade_items[1]->itemmodule));
 191          $this->assertEquals($this->grade_items[1]->id, $grade_item->id);
 192          $this->assertEquals($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
 193      }
 194  
 195      protected function sub_test_grade_item_fetch_all() {
 196          $grade_item = new grade_item();
 197          $this->assertTrue(method_exists($grade_item, 'fetch_all'));
 198  
 199          $grade_items = grade_item::fetch_all(array('courseid'=>$this->courseid));
 200          $this->assertEquals(count($this->grade_items), count($grade_items)-1); // -1 to account for the course grade item.
 201      }
 202  
 203      // Retrieve all final scores for a given grade_item.
 204      protected function sub_test_grade_item_get_all_finals() {
 205          $grade_item = new grade_item($this->grade_items[0], false);
 206          $this->assertTrue(method_exists($grade_item, 'get_final'));
 207  
 208          $final_grades = $grade_item->get_final();
 209          $this->assertEquals(3, count($final_grades));
 210      }
 211  
 212  
 213      // Retrieve all final scores for a specific userid.
 214      protected function sub_test_grade_item_get_final() {
 215          $grade_item = new grade_item($this->grade_items[0], false);
 216          $this->assertTrue(method_exists($grade_item, 'get_final'));
 217          $final_grade = $grade_item->get_final($this->user[1]->id);
 218          $this->assertEquals($this->grade_grades[0]->finalgrade, $final_grade->finalgrade);
 219      }
 220  
 221      protected function sub_test_grade_item_get_sortorder() {
 222          $grade_item = new grade_item($this->grade_items[0], false);
 223          $this->assertTrue(method_exists($grade_item, 'get_sortorder'));
 224          $sortorder = $grade_item->get_sortorder();
 225          $this->assertEquals($this->grade_items[0]->sortorder, $sortorder);
 226      }
 227  
 228      protected function sub_test_grade_item_set_sortorder() {
 229          $grade_item = new grade_item($this->grade_items[0], false);
 230          $this->assertTrue(method_exists($grade_item, 'set_sortorder'));
 231          $grade_item->set_sortorder(999);
 232          $this->assertEquals($grade_item->sortorder, 999);
 233      }
 234  
 235      protected function sub_test_grade_item_move_after_sortorder() {
 236          $grade_item = new grade_item($this->grade_items[0], false);
 237          $this->assertTrue(method_exists($grade_item, 'move_after_sortorder'));
 238          $grade_item->move_after_sortorder(5);
 239          $this->assertEquals($grade_item->sortorder, 6);
 240  
 241          $grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
 242          $this->assertEquals($grade_item->sortorder, 6);
 243  
 244          $after = grade_item::fetch(array('id'=>$this->grade_items[6]->id));
 245          $this->assertEquals($after->sortorder, 8);
 246      }
 247  
 248      protected function sub_test_grade_item_get_name() {
 249          $grade_item = new grade_item($this->grade_items[0], false);
 250          $this->assertTrue(method_exists($grade_item, 'get_name'));
 251  
 252          $name = $grade_item->get_name();
 253          $this->assertEquals($this->grade_items[0]->itemname, $name);
 254      }
 255  
 256      protected function sub_test_grade_item_set_parent() {
 257          $grade_item = new grade_item($this->grade_items[0], false);
 258          $this->assertTrue(method_exists($grade_item, 'set_parent'));
 259  
 260          $old = $grade_item->get_parent_category();
 261          $new = new grade_category($this->grade_categories[3], false);
 262          $new_item = $new->get_grade_item();
 263  
 264          $this->assertTrue($grade_item->set_parent($new->id));
 265  
 266          $new_item->update_from_db();
 267          $grade_item->update_from_db();
 268  
 269          $this->assertEquals($grade_item->categoryid, $new->id);
 270      }
 271  
 272      protected function sub_test_grade_item_get_parent_category() {
 273          $grade_item = new grade_item($this->grade_items[0], false);
 274          $this->assertTrue(method_exists($grade_item, 'get_parent_category'));
 275  
 276          $category = $grade_item->get_parent_category();
 277          $this->assertEquals($this->grade_categories[1]->fullname, $category->fullname);
 278      }
 279  
 280      protected function sub_test_grade_item_load_parent_category() {
 281          $grade_item = new grade_item($this->grade_items[0], false);
 282          $this->assertTrue(method_exists($grade_item, 'load_parent_category'));
 283  
 284          $category = $grade_item->load_parent_category();
 285          $this->assertEquals($this->grade_categories[1]->fullname, $category->fullname);
 286          $this->assertEquals($this->grade_categories[1]->fullname, $grade_item->parent_category->fullname);
 287      }
 288  
 289      protected function sub_test_grade_item_get_item_category() {
 290          $grade_item = new grade_item($this->grade_items[3], false);
 291          $this->assertTrue(method_exists($grade_item, 'get_item_category'));
 292  
 293          $category = $grade_item->get_item_category();
 294          $this->assertEquals($this->grade_categories[0]->fullname, $category->fullname);
 295      }
 296  
 297      protected function sub_test_grade_item_load_item_category() {
 298          $grade_item = new grade_item($this->grade_items[3], false);
 299          $this->assertTrue(method_exists($grade_item, 'load_item_category'));
 300  
 301          $category = $grade_item->load_item_category();
 302          $this->assertEquals($this->grade_categories[0]->fullname, $category->fullname);
 303          $this->assertEquals($this->grade_categories[0]->fullname, $grade_item->item_category->fullname);
 304      }
 305  
 306      protected function sub_test_grade_item_regrade_final_grades() {
 307          $grade_item = new grade_item($this->grade_items[0], false);
 308          $this->assertTrue(method_exists($grade_item, 'regrade_final_grades'));
 309          $this->assertEquals(true, $grade_item->regrade_final_grades());
 310          // TODO: add more tests.
 311      }
 312  
 313      protected function sub_test_grade_item_adjust_raw_grade() {
 314          $grade_item = new grade_item($this->grade_items[2], false); // Anything but assignment module!
 315          $this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
 316  
 317          $grade_raw = new stdClass();
 318          $grade_raw->rawgrade = 40;
 319          $grade_raw->grademax = 100;
 320          $grade_raw->grademin = 0;
 321  
 322          $grade_item->gradetype = GRADE_TYPE_VALUE;
 323          $grade_item->multfactor = 1;
 324          $grade_item->plusfactor = 0;
 325          $grade_item->grademax = 50;
 326          $grade_item->grademin = 0;
 327  
 328          $original_grade_raw  = clone($grade_raw);
 329          $original_grade_item = clone($grade_item);
 330  
 331          $this->assertEquals(20, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 332  
 333          // Try a larger maximum grade.
 334          $grade_item->grademax = 150;
 335          $grade_item->grademin = 0;
 336          $this->assertEquals(60, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 337  
 338          // Try larger minimum grade.
 339          $grade_item->grademin = 50;
 340  
 341          $this->assertEquals(90, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 342  
 343          // Rescaling from a small scale (0-50) to a larger scale (0-100).
 344          $grade_raw->grademax = 50;
 345          $grade_raw->grademin = 0;
 346          $grade_item->grademax = 100;
 347          $grade_item->grademin = 0;
 348  
 349          $this->assertEquals(80, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 350  
 351          // Rescaling from a small scale (0-50) to a larger scale with offset (40-100).
 352          $grade_item->grademax = 100;
 353          $grade_item->grademin = 40;
 354  
 355          $this->assertEquals(88, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 356  
 357          // Try multfactor and plusfactor.
 358          $grade_raw = clone($original_grade_raw);
 359          $grade_item = clone($original_grade_item);
 360          $grade_item->multfactor = 1.23;
 361          $grade_item->plusfactor = 3;
 362  
 363          $this->assertEquals(27.6, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 364  
 365          // Try multfactor below 0 and a negative plusfactor.
 366          $grade_raw = clone($original_grade_raw);
 367          $grade_item = clone($original_grade_item);
 368          $grade_item->multfactor = 0.23;
 369          $grade_item->plusfactor = -3;
 370  
 371          $this->assertEquals(round(1.6), round($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax)));
 372      }
 373  
 374      protected function sub_test_grade_item_set_locked() {
 375          // Getting a grade_item from the DB as set_locked() will fail if the grade items needs to be updated
 376          // also needs to have at least one grade_grade or $grade_item->get_final(1) returns null.
 377          // $grade_item = new grade_item($this->grade_items[8]);
 378          $grade_item = grade_item::fetch(array('id'=>$this->grade_items[8]->id));
 379  
 380          $this->assertTrue(method_exists($grade_item, 'set_locked'));
 381  
 382          $grade_grade = new grade_grade($grade_item->get_final($this->user[1]->id), false);
 383          $this->assertTrue(empty($grade_item->locked));// Not locked.
 384          $this->assertTrue(empty($grade_grade->locked));// Not locked.
 385  
 386          $this->assertTrue($grade_item->set_locked(true, true, false));
 387          $grade_grade = new grade_grade($grade_item->get_final($this->user[1]->id), false);
 388  
 389          $this->assertFalse(empty($grade_item->locked));// Locked.
 390          $this->assertFalse(empty($grade_grade->locked)); // Individual grades should be locked too.
 391  
 392          $this->assertTrue($grade_item->set_locked(false, true, false));
 393          $grade = new grade_grade($grade_item->get_final($this->user[1]->id), false);
 394  
 395          $this->assertTrue(empty($grade_item->locked));
 396          $this->assertTrue(empty($grade->locked)); // Individual grades should be unlocked too.
 397      }
 398  
 399      protected function sub_test_grade_item_is_locked() {
 400          $grade_item = new grade_item($this->grade_items[10], false);
 401          $this->assertTrue(method_exists($grade_item, 'is_locked'));
 402  
 403          $this->assertFalse($grade_item->is_locked());
 404          $this->assertFalse($grade_item->is_locked($this->user[1]->id));
 405          $this->assertTrue($grade_item->set_locked(true, true, false));
 406          $this->assertTrue($grade_item->is_locked());
 407          $this->assertTrue($grade_item->is_locked($this->user[1]->id));
 408      }
 409  
 410      protected function sub_test_grade_item_set_hidden() {
 411          $grade_item = new grade_item($this->grade_items[0], false);
 412          $this->assertTrue(method_exists($grade_item, 'set_hidden'));
 413  
 414          $grade = new grade_grade($grade_item->get_final($this->user[1]->id), false);
 415          $this->assertEquals(0, $grade_item->hidden);
 416          $this->assertEquals(0, $grade->hidden);
 417  
 418          $grade_item->set_hidden(666, true);
 419          $grade = new grade_grade($grade_item->get_final($this->user[1]->id), false);
 420  
 421          $this->assertEquals(666, $grade_item->hidden);
 422          $this->assertEquals(666, $grade->hidden);
 423      }
 424  
 425      protected function sub_test_grade_item_is_hidden() {
 426          $grade_item = new grade_item($this->grade_items[0], false);
 427          $this->assertTrue(method_exists($grade_item, 'is_hidden'));
 428  
 429          $this->assertFalse($grade_item->is_hidden());
 430          $this->assertFalse($grade_item->is_hidden(1));
 431  
 432          $grade_item->set_hidden(1);
 433          $this->assertTrue($grade_item->is_hidden());
 434          $this->assertTrue($grade_item->is_hidden(1));
 435  
 436          $grade_item->set_hidden(666);
 437          $this->assertFalse($grade_item->is_hidden());
 438          $this->assertFalse($grade_item->is_hidden(1));
 439  
 440          $grade_item->set_hidden(time()+666);
 441          $this->assertTrue($grade_item->is_hidden());
 442          $this->assertTrue($grade_item->is_hidden(1));
 443      }
 444  
 445      protected function sub_test_grade_item_is_category_item() {
 446          $grade_item = new grade_item($this->grade_items[3], false);
 447          $this->assertTrue(method_exists($grade_item, 'is_category_item'));
 448          $this->assertTrue($grade_item->is_category_item());
 449      }
 450  
 451      protected function sub_test_grade_item_is_course_item() {
 452          $grade_item = grade_item::fetch_course_item($this->courseid);
 453          $this->assertTrue(method_exists($grade_item, 'is_course_item'));
 454          $this->assertTrue($grade_item->is_course_item());
 455      }
 456  
 457      protected function sub_test_grade_item_fetch_course_item() {
 458          $grade_item = grade_item::fetch_course_item($this->courseid);
 459          $this->assertTrue(method_exists($grade_item, 'fetch_course_item'));
 460          $this->assertEquals($grade_item->itemtype, 'course');
 461      }
 462  
 463      protected function sub_test_grade_item_depends_on() {
 464          global $CFG;
 465  
 466          $origenableoutcomes = $CFG->enableoutcomes;
 467          $CFG->enableoutcomes = 0;
 468          $grade_item = new grade_item($this->grade_items[1], false);
 469  
 470          // Calculated grade dependency.
 471          $deps = $grade_item->depends_on();
 472          sort($deps, SORT_NUMERIC); // For comparison.
 473          $this->assertEquals(array($this->grade_items[0]->id), $deps);
 474  
 475          // Simulate depends on returns none when locked.
 476          $grade_item->locked = time();
 477          $grade_item->update();
 478          $deps = $grade_item->depends_on();
 479          sort($deps, SORT_NUMERIC); // For comparison.
 480          $this->assertEquals(array(), $deps);
 481  
 482          // Category dependency.
 483          $grade_item = new grade_item($this->grade_items[3], false);
 484          $deps = $grade_item->depends_on();
 485          sort($deps, SORT_NUMERIC); // For comparison.
 486          $res = array($this->grade_items[4]->id, $this->grade_items[5]->id);
 487          $this->assertEquals($res, $deps);
 488      }
 489  
 490      protected function scales_outcomes_test_grade_item_depends_on() {
 491          $CFG->enableoutcomes = 1;
 492          $origgradeincludescalesinaggregation = $CFG->grade_includescalesinaggregation;
 493          $CFG->grade_includescalesinaggregation = 1;
 494  
 495          // Scale item in category with $CFG->grade_includescalesinaggregation = 1.
 496          $grade_item = new grade_item($this->grade_items[14], false);
 497          $deps = $grade_item->depends_on();
 498          sort($deps, SORT_NUMERIC);
 499          $res = array($this->grade_items[16]->id);
 500          $this->assertEquals($res, $deps);
 501  
 502          // Scale item in category with $CFG->grade_includescalesinaggregation = 0.
 503          $CFG->grade_includescalesinaggregation = 0;
 504          $grade_item = new grade_item($this->grade_items[14], false);
 505          $deps = $grade_item->depends_on();
 506          $res = array();
 507          $this->assertEquals($res, $deps);
 508          $CFG->grade_includescalesinaggregation = 1;
 509  
 510          // Outcome item in category with outcomes disabled.
 511          $CFG->enableoutcomes = 0;
 512          $grade_item = new grade_item($this->grade_items[14], false);
 513          $deps = $grade_item->depends_on();
 514          sort($deps, SORT_NUMERIC);
 515          $res = array($this->grade_items[16]->id, $this->grade_items[17]->id);
 516          $this->assertEquals($res, $deps);
 517  
 518          $CFG->enableoutcomes = $origenableoutcomes;
 519          $CFG->grade_includescalesinaggregation = $origgradeincludescalesinaggregation;
 520      }
 521  
 522      protected function sub_test_refresh_grades() {
 523          // Testing with the grade item for a mod_assignment instance.
 524          $grade_item = new grade_item($this->grade_items[0], false);
 525          $this->assertTrue(method_exists($grade_item, 'refresh_grades'));
 526          $this->assertTrue($grade_item->refresh_grades());
 527  
 528          // Break the grade item and check error handling.
 529          $grade_item->iteminstance = 123456789;
 530          $this->assertFalse($grade_item->refresh_grades());
 531          $this->assertDebuggingCalled();
 532      }
 533  
 534      protected function sub_test_grade_item_is_calculated() {
 535          $grade_item = new grade_item($this->grade_items[1], false);
 536          $this->assertTrue(method_exists($grade_item, 'is_calculated'));
 537          $this->assertTrue($grade_item->is_calculated());
 538  
 539          $grade_item = new grade_item($this->grade_items[0], false);
 540          $this->assertFalse($grade_item->is_calculated());
 541      }
 542  
 543      protected function sub_test_grade_item_set_calculation() {
 544          $grade_item = new grade_item($this->grade_items[1], false);
 545          $this->assertTrue(method_exists($grade_item, 'set_calculation'));
 546          $grade_itemsource = new grade_item($this->grade_items[0], false);
 547  
 548          $grade_item->set_calculation('=[['.$grade_itemsource->idnumber.']]');
 549  
 550          $this->assertTrue(!empty($grade_item->needsupdate));
 551          $this->assertEquals('=##gi'.$grade_itemsource->id.'##', $grade_item->calculation);
 552      }
 553  
 554      protected function sub_test_grade_item_get_calculation() {
 555          $grade_item = new grade_item($this->grade_items[1], false);
 556          $this->assertTrue(method_exists($grade_item, 'get_calculation'));
 557          $grade_itemsource = new grade_item($this->grade_items[0], false);
 558  
 559          $denormalizedformula = str_replace('##gi'.$grade_itemsource->id.'##', '[['.$grade_itemsource->idnumber.']]', $this->grade_items[1]->calculation);
 560  
 561          $formula = $grade_item->get_calculation();
 562          $this->assertTrue(!empty($grade_item->needsupdate));
 563          $this->assertEquals($denormalizedformula, $formula);
 564      }
 565  
 566      public function sub_test_grade_item_compute() {
 567          $grade_item = grade_item::fetch(array('id'=>$this->grade_items[1]->id));
 568          $this->assertTrue(method_exists($grade_item, 'compute'));
 569  
 570          // Check the grade_grades in the array match those in the DB then delete $this->grade_items[1]'s grade_grades.
 571          $this->grade_grades[3] = grade_grade::fetch(array('id'=>$this->grade_grades[3]->id));
 572          $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[3]->id));
 573          $grade_grade->delete();
 574  
 575          $this->grade_grades[4] = grade_grade::fetch(array('id'=>$this->grade_grades[4]->id));
 576          $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[4]->id));
 577          $grade_grade->delete();
 578  
 579          $this->grade_grades[5] = grade_grade::fetch(array('id'=>$this->grade_grades[5]->id));
 580          $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[5]->id));
 581          $grade_grade->delete();
 582  
 583          // Recalculate the grades (its a calculation so pulls values from other grade_items) and reinsert them.
 584          $grade_item->compute();
 585  
 586          $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[3]->userid, 'itemid'=>$this->grade_grades[3]->itemid));
 587          $this->assertEquals($this->grade_grades[3]->finalgrade, $grade_grade->finalgrade);
 588  
 589          $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[4]->userid, 'itemid'=>$this->grade_grades[4]->itemid));
 590          $this->assertEquals($this->grade_grades[4]->finalgrade, $grade_grade->finalgrade);
 591  
 592          $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[5]->userid, 'itemid'=>$this->grade_grades[5]->itemid));
 593          $this->assertEquals($this->grade_grades[5]->finalgrade, $grade_grade->finalgrade);
 594      }
 595  
 596      protected function sub_test_update_final_grade() {
 597  
 598          // MDL-31713 Check that min and max are set on the grade_grade instance
 599          // if the grade is overridden before the activity has supplied a grade.
 600          $min = 2;
 601          $max = 8;
 602  
 603          // Create a brand new grade item.
 604          $grade_item = new grade_item();
 605          $this->assertTrue(method_exists($grade_item, 'insert'));
 606  
 607          $grade_item->courseid = $this->courseid;
 608          $grade_item->categoryid = $this->grade_categories[1]->id;
 609          $grade_item->itemname = 'brand new unit test grade item';
 610          $grade_item->itemtype = 'mod';
 611          $grade_item->itemmodule = 'quiz';
 612          $grade_item->iteminfo = 'Grade item used for unit testing';
 613          $grade_item->grademin = $min;
 614          $grade_item->grademax = $max;
 615          $grade_item->insert();
 616  
 617          // Override the student grade.
 618          $grade_item->update_final_grade($this->user[1]->id, 7, 'gradebook', '', FORMAT_MOODLE);
 619  
 620          // Check the student's grade has the correct min and max grade.
 621          $grade_grade = grade_grade::fetch(array('userid'=>$this->user[1]->id, 'itemid'=>$grade_item->id));
 622          $this->assertEquals($min, $grade_grade->rawgrademin);
 623          $this->assertEquals($max, $grade_grade->rawgrademax);
 624      }
 625  
 626      protected function sub_test_grade_item_can_control_visibility() {
 627          // Grade item 0 == Course module 0 == Assignment.
 628          $grade_item = new grade_item($this->grade_items[0], false);
 629          $this->assertTrue($grade_item->can_control_visibility());
 630  
 631          // Grade item  == Course module 7 == Quiz.
 632          $grade_item = new grade_item($this->grade_items[11], false);
 633          $this->assertFalse($grade_item->can_control_visibility());
 634      }
 635  
 636      /**
 637       * Test the {@link grade_item::fix_duplicate_sortorder() function with
 638       * faked duplicate sortorder data.
 639       */
 640      public function sub_test_grade_item_fix_sortorder() {
 641          global $DB;
 642  
 643          $this->resetAfterTest(true);
 644  
 645          // Each set is used for filling the db with fake data and will be representing the result of query:
 646          // "SELECT sortorder from {grade_items} WHERE courseid=? ORDER BY id".
 647          $testsets = array(
 648              // Items that need no action.
 649              array(1,2,3),
 650              array(5,6,7),
 651              array(7,6,1,3,2,5),
 652              // Items with sortorder duplicates
 653              array(1,2,2,3,3,4,5),
 654              // Only one sortorder duplicate.
 655              array(1,1),
 656              array(3,3),
 657              // Non-sequential sortorders with one or multiple duplicates.
 658              array(3,3,7,5,6,6,9,10,8,3),
 659              array(7,7,3),
 660              array(3,4,5,3,5,4,7,1)
 661          );
 662          $origsequence = array();
 663  
 664          // Generate the data and remember the initial sequence or items.
 665          foreach ($testsets as $testset) {
 666              $course = $this->getDataGenerator()->create_course();
 667              foreach ($testset as $sortorder) {
 668                  $this->insert_fake_grade_item_sortorder($course->id, $sortorder);
 669              }
 670              $DB->get_records('grade_items');
 671              $origsequence[$course->id] = $DB->get_fieldset_sql("SELECT id FROM {grade_items} ".
 672                  "WHERE courseid = ? ORDER BY sortorder, id", array($course->id));
 673          }
 674  
 675          $duplicatedetectionsql = "SELECT courseid, sortorder
 676                                      FROM {grade_items}
 677                                  WHERE courseid = :courseid
 678                                  GROUP BY courseid, sortorder
 679                                    HAVING COUNT(id) > 1";
 680  
 681          // Do the work.
 682          foreach ($origsequence as $courseid => $ignore) {
 683              grade_item::fix_duplicate_sortorder($courseid);
 684              // Verify that no duplicates are left in the database.
 685              $dupes = $DB->record_exists_sql($duplicatedetectionsql, array('courseid' => $courseid));
 686              $this->assertFalse($dupes);
 687          }
 688  
 689          // Verify that sequences are exactly the same as they were before upgrade script.
 690          $idx = 0;
 691          foreach ($origsequence as $courseid => $sequence) {
 692              if (count(($testsets[$idx])) == count(array_unique($testsets[$idx]))) {
 693                  // If there were no duplicates for this course verify that sortorders are not modified.
 694                  $newsortorders = $DB->get_fieldset_sql("SELECT sortorder from {grade_items} WHERE courseid=? ORDER BY id", array($courseid));
 695                  $this->assertEquals($testsets[$idx], $newsortorders);
 696              }
 697              $newsequence = $DB->get_fieldset_sql("SELECT id FROM {grade_items} ".
 698                  "WHERE courseid = ? ORDER BY sortorder, id", array($courseid));
 699              $this->assertEquals($sequence, $newsequence,
 700                      "Sequences do not match for test set $idx : ".join(',', $testsets[$idx]));
 701              $idx++;
 702          }
 703      }
 704  
 705      /**
 706       * Populate some fake grade items into the database with specified
 707       * sortorder and course id.
 708       *
 709       * NOTE: This function doesn't make much attempt to respect the
 710       * gradebook internals, its simply used to fake some data for
 711       * testing the upgradelib function. Please don't use it for other
 712       * purposes.
 713       *
 714       * @param int $courseid id of course
 715       * @param int $sortorder numeric sorting order of item
 716       * @return stdClass grade item object from the database.
 717       */
 718      private function insert_fake_grade_item_sortorder($courseid, $sortorder) {
 719          global $DB, $CFG;
 720          require_once($CFG->libdir.'/gradelib.php');
 721  
 722          $item = new stdClass();
 723          $item->courseid = $courseid;
 724          $item->sortorder = $sortorder;
 725          $item->gradetype = GRADE_TYPE_VALUE;
 726          $item->grademin = 30;
 727          $item->grademax = 110;
 728          $item->itemnumber = 1;
 729          $item->iteminfo = '';
 730          $item->timecreated = time();
 731          $item->timemodified = time();
 732  
 733          $item->id = $DB->insert_record('grade_items', $item);
 734  
 735          return $DB->get_record('grade_items', array('id' => $item->id));
 736      }
 737  }