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

Fixing a few bugs identified by Petr and attacking grade_item unit tests

Browse Source
This commit is contained in:
nicolasconnault 2007-11-13 19:12:37 +00:00
parent 5e983a9a2f
commit b7cf8eac52
4 changed files with 54 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/grade/grade_category.php
View File

@ -159,7 +159,7 @@ class grade_category extends grade_object {
} else {
$obj = grade_object::get_instance('grade_category');
$parent = $obj->lib_wrapper->get_record('grade_categories', 'id', $grade_category->parent);
var_dump($parent);
return grade_category::build_path($parent).$grade_category->id.'/';
}
}
@ -1125,7 +1125,6 @@ class grade_category extends grade_object {
if ($cascade) {
//process all children - items and categories
$grade_item = grade_object::get_instance('grade_item');
var_dump($grade_item);
if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
foreach($children as $child) {
$child->set_locked($lockedstate, true, false);

10
lib/grade/grade_grade.php
View File

@ -387,14 +387,14 @@ class grade_grade extends grade_object {
$items_sql = implode(',', $items);
$now = time(); // no rounding needed, this is not supposed to be called every 10 seconds
if ($rs = $this->lib_wrapper->get_recordset_select('grade_grades', "itemid IN ($items_sql) AND locked = 0 AND locktime > 0 AND locktime < $now")) {
while ($grade = $this->lib_wrapper->rs_fetch_next_record($rs)) {
$grade_grade = $this->get_instance('grade_grade', $grade, false);
$obj = grade_object::get_instance('grade_grade');
if ($rs = $obj->lib_wrapper->get_recordset_select('grade_grades', "itemid IN ($items_sql) AND locked = 0 AND locktime > 0 AND locktime < $now")) {
while ($grade = $obj->lib_wrapper->rs_fetch_next_record($rs)) {
$grade_grade = $obj->get_instance('grade_grade', $grade, false);
$grade_grade->locked = time();
$grade_grade->update('locktime');
}
$this->lib_wrapper->rs_close($rs);
$obj->lib_wrapper->rs_close($rs);
}
}

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

@ -60,7 +60,6 @@ class grade_category_test extends grade_test {
$parent1->parent = null;
$parent1->id = 1;
$obj->lib_wrapper->setReturnValueAt(1, 'get_record', $parent1);
var_dump($grade_category);
$path = $grade_category->build_path($grade_category);
$this->assertEqual($grade_category->path, $path);
}
@ -75,6 +74,13 @@ class grade_category_test extends grade_test {
$grade_category = &new partial_mock($this);
$grade_category->grade_category($this->grade_categories[1], false);
// There is a static call to grade_category::build_path(): prepare the static instance
$obj = grade_object::get_instance('grade_category');
$parent = new stdClass();
$parent->parent = null;
$parent->id = 1;
$obj->lib_wrapper->setReturnValue('get_record', $parent);
$this->assertTrue(method_exists($grade_category, 'update'));
@ -555,7 +561,6 @@ class grade_category_test extends grade_test {
$cascading = true;
$grade_category = new mock_grade_category_for_set_locked($this);
$obj = grade_object::get_instance('grade_item');
$obj->expectOnce('fetch_all');
$obj->setReturnValue('fetch_all', array(fullclone($grade_item), fullclone($grade_item)));
$grade_category->expectOnce('load_grade_item');
$grade_category->grade_item = $grade_item;
@ -563,33 +568,35 @@ class grade_category_test extends grade_test {
$this->assertTrue($grade_category->set_locked($lockedstate, $cascade, $refresh));
}
/*
function test_grade_category_is_hidden() {
$grade_category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($grade_category, 'is_hidden'));
$grade_category->load_grade_item();
$this->assertEqual($grade_category->is_hidden(), $grade_category->grade_item->is_hidden());
}
function test_grade_category_set_hidden() {
$grade_category = new grade_category($this->grade_categories[0]);
$methods_to_mock = array('load_grade_item', 'instantiate_new_grade_item', 'fetch_all');
$hiddenstate = true;
$cascade = false;
// Test non-cascading set_hidden
Mock::generatePartial('grade_category', 'mock_grade_category_for_set_hidden', $methods_to_mock);
$grade_item = new mock_grade_item();
$grade_item->expectCallCount('set_hidden', 2, array($hiddenstate, $cascade));
$grade_item->setReturnValue('set_hidden', true);
$grade_item->expectNever('fetch_all');
$grade_category = new mock_grade_category_for_set_hidden($this);
$grade_category->expectOnce('load_grade_item');
$grade_category->expectNever('instantiate_new_grade_item');
$this->assertTrue(method_exists($grade_category, 'set_hidden'));
$grade_category->set_hidden(1);
$grade_category->load_grade_item();
$this->assertEqual(true, $grade_category->grade_item->is_hidden());
}
$grade_category->grade_item = $grade_item;
function generate_random_raw_grade($item, $userid) {
$grade = new grade_grade();
$grade->itemid = $item->id;
$grade->userid = $userid;
$grade->grademin = 0;
$grade->grademax = 1;
$valuetype = "grade$item->gradetype";
$grade->rawgrade = rand(0, 1000) / 1000;
$grade->insert();
return $grade->rawgrade;
}
*/
$grade_category->set_hidden($hiddenstate, $cascade);
// Test cascading set_hidden
$cascading = true;
$grade_category = new mock_grade_category_for_set_hidden($this);
$obj = grade_object::get_instance('grade_item');
$obj->setReturnValue('fetch_all', array(fullclone($grade_item), fullclone($grade_item)));
$grade_category->expectOnce('load_grade_item');
$grade_category->grade_item = $grade_item;
$grade_category->set_hidden($hiddenstate, $cascade);
}
}
?>

59
lib/grade/simpletest/testgradeitem.php
View File

@ -59,7 +59,11 @@ class grade_item_test extends grade_test {
}
function test_grade_item_insert() {
$grade_item = new grade_item();
Mock::generatePartial('grade_item', 'mock_grade_item_for_insert', array('load_scale', 'is_course_item', 'is_category_item', 'force_regrading'));
$grade_item = new mock_grade_item_for_insert($this);
$grade_item->lib_wrapper = new mock_lib_wrapper();
$this->assertTrue(method_exists($grade_item, 'insert'));
$grade_item->courseid = $this->courseid;
@ -69,14 +73,18 @@ class grade_item_test extends grade_test {
$grade_item->itemmodule = 'quiz';
$grade_item->iteminfo = 'Grade item used for unit testing';
$grade_item->lib_wrapper->expectCallCount('insert_record', 2); // main insert and history table insert
$grade_item->lib_wrapper->setReturnValue('insert_record', 4);
$grade_item->lib_wrapper->expectOnce('get_record'); // for update_from_db() method
$grade_item->lib_wrapper->setReturnValue('get_record', array(1));
$grade_item->insert();
$last_grade_item = end($this->grade_items);
$this->assertEqual($grade_item->id, 4);
$this->assertEqual($grade_item->id, $last_grade_item->id + 1);
$this->assertEqual(11, $grade_item->sortorder);
$this->assertFalse(empty($grade_item->timecreated));
$this->assertFalse(empty($grade_item->timemodified));
}
/*
function test_grade_item_delete() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'delete'));
@ -143,30 +151,6 @@ class grade_item_test extends grade_test {
$this->assertEqual(1, $grade_item->needsupdate);
}
function test_grade_item_fetch() {
$grade_item = new grade_item();
$this->assertTrue(method_exists($grade_item, 'fetch'));
$grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
$this->assertEqual($this->grade_items[0]->id, $grade_item->id);
$this->assertEqual($this->grade_items[0]->iteminfo, $grade_item->iteminfo);
$grade_item = grade_item::fetch(array('itemtype'=>$this->grade_items[1]->itemtype, 'itemmodule'=>$this->grade_items[1]->itemmodule));
$this->assertEqual($this->grade_items[1]->id, $grade_item->id);
$this->assertEqual($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
}
function test_grade_item_fetch_all() {
$grade_item = new grade_item();
$this->assertTrue(method_exists($grade_item, 'fetch_all'));
$grade_items = grade_item::fetch_all(array('courseid'=>$this->courseid));
$this->assertEqual(count($this->grade_items), count($grade_items)-1);
}
/**
* Retrieve all final scores for a given grade_item.
*/
function test_grade_item_get_all_finals() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_final'));
@ -176,9 +160,6 @@ class grade_item_test extends grade_test {
}
/**
* Retrieve all final scores for a specific userid.
*/
function test_grade_item_get_final() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_final'));
@ -271,9 +252,6 @@ class grade_item_test extends grade_test {
$this->assertEqual($this->grade_categories[0]->fullname, $grade_item->item_category->fullname);
}
/**
* Test update of all final grades
*/
function test_grade_item_regrade_final_grades() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'regrade_final_grades'));
@ -281,9 +259,6 @@ class grade_item_test extends grade_test {
//TODO: add more tests
}
/**
* Test the adjust_raw_grade method
*/
function test_grade_item_adjust_raw_grade() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
@ -344,9 +319,6 @@ class grade_item_test extends grade_test {
$this->assertEqual(round(1.6), round($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax)));
}
/**
* Test locking of grade items
*/
function test_grade_item_set_locked() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_locked'));
@ -379,9 +351,6 @@ class grade_item_test extends grade_test {
$this->assertTrue($grade_item->is_locked(1));
}
/**
* Test hiding of grade items
*/
function test_grade_item_set_hidden() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_hidden'));
@ -511,6 +480,6 @@ class grade_item_test extends grade_test {
$grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[5]->userid, 'itemid'=>$this->grade_grades[5]->itemid));
$this->assertEqual($this->grade_grades[5]->finalgrade, $grade_grade->finalgrade);
}
*/
}
?>