mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-04-21 16:32:18 +02:00
Code Issues Projects Releases Wiki Activity

complete unit tests for grade_category, minor API cleanup, fixed forced regrading in grade_category

Browse Source
This commit is contained in:
skodak 2007-07-03 10:06:08 +00:00
parent 5dcb429b34
commit 6639ead31e
4 changed files with 211 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
lib/grade/grade_category.php
View File

@ -137,7 +137,6 @@ class grade_category extends grade_object {
}
}
/**
* Finds and returns a grade_category instance based on params.
* @static
@ -173,15 +172,18 @@ class grade_category extends grade_object {
$this->depth = substr_count($this->path, '/');
}
if (!parent::update()) {
return false;
}
// Recalculate grades if needed
if ($this->qualifies_for_regrading()) {
if (!parent::update()) {
return false;
}
$this->grade_item->force_regrading();
return true;
} else {
return parent::update();
}
return true;
}
/**
@ -270,10 +272,11 @@ class grade_category extends grade_object {
*/
function qualifies_for_regrading() {
if (empty($this->id)) {
debugging("Can not regrade non existing category");
return false;
}
$db_item = new grade_category(array('id' => $this->id));
$db_item = grade_category::fetch(array('id'=>$this->id));
$aggregationdiff = $db_item->aggregation != $this->aggregation;
$keephighdiff = $db_item->keephigh != $this->keephigh;
@ -293,7 +296,7 @@ class grade_category extends grade_object {
*/
function force_regrading() {
if (empty($this->id)) {
debugging("Needsupdate requested before insering grade category.");
debugging("Needsupdate requested before inserting grade category.");
return true;
}
@ -781,25 +784,6 @@ class grade_category extends grade_object {
}
}
/**
* Returns this category's grade_item's id. This is specified for cases where we do not
* know an object's type, and want to get either an item's id or a category's item's id.
*
* @return int
*/
function get_item_id() {
$this->load_grade_item();
return $this->grade_item->id;
}
/**
* Returns this category's parent id. A generic method shared by objects that have a parent id of some kind.
* @return id $parentid
*/
function get_parent_id() {
return $this->parent;
}
/**
* Sets this category's parent id. A generic method shared by objects that have a parent id of some kind.
* @param int parentid
@ -867,6 +851,10 @@ class grade_category extends grade_object {
$this->grade_item->set_sortorder($sortorder);
}
/**
* Move this category after the given sortorder - does not change the parent
* @param int $sortorder to place after
*/
function move_after_sortorder($sortorder) {
$this->load_grade_item();
$this->grade_item->move_after_sortorder($sortorder);

28
lib/grade/grade_item.php
View File

@ -1003,34 +1003,6 @@ class grade_item extends grade_object {
}
}
/**
* Returns this grade_item's id. This is specified for cases where we do not
* know an object's type, and want to get either an item's id or a category's item's id.
*
* @return int
*/
function get_item_id() {
return $this->id;
}
/**
* Returns this item's category id. A generic method shared by objects that have a parent id of some kind.
* @return int $parentid
*/
function get_parent_id() {
if ($this->is_course_item()) {
return false;
} else if ($this->is_category_item()) {
return $category->id;
} else {
return $this->categoryid;
;
}
}
/**
* Sets this item's categoryid. A generic method shared by objects that have a parent id of some kind.
* @param int $parentid

24
lib/simpletest/fixtures/gradetest.php
View File

@ -506,7 +506,7 @@ class grade_test extends UnitTestCase {
$grade_item->grademax = 110;
$grade_item->itemnumber = 1;
$grade_item->idnumber = 'item id 0';
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 0 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 3;
@ -529,7 +529,7 @@ class grade_test extends UnitTestCase {
$grade_item->itemnumber = null;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 1 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 4;
@ -551,7 +551,7 @@ class grade_test extends UnitTestCase {
$grade_item->scaleid = $this->scale[0]->id;
$grade_item->grademin = 0;
$grade_item->grademax = $this->scalemax[0];
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 2 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 6;
@ -567,12 +567,12 @@ class grade_test extends UnitTestCase {
$grade_item->courseid = $this->courseid;
$grade_item->iteminstance = $this->grade_categories[0]->id;
$grade_item->itemname = 'unittestgradeitemcategory1';
$grade_item->needsupdate = true;
$grade_item->needsupdate = 0;
$grade_item->itemtype = 'category';
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 3 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 1;
@ -589,10 +589,10 @@ class grade_test extends UnitTestCase {
$grade_item->itemname = 'unittestgradeitemcategory2';
$grade_item->itemtype = 'category';
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->needsupdate = true;
$grade_item->needsupdate = 0;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 4 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 2;
@ -612,7 +612,7 @@ class grade_test extends UnitTestCase {
$grade_item->needsupdate = true;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 5 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 5;
@ -636,7 +636,7 @@ class grade_test extends UnitTestCase {
$grade_item->grademin = 10;
$grade_item->grademax = 120;
$grade_item->locked = time();
$grade_item->iteminfo = 'Orphan Grade item used for unit testing';
$grade_item->iteminfo = 'Orphan Grade 6 item used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 7;
@ -659,7 +659,7 @@ class grade_test extends UnitTestCase {
$grade_item->scaleid = $this->scale[0]->id;
$grade_item->grademin = 0;
$grade_item->grademax = $this->scalemax[0];
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 7 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 9;
@ -680,7 +680,7 @@ class grade_test extends UnitTestCase {
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->iteminfo = 'Grade item 8 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 10;
@ -702,7 +702,7 @@ class grade_test extends UnitTestCase {
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Orphan Grade item used for unit testing';
$grade_item->iteminfo = 'Orphan Grade 9 item used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 8;

187
lib/simpletest/grade/simpletest/testgradecategory.php
View File

@ -92,6 +92,7 @@ class grade_category_test extends grade_test {
$grade_category->insert();
$this->assertEqual('/'.$course_category->id.'/'.$this->grade_categories[0]->id.'/'.$grade_category->id, $grade_category->path);
$this->assertEqual(3, $grade_category->depth);
$last_grade_category = end($this->grade_categories);
@ -104,15 +105,77 @@ class grade_category_test extends grade_test {
$this->assertFalse(empty($grade_category->timemodified));
}
function test_grade_category_build_path() {
$grade_category = new grade_category($this->grade_categories[1]);
$path = grade_category::build_path($grade_category);
$this->assertEqual($grade_category->path, $path);
}
function test_grade_category_update() {
$grade_category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($grade_category, 'update'));
$grade_category->fullname = 'Updated info for this unittest grade_category';
$grade_category->path = null; // path must be recalculated if missing
$grade_category->depth = null;
$grade_category->aggregation = GRADE_AGGREGATE_MAX; // should force regrading
$grade_item = $grade_category->get_grade_item();
$this->assertEqual(0, $grade_item->needsupdate);
$this->assertTrue($grade_category->update());
$fullname = get_field('grade_categories', 'fullname', 'id', $this->grade_categories[0]->id);
$this->assertEqual($grade_category->fullname, $fullname);
$path = get_field('grade_categories', 'path', 'id', $this->grade_categories[0]->id);
$this->assertEqual($grade_category->path, $path);
$depth = get_field('grade_categories', 'depth', 'id', $this->grade_categories[0]->id);
$this->assertEqual($grade_category->depth, $depth);
$grade_item = $grade_category->get_grade_item();
$this->assertEqual(1, $grade_item->needsupdate);
}
function test_grade_category_qualifies_for_regrading() {
$grade_category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
$this->assertFalse($grade_category->qualifies_for_regrading());
$grade_category->aggregation = GRADE_AGGREGATE_MAX;
$this->assertTrue($grade_category->qualifies_for_regrading());
$grade_category = new grade_category($this->grade_categories[0]);
$grade_category->droplow = 99;
$this->assertTrue($grade_category->qualifies_for_regrading());
$grade_category = new grade_category($this->grade_categories[0]);
$grade_category->keephigh = 99;
$this->assertTrue($grade_category->qualifies_for_regrading());
}
function test_grade_category_force_regrading() {
$grade_category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($grade_category, 'force_regrading'));
$grade_category->load_grade_item();
$parent_category = new grade_category($this->grade_categories[1]);
$parent_category->load_grade_item();
$this->assertEqual(0, $grade_category->grade_item->needsupdate);
$this->assertEqual(0, $parent_category->grade_item->needsupdate);
$this->assertTrue($grade_category->force_regrading());
$grade_category->grade_item = null;
$parent_category->grade_item = null;
$grade_category->load_grade_item();
$parent_category->load_grade_item();
$this->assertEqual(1, $grade_category->grade_item->needsupdate);
$this->assertEqual(1, $parent_category->grade_item->needsupdate);
}
function test_grade_category_delete() {
@ -159,6 +222,98 @@ class grade_category_test extends grade_test {
$this->assertEqual($this->grade_items[2]->id, $children_array[5]['children'][6]['object']->id);
}
function test_grade_category_get_grade_item() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'get_grade_item'));
$grade_item = $category->get_grade_item();
$this->assertEqual($this->grade_items[3]->id, $grade_item->id);
}
function test_grade_category_load_grade_item() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'load_grade_item'));
$this->assertEqual(null, $category->grade_item);
$category->load_grade_item();
$this->assertEqual($this->grade_items[3]->id, $category->grade_item->id);
}
function test_grade_category_get_parent_category() {
$category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($category, 'get_parent_category'));
$parent_category = $category->get_parent_category();
$this->assertEqual($this->grade_categories[0]->id, $parent_category->id);
}
function test_grade_category_load_parent_category() {
$category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($category, 'load_parent_category'));
$this->assertEqual(null, $category->parent_category);
$category->load_parent_category();
$this->assertEqual($this->grade_categories[0]->id, $category->parent_category->id);
}
function test_grade_category_get_name() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'get_name'));
$this->assertEqual($this->grade_categories[0]->fullname, $category->get_name());
}
function test_grade_category_get_final() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'get_final'));
$category->load_grade_item();
$this->assertEqual($category->get_final(), $category->grade_item->get_final());
}
function test_grade_category_get_sortorder() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'get_sortorder'));
$category->load_grade_item();
$this->assertEqual($category->get_sortorder(), $category->grade_item->get_sortorder());
}
function test_grade_category_set_sortorder() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'set_sortorder'));
$category->load_grade_item();
$this->assertEqual($category->set_sortorder(10), $category->grade_item->set_sortorder(10));
}
function test_grade_category_move_after_sortorder() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'move_after_sortorder'));
$category->load_grade_item();
$this->assertEqual($category->move_after_sortorder(10), $category->grade_item->move_after_sortorder(10));
}
function test_grade_category_is_locked() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'is_locked'));
$category->load_grade_item();
$this->assertEqual($category->is_locked(), $category->grade_item->is_locked());
}
function test_grade_category_set_locked() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'set_locked'));
$category->load_grade_item();
$this->assertEqual($category->set_locked(1), $category->grade_item->set_locked(1));
}
function test_grade_category_is_hidden() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'is_hidden'));
$category->load_grade_item();
$this->assertEqual($category->is_hidden(), $category->grade_item->is_hidden());
}
function test_grade_category_set_hidden() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'set_hidden'));
$category->load_grade_item();
$this->assertEqual($category->set_hidden(1), $category->grade_item->set_hidden(1));
}
function test_grade_category_has_children() {
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'has_children'));
@ -207,7 +362,6 @@ class grade_category_test extends grade_test {
return $grade->rawgrade;
}
/*
function test_grade_category_apply_limit_rules() {
$category = new grade_category();
$grades = array(5.374, 9.4743, 2.5474, 7.3754);
@ -224,6 +378,35 @@ class grade_category_test extends grade_test {
$category->droplow = 0;
$category->apply_limit_rules($grades);
$this->assertEqual(array(9.4743), $grades);
}*/
}
function test_grade_category_set_parent() {
$category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($category, 'set_parent'));
// TODO: implement detailed tests
$course_category = grade_category::fetch_course_category($this->courseid);
$this->assertTrue($category->set_parent($course_category->id));
$this->assertEqual($course_category->id, $category->parent);
}
function test_grade_category_is_course_category() {
$category = grade_category::fetch_course_category($this->courseid);
$this->assertTrue(method_exists($category, 'is_course_category'));
$this->assertTrue($category->is_course_category());
}
function test_grade_category_fetch_course_category() {
$category = new grade_category();
$this->assertTrue(method_exists($category, 'fetch_course_category'));
$category = grade_category::fetch_course_category($this->courseid);
$this->assertTrue(empty($category->parent));
}
function test_grade_category_fetch_course_tree() {
$category = new grade_category();
$this->assertTrue(method_exists($category, 'fetch_course_tree'));
//TODO: add some tests
}
}
?>