[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  
  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  }