mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-04-23 17:34:56 +02:00
Code Issues Projects Releases Wiki Activity

complete unit tests for grade_item + minor cleanup in insert and update

Browse Source
This commit is contained in:
skodak 2007-07-04 17:52:43 +00:00
parent 225e707187
commit c3146da7ac
3 changed files with 177 additions and 72 deletions
lib
grade
grade_item.php
simpletest
fixtures
gradetest.php
grade/simpletest
testgradeitem.php

69
lib/grade/grade_item.php

@ -229,27 +229,8 @@ class grade_item extends grade_object {
* @return boolean success
*/
function update() {
if (!empty($this->outcome->id)) {
$this->outcomeid = $this->outcome->id;
}
if (!isset($this->gradetype)) {
$this->gradetype = GRADE_TYPE_VALUE;
}
if (empty($this->scaleid) and !empty($this->scale->id)) {
$this->scaleid = $this->scale->id;
}
// Retrieve scale and infer grademax from it
if ($this->gradetype == GRADE_TYPE_SCALE and !empty($this->scaleid)) {
$this->load_scale();
} else {
$this->scaleid = NULL;
$this->scale = NULL;
}
// Retrieve scale and infer grademax/min from it if needed
$this->load_scale();
if ($this->qualifies_for_regrading()) {
return $this->force_regrading();
@ -341,19 +322,10 @@ class grade_item extends grade_object {
error('Can not insert grade item without course id!');
}
if (empty($this->scaleid) and !empty($this->scale->id)) {
$this->scaleid = $this->scale->id;
}
// Retrieve scale and infer grademax from it
if ($this->gradetype == GRADE_TYPE_SCALE and !empty($this->scaleid)) {
$this->load_scale();
} else {
$this->scaleid = NULL;
$this->scale = NULL;
}
// load scale if needed
$this->load_scale();
// add parent categroy if needed
if (empty($this->categoryid) and !$this->is_course_item() and !$this->is_category_item()) {
$course_category = grade_category::fetch_course_category($this->courseid);
$this->categoryid = $course_category->id;
@ -376,22 +348,16 @@ class grade_item extends grade_object {
$this->idnumber = rand(0,9999999999); // TODO replace rand() with proper random generator
}
}
/*
// If a grade_item already exists with these itemtype, itemmodule and iteminstance
// but not itemnumber, generate an itemnumber.
if (empty($this->itemnumber) && !empty($this->itemtype) && !empty($this->itemmodule) && !empty($this->iteminstance)) {
$existing_item = get_record('grade_items',
'iteminstance', $this->iteminstance,
'itemmodule', $this->itemmodule,
'itemtype', $this->itemtype);
if (empty($existing_item->itemnumber)) {
$existing_item->itemnumber = 0;
// add proper item numbers to manual items
if ($this->itemtype == 'manual') {
if (empty($this->itemnumber)) {
$this->itemnumber = 0;
}
while (grade_item::fetch(array('courseid'=>$this->courseid, 'itemtype'=>'manual', 'itemnumber'=>$this->itemnumber))) {
$this->itemnumber++;
}
$this->itemnumber = $existing_item->itemnumber + 1;
}
*/
$result = parent::insert();
@ -737,7 +703,7 @@ class grade_item extends grade_object {
/**
* Instantiates a grade_scale object whose data is retrieved from the DB,
* if this item's scaleid variable is set.
* @return object grade_scale
* @return object grade_scale or null if no scale used
*/
function load_scale() {
if ($this->gradetype != GRADE_TYPE_SCALE) {
@ -745,13 +711,17 @@ class grade_item extends grade_object {
}
if (!empty($this->scaleid)) {
$this->scale = grade_scale::fetch(array('id'=>$this->scaleid));
$this->scale->load_items();
//do not load scale if already present
if (empty($this->scale->id) or $this->scale->id != $this->scaleid) {
$this->scale = grade_scale::fetch(array('id'=>$this->scaleid));
$this->scale->load_items();
}
// Until scales are uniformly set to min=0 max=count(scaleitems)-1 throughout Moodle, we
// stay with the current min=1 max=count(scaleitems)
$this->grademax = count($this->scale->scale_items);
$this->grademin = 1;
} else {
$this->scale = null;
}
@ -999,7 +969,6 @@ class grade_item extends grade_object {
} else {
return get_string('grade');
}
}

23
lib/simpletest/fixtures/gradetest.php

@ -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 9 item used for unit testing';
$grade_item->iteminfo = 'Orphan Grade item 9 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
$grade_item->sortorder = 8;
@ -711,6 +711,27 @@ class grade_test extends UnitTestCase {
$this->grade_items[9] = $grade_item;
}
// Manual grade_item
// id = 10
$grade_item = new stdClass();
$grade_item->courseid = $this->courseid;
$grade_item->categoryid = $course_category->id;
$grade_item->itemname = 'manual grade_item';
$grade_item->itemtype = 'manual';
$grade_item->itemnumber = 0;
$grade_item->needsupdate = false;
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->iteminfo = 'Manual grade item 10 used for unit testing';
$grade_item->timecreated = mktime();
$grade_item->timemodified = mktime();
if ($grade_item->id = insert_record('grade_items', $grade_item)) {
$this->grade_items[10] = $grade_item;
}
}
/**

157
lib/simpletest/grade/simpletest/testgradeitem.php

@ -86,37 +86,20 @@ class grade_item_test extends grade_test {
$this->assertEqual($grade_item->id, $last_grade_item->id + 1);
$this->assertEqual(11, $grade_item->sortorder);
}
/*
function test_grade_item_generate_itemnumber() {
$grade_item = new grade_item($this->grade_items[0]);
function test_grade_item_generate_itemnumber_for_manual() {
$grade_item = new grade_item($this->grade_items[10]);
$copy_grade_item = fullclone($grade_item);
$copy_grade_item->itemnumber = null;
unset($copy_grade_item->id);
$result_id = $copy_grade_item->insert();
$this->assertEqual($grade_item->itemnumber+1, $copy_grade_item->itemnumber);
}
*/
function test_grade_item_generate_idnumber() {
}
function test_grade_item_update_when_flagged_as_deleted() {
}
function test_grade_item_update_guess_outcomeid() {
}
function test_grade_item_update_default_gradetype() {
}
function test_grade_item_update_guess_scaleid() {
}
function test_grade_item_delete() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'delete'));
@ -166,6 +149,20 @@ class grade_item_test extends grade_test {
$this->assertEqual($grade_item->iteminfo, $iteminfo);
}
function test_grade_item_load_scale() {
$grade_item = new grade_item($this->grade_items[2]);
$this->assertTrue(method_exists($grade_item, 'load_scale'));
$scale = $grade_item->load_scale();
$this->assertFalse(empty($grade_item->scale));
$this->assertEqual($scale->id, $this->grade_items[2]->scaleid);
}
function test_grade_item_load_outcome() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'load_outcome'));
//TODO: add tests
}
function test_grade_item_qualifies_for_regrading() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'qualifies_for_regrading'));
@ -181,6 +178,23 @@ class grade_item_test extends grade_test {
$this->assertTrue($grade_item->qualifies_for_regrading());
}
function test_grade_item_force_regrading() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'force_regrading'));
$grade_category = $grade_item->get_parent_category();
$grade_category->load_grade_item();
$this->assertEqual(0, $grade_item->needsupdate);
$this->assertEqual(0, $grade_category->grade_item->needsupdate);
$this->assertTrue($grade_item->force_regrading());
$grade_category = $grade_item->get_parent_category();
$grade_category->load_grade_item();
$this->assertEqual(1, $grade_item->needsupdate);
$this->assertEqual(1, $grade_category->grade_item->needsupdate);
}
function test_grade_item_fetch() {
$grade_item = new grade_item();
$this->assertTrue(method_exists($grade_item, 'fetch'));
@ -224,6 +238,62 @@ class grade_item_test extends grade_test {
$this->assertEqual($this->grade_grades[0]->finalgrade, $final_grade->finalgrade);
}
function test_grade_item_get_sortorder() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_sortorder'));
$sortorder = $grade_item->get_sortorder();
$this->assertEqual($this->grade_items[0]->sortorder, $sortorder);
}
function test_grade_item_set_sortorder() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_sortorder'));
$grade_item->set_sortorder(999);
$this->assertEqual($grade_item->sortorder, 999);
}
function test_grade_item_move_after_sortorder() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'move_after_sortorder'));
$grade_item->move_after_sortorder(5);
$this->assertEqual($grade_item->sortorder, 6);
$grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
$this->assertEqual($grade_item->sortorder, 6);
$after = grade_item::fetch(array('id'=>$this->grade_items[6]->id));
$this->assertEqual($after->sortorder, 8);
}
function test_grade_item_get_name() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_name'));
$name = $grade_item->get_name();
$this->assertEqual($this->grade_items[0]->itemname, $name);
}
function test_grade_item_set_parent() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_parent'));
$old = $grade_item->get_parent_category();
$old_item = $old->get_grade_item();
$new = new grade_category($this->grade_categories[3]);
$new_item = $new->get_grade_item();
$this->assertEqual($old_item->needsupdate, 0);
$this->assertTrue($grade_item->set_parent($new->id));
$new_item->update_from_db();
$old_item->update_from_db();
$grade_item->update_from_db();
$this->assertEqual($old_item->needsupdate, 1);
$this->assertEqual($grade_item->categoryid, $new->id);
}
function test_grade_item_get_parent_category() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_parent_category'));
@ -232,6 +302,32 @@ class grade_item_test extends grade_test {
$this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
}
function test_grade_item_load_parent_category() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'load_parent_category'));
$category = $grade_item->load_parent_category();
$this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
$this->assertEqual($this->grade_categories[1]->fullname, $grade_item->parent_category->fullname);
}
function test_grade_item_get_item_category() {
$grade_item = new grade_item($this->grade_items[3]);
$this->assertTrue(method_exists($grade_item, 'get_item_category'));
$category = $grade_item->get_item_category();
$this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
}
function test_grade_item_load_item_category() {
$grade_item = new grade_item($this->grade_items[3]);
$this->assertTrue(method_exists($grade_item, 'load_item_category'));
$category = $grade_item->load_item_category();
$this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
$this->assertEqual($this->grade_categories[0]->fullname, $grade_item->item_category->fullname);
}
/**
* Test update of all final grades
*/
@ -239,6 +335,7 @@ class grade_item_test extends grade_test {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'update_final_grades'));
$this->assertEqual(true, $grade_item->update_final_grades());
//TODO: add more tests
}
/**
@ -377,6 +474,24 @@ class grade_item_test extends grade_test {
$this->assertTrue($grade_item->is_hidden(1));
}
function test_grade_item_is_category_item() {
$grade_item = new grade_item($this->grade_items[3]);
$this->assertTrue(method_exists($grade_item, 'is_category_item'));
$this->assertTrue($grade_item->is_category_item());
}
function test_grade_item_is_course_item() {
$grade_item = grade_item::fetch_course_item($this->courseid);
$this->assertTrue(method_exists($grade_item, 'is_course_item'));
$this->assertTrue($grade_item->is_course_item());
}
function test_grade_item_fetch_course_item() {
$grade_item = grade_item::fetch_course_item($this->courseid);
$this->assertTrue(method_exists($grade_item, 'fetch_course_item'));
$this->assertTrue($grade_item->itemtype, 'course');
}
function test_grade_item_depends_on() {
$grade_item = new grade_item($this->grade_items[1]);