lib/grade/simpletest/testgradecategory.php

   1 <?php // $Id$
   2
   3 ///////////////////////////////////////////////////////////////////////////
   4 //                                                                       //
   5 // NOTICE OF COPYRIGHT                                                   //
   6 //                                                                       //
   7 // Moodle - Modular Object-Oriented Dynamic Learning Environment         //
   8 //          http://moodle.org                                            //
   9 //                                                                       //
  10 // Copyright (C) 1999-2004  Martin Dougiamas  http://dougiamas.com       //
  11 //                                                                       //
  12 // This program is free software; you can redistribute it and/or modify  //
  13 // it under the terms of the GNU General Public License as published by  //
  14 // the Free Software Foundation; either version 2 of the License, or     //
  15 // (at your option) any later version.                                   //
  16 //                                                                       //
  17 // This program is distributed in the hope that it will be useful,       //
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of        //
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //
  20 // GNU General Public License for more details:                          //
  21 //                                                                       //
  22 //          http://www.gnu.org/copyleft/gpl.html                         //
  23 //                                                                       //
  24 ///////////////////////////////////////////////////////////////////////////
  25
  26 /**
  27  * Unit tests for grade_category object.
  28  *
  29  * @author nicolas@moodle.com
  30  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  31  * @package moodlecore
  32  */
  33
  34 if (!defined('MOODLE_INTERNAL')) {
  35     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
  36 }
  37
  38 require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
  39
  40 class grade_category_test extends grade_test {
  41
  42     function test_grade_category_construct() {
  43         $course_category = grade_category::fetch_course_category($this->courseid);
  44
  45         $params = new stdClass();
  46
  47         $params->courseid = $this->courseid;
  48         $params->fullname = 'unittestcategory4';
  49
  50         $grade_category = new grade_category($params, false);
  51         $grade_category->insert();
  52
  53         $this->assertEqual($params->courseid, $grade_category->courseid);
  54         $this->assertEqual($params->fullname, $grade_category->fullname);
  55         $this->assertEqual(2, $grade_category->depth);
  56         $this->assertEqual("/$course_category->id/$grade_category->id", $grade_category->path);
  57         $parentpath = $grade_category->path;
  58
  59         // Test a child category
  60         $params->parent = $grade_category->id;
  61         $params->fullname = 'unittestcategory5';
  62         $grade_category = new grade_category($params, false);
  63         $grade_category->insert();
  64
  65         $this->assertEqual(3, $grade_category->depth);
  66         $this->assertEqual("$parentpath/$grade_category->id", $grade_category->path);
  67         $parentpath = $grade_category->path;
  68
  69         // Test a third depth category
  70         $params->parent = $grade_category->id;
  71         $params->fullname = 'unittestcategory6';
  72         $grade_category = new grade_category($params, false);
  73         $grade_category->insert();
  74         $this->assertEqual(4, $grade_category->depth);
  75         $this->assertEqual("$parentpath/$grade_category->id", $grade_category->path);
  76     }
  77
  78     function test_grade_category_insert() {
  79         $course_category = grade_category::fetch_course_category($this->courseid);
  80
  81         $grade_category = new grade_category();
  82         $this->assertTrue(method_exists($grade_category, 'insert'));
  83
  84         $grade_category->fullname    = 'unittestcategory4';
  85         $grade_category->courseid    = $this->courseid;
  86         $grade_category->aggregation = GRADE_AGGREGATE_MEAN_GRADED;
  87         $grade_category->keephigh    = 100;
  88         $grade_category->droplow     = 10;
  89         $grade_category->hidden      = 0;
  90         $grade_category->parent      = $this->grade_categories[0]->id;
  91
  92         $grade_category->insert();
  93
  94         $this->assertEqual('/'.$course_category->id.'/'.$this->grade_categories[0]->id.'/'.$grade_category->id, $grade_category->path);
  95         $this->assertEqual(3, $grade_category->depth);
  96
  97         $last_grade_category = end($this->grade_categories);
  98
  99         $this->assertFalse(empty($grade_category->grade_item));
 100         $this->assertEqual($grade_category->id, $grade_category->grade_item->iteminstance);
 101         $this->assertEqual('category', $grade_category->grade_item->itemtype);
 102
 103         $this->assertEqual($grade_category->id, $last_grade_category->id + 1);
 104         $this->assertFalse(empty($grade_category->timecreated));
 105         $this->assertFalse(empty($grade_category->timemodified));
 106     }
 107
 108     function test_grade_category_build_path() {
 109         $grade_category = new grade_category($this->grade_categories[1]);
 110         $path = grade_category::build_path($grade_category);
 111         $this->assertEqual($grade_category->path, $path);
 112     }
 113
 114     function test_grade_category_update() {
 115         $grade_category = new grade_category($this->grade_categories[0]);
 116         $this->assertTrue(method_exists($grade_category, 'update'));
 117
 118         $grade_category->fullname = 'Updated info for this unittest grade_category';
 119         $grade_category->path = null; // path must be recalculated if missing
 120         $grade_category->depth = null;
 121         $grade_category->aggregation = GRADE_AGGREGATE_MAX_ALL; // should force regrading
 122
 123         $grade_item = $grade_category->get_grade_item();
 124         $this->assertEqual(0, $grade_item->needsupdate);
 125
 126         $this->assertTrue($grade_category->update());
 127
 128         $fullname = get_field('grade_categories', 'fullname', 'id', $this->grade_categories[0]->id);
 129         $this->assertEqual($grade_category->fullname, $fullname);
 130
 131         $path = get_field('grade_categories', 'path', 'id', $this->grade_categories[0]->id);
 132         $this->assertEqual($grade_category->path, $path);
 133
 134         $depth = get_field('grade_categories', 'depth', 'id', $this->grade_categories[0]->id);
 135         $this->assertEqual($grade_category->depth, $depth);
 136
 137         $grade_item = $grade_category->get_grade_item();
 138         $this->assertEqual(1, $grade_item->needsupdate);
 139     }
 140
 141     function test_grade_category_qualifies_for_regrading() {
 142         $grade_category = new grade_category($this->grade_categories[0]);
 143         $this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
 144
 145         $this->assertFalse($grade_category->qualifies_for_regrading());
 146
 147         $grade_category->aggregation = GRADE_AGGREGATE_MAX_ALL;
 148         $this->assertTrue($grade_category->qualifies_for_regrading());
 149
 150         $grade_category = new grade_category($this->grade_categories[0]);
 151         $grade_category->droplow = 99;
 152         $this->assertTrue($grade_category->qualifies_for_regrading());
 153
 154         $grade_category = new grade_category($this->grade_categories[0]);
 155         $grade_category->keephigh = 99;
 156         $this->assertTrue($grade_category->qualifies_for_regrading());
 157     }
 158
 159     function test_grade_category_force_regrading() {
 160         $grade_category = new grade_category($this->grade_categories[1]);
 161         $this->assertTrue(method_exists($grade_category, 'force_regrading'));
 162
 163         $grade_category->load_grade_item();
 164         $this->assertEqual(0, $grade_category->grade_item->needsupdate);
 165
 166         $grade_category->force_regrading();
 167
 168         $grade_category->grade_item = null;
 169         $grade_category->load_grade_item();
 170
 171         $this->assertEqual(1, $grade_category->grade_item->needsupdate);
 172     }
 173
 174     function test_grade_category_delete() {
 175         $grade_category = new grade_category($this->grade_categories[0]);
 176         $this->assertTrue(method_exists($grade_category, 'delete'));
 177
 178         $this->assertTrue($grade_category->delete());
 179         $this->assertFalse(get_record('grade_categories', 'id', $grade_category->id));
 180     }
 181
 182     function test_grade_category_fetch() {
 183         $grade_category = new grade_category();
 184         $this->assertTrue(method_exists($grade_category, 'fetch'));
 185
 186         $grade_category = grade_category::fetch(array('id'=>$this->grade_categories[0]->id));
 187         $this->assertEqual($this->grade_categories[0]->id, $grade_category->id);
 188         $this->assertEqual($this->grade_categories[0]->fullname, $grade_category->fullname);
 189     }
 190
 191     function test_grade_category_fetch_all() {
 192         $grade_category = new grade_category();
 193         $this->assertTrue(method_exists($grade_category, 'fetch_all'));
 194
 195         $grade_categories = grade_category::fetch_all(array('courseid'=>$this->courseid));
 196         $this->assertEqual(count($this->grade_categories), count($grade_categories)-1);
 197     }
 198
 199     function test_grade_category_get_children() {
 200         $course_category = grade_category::fetch_course_category($this->courseid);
 201
 202         $category = new grade_category($this->grade_categories[0]);
 203         $this->assertTrue(method_exists($category, 'get_children'));
 204
 205         $children_array = $category->get_children(0);
 206
 207         $this->assertTrue(is_array($children_array));
 208         $this->assertFalse(empty($children_array[2]));
 209         $this->assertFalse(empty($children_array[2]['object']));
 210         $this->assertFalse(empty($children_array[2]['children']));
 211         $this->assertEqual($this->grade_categories[1]->id, $children_array[2]['object']->id);
 212         $this->assertEqual($this->grade_categories[2]->id, $children_array[5]['object']->id);
 213         $this->assertEqual($this->grade_items[0]->id, $children_array[2]['children'][3]['object']->id);
 214         $this->assertEqual($this->grade_items[1]->id, $children_array[2]['children'][4]['object']->id);
 215         $this->assertEqual($this->grade_items[2]->id, $children_array[5]['children'][6]['object']->id);
 216     }
 217
 218     function test_grade_category_get_grade_item() {
 219         $category = new grade_category($this->grade_categories[0]);
 220         $this->assertTrue(method_exists($category, 'get_grade_item'));
 221         $grade_item = $category->get_grade_item();
 222         $this->assertEqual($this->grade_items[3]->id, $grade_item->id);
 223     }
 224
 225     function test_grade_category_load_grade_item() {
 226         $category = new grade_category($this->grade_categories[0]);
 227         $this->assertTrue(method_exists($category, 'load_grade_item'));
 228         $this->assertEqual(null, $category->grade_item);
 229         $category->load_grade_item();
 230         $this->assertEqual($this->grade_items[3]->id, $category->grade_item->id);
 231     }
 232
 233     function test_grade_category_get_parent_category() {
 234         $category = new grade_category($this->grade_categories[1]);
 235         $this->assertTrue(method_exists($category, 'get_parent_category'));
 236         $parent_category = $category->get_parent_category();
 237         $this->assertEqual($this->grade_categories[0]->id, $parent_category->id);
 238     }
 239
 240     function test_grade_category_load_parent_category() {
 241         $category = new grade_category($this->grade_categories[1]);
 242         $this->assertTrue(method_exists($category, 'load_parent_category'));
 243         $this->assertEqual(null, $category->parent_category);
 244         $category->load_parent_category();
 245         $this->assertEqual($this->grade_categories[0]->id, $category->parent_category->id);
 246     }
 247
 248     function test_grade_category_get_name() {
 249         $category = new grade_category($this->grade_categories[0]);
 250         $this->assertTrue(method_exists($category, 'get_name'));
 251         $this->assertEqual($this->grade_categories[0]->fullname, $category->get_name());
 252     }
 253
 254     function test_grade_category_get_final() {
 255         $category = new grade_category($this->grade_categories[0]);
 256         $this->assertTrue(method_exists($category, 'get_final'));
 257         $category->load_grade_item();
 258         $this->assertEqual($category->get_final(), $category->grade_item->get_final());
 259     }
 260
 261     function test_grade_category_get_sortorder() {
 262         $category = new grade_category($this->grade_categories[0]);
 263         $this->assertTrue(method_exists($category, 'get_sortorder'));
 264         $category->load_grade_item();
 265         $this->assertEqual($category->get_sortorder(), $category->grade_item->get_sortorder());
 266     }
 267
 268     function test_grade_category_set_sortorder() {
 269         $category = new grade_category($this->grade_categories[0]);
 270         $this->assertTrue(method_exists($category, 'set_sortorder'));
 271         $category->load_grade_item();
 272         $this->assertEqual($category->set_sortorder(10), $category->grade_item->set_sortorder(10));
 273     }
 274
 275     function test_grade_category_move_after_sortorder() {
 276         $category = new grade_category($this->grade_categories[0]);
 277         $this->assertTrue(method_exists($category, 'move_after_sortorder'));
 278         $category->load_grade_item();
 279         $this->assertEqual($category->move_after_sortorder(10), $category->grade_item->move_after_sortorder(10));
 280     }
 281
 282     function test_grade_category_is_locked() {
 283         $category = new grade_category($this->grade_categories[0]);
 284         $this->assertTrue(method_exists($category, 'is_locked'));
 285         $category->load_grade_item();
 286         $this->assertEqual($category->is_locked(), $category->grade_item->is_locked());
 287     }
 288
 289     function test_grade_category_set_locked() {
 290         $category = new grade_category($this->grade_categories[0]);
 291         $this->assertTrue(method_exists($category, 'set_locked'));
 292         $this->assertTrue($category->set_locked(1));
 293     }
 294
 295     function test_grade_category_is_hidden() {
 296         $category = new grade_category($this->grade_categories[0]);
 297         $this->assertTrue(method_exists($category, 'is_hidden'));
 298         $category->load_grade_item();
 299         $this->assertEqual($category->is_hidden(), $category->grade_item->is_hidden());
 300     }
 301
 302     function test_grade_category_set_hidden() {
 303         $category = new grade_category($this->grade_categories[0]);
 304         $this->assertTrue(method_exists($category, 'set_hidden'));
 305         $category->set_hidden(1);
 306         $category->load_grade_item();
 307         $this->assertEqual(true, $category->grade_item->is_hidden());
 308     }
 309
 310     function test_grade_category_generate_grades() {
 311         $category = new grade_category($this->grade_categories[3]);
 312         $this->assertTrue(method_exists($category, 'generate_grades'));
 313         $category->load_grade_item();
 314
 315         $grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
 316         $this->assertFalse($grades);
 317
 318         $category->generate_grades();
 319         $grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
 320         $this->assertEqual(3, count($grades));
 321
 322         $rawvalues = array();
 323         foreach ($grades as $grade) {
 324             $this->assertWithinMargin($grade->rawgrade, $grade->rawgrademin, $grade->rawgrademax);
 325             $rawvalues[] = (int)$grade->rawgrade;
 326         }
 327         sort($rawvalues);
 328         // calculated mean results
 329         $this->assertEqual($rawvalues, array(20,50,100));
 330     }
 331
 332     function test_grade_category_aggregate_grades() {
 333         $category = new grade_category($this->grade_categories[0]);
 334         $this->assertTrue(method_exists($category, 'aggregate_grades'));
 335         // tested above in test_grade_category_generate_grades()
 336     }
 337
 338     function generate_random_raw_grade($item, $userid) {
 339         $grade = new grade_grade();
 340         $grade->itemid = $item->id;
 341         $grade->userid = $userid;
 342         $grade->grademin = 0;
 343         $grade->grademax = 1;
 344         $valuetype = "grade$item->gradetype";
 345         $grade->rawgrade = rand(0, 1000) / 1000;
 346         $grade->insert();
 347         return $grade->rawgrade;
 348     }
 349
 350     function test_grade_category_apply_limit_rules() {
 351         $category = new grade_category();
 352         $grades = array(5.374, 9.4743, 2.5474, 7.3754);
 353
 354         $category->droplow = 2;
 355         $category->apply_limit_rules($grades);
 356         sort($grades, SORT_NUMERIC);
 357         $this->assertEqual(array(7.3754, 9.4743), $grades);
 358
 359         $category = new grade_category();
 360         $grades = array(5.374, 9.4743, 2.5474, 7.3754);
 361
 362         $category->keephigh = 1;
 363         $category->droplow = 0;
 364         $category->apply_limit_rules($grades);
 365         $this->assertEqual(count($grades), 1);
 366         $grade = reset($grades);
 367         $this->assertEqual(9.4743, $grade);
 368     }
 369
 370     function test_grade_category_set_parent() {
 371         $category = new grade_category($this->grade_categories[1]);
 372         $this->assertTrue(method_exists($category, 'set_parent'));
 373         // TODO: implement detailed tests
 374
 375         $course_category = grade_category::fetch_course_category($this->courseid);
 376         $this->assertTrue($category->set_parent($course_category->id));
 377         $this->assertEqual($course_category->id, $category->parent);
 378     }
 379
 380     function test_grade_category_is_course_category() {
 381         $category = grade_category::fetch_course_category($this->courseid);
 382         $this->assertTrue(method_exists($category, 'is_course_category'));
 383         $this->assertTrue($category->is_course_category());
 384     }
 385
 386     function test_grade_category_fetch_course_category() {
 387         $category = new grade_category();
 388         $this->assertTrue(method_exists($category, 'fetch_course_category'));
 389         $category = grade_category::fetch_course_category($this->courseid);
 390         $this->assertTrue(empty($category->parent));
 391     }
 392
 393     function test_grade_category_fetch_course_tree() {
 394         $category = new grade_category();
 395         $this->assertTrue(method_exists($category, 'fetch_course_tree'));
 396         //TODO: add some tests
 397     }
 398 }
 399 ?>