L-electron-Rare/moodle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MDL-12182 Reverting to pre-upgrade in order to prepare a patch instead

Browse Source
This commit is contained in:
nicolasconnault
2007-11-22 05:42:46 +00:00
parent 93da7cf445
commit f3ac8eb40c
13 changed files with 1452 additions and 1470 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/grade/grade_category.php
+40 -54
View File
@@ -157,9 +157,7 @@ class grade_category extends grade_object {
if (empty($grade_category->parent)) {
return '/'.$grade_category->id.'/';
} else {
$obj = grade_object::get_instance('grade_category');
$parent = $obj->lib_wrapper->get_record('grade_categories', 'id', $grade_category->parent);
$parent = get_record('grade_categories', 'id', $grade_category->parent);
return grade_category::build_path($parent).$grade_category->id.'/';
}
}
@@ -172,8 +170,7 @@ class grade_category extends grade_object {
* @return object grade_category instance or false if none found.
*/
function fetch($params) {
$obj = grade_object::get_instance('grade_category');
return $obj->fetch_helper('grade_categories', 'grade_category', $params);
return grade_object::fetch_helper('grade_categories', 'grade_category', $params);
}
/**
@@ -184,8 +181,7 @@ class grade_category extends grade_object {
* @return array array of grade_category insatnces or false if none found.
*/
function fetch_all($params) {
$obj = grade_object::get_instance('grade_category');
return $obj->fetch_all_helper('grade_categories', 'grade_category', $params);
return grade_object::fetch_all_helper('grade_categories', 'grade_category', $params);
}
/**
@@ -229,10 +225,9 @@ class grade_category extends grade_object {
*/
function delete($source=null) {
$grade_item = $this->load_grade_item();
$obj = grade_object::get_instance('grade_category');
if ($this->is_course_category()) {
if ($categories = $obj->fetch_all(array('courseid'=>$this->courseid))) {
if ($categories = grade_category::fetch_all(array('courseid'=>$this->courseid))) {
foreach ($categories as $category) {
if ($category->id == $this->id) {
continue; // do not delete course category yet
@@ -241,7 +236,7 @@ class grade_category extends grade_object {
}
}
if ($items = $grade_item->fetch_all(array('courseid'=>$this->courseid))) {
if ($items = grade_item::fetch_all(array('courseid'=>$this->courseid))) {
foreach ($items as $item) {
if ($item->id == $grade_item->id) {
continue; // do not delete course item yet
@@ -256,12 +251,12 @@ class grade_category extends grade_object {
$parent = $this->load_parent_category();
// Update children's categoryid/parent field first
if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
if ($children = grade_item::fetch_all(array('categoryid'=>$this->id))) {
foreach ($children as $child) {
$child->set_parent($parent->id);
}
}
if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
if ($children = grade_category::fetch_all(array('parent'=>$this->id))) {
foreach ($children as $child) {
$child->set_parent($parent->id);
}
@@ -288,11 +283,10 @@ class grade_category extends grade_object {
if (empty($this->courseid)) {
error('Can not insert grade category without course id!');
return false;
}
if (empty($this->parent)) {
$course_category = $obj->fetch_course_category($this->courseid);
$course_category = grade_category::fetch_course_category($this->courseid);
$this->parent = $course_category->id;
}
@@ -353,8 +347,8 @@ class grade_category extends grade_object {
debugging("Can not regrade non existing category");
return false;
}
$obj = grade_object::get_instance('grade_category');
$db_item = $obj->fetch(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;
@@ -409,7 +403,7 @@ class grade_category extends grade_object {
$sql = "SELECT *
FROM {$CFG->prefix}grade_items
WHERE id IN ($gis)";
$items = $this->lib_wrapper->get_records_sql($sql);
$items = get_records_sql($sql);
}
if ($userid) {
@@ -418,7 +412,7 @@ class grade_category extends grade_object {
$usersql = "";
}
$grade_inst = grade_object::get_instance('grade_grade');
$grade_inst = new grade_grade();
$fields = 'g.'.implode(',g.', $grade_inst->required_fields);
// where to look for final grades - include grade of this item too, we will store the results there
@@ -429,12 +423,12 @@ class grade_category extends grade_object {
ORDER BY g.userid";
// group the results by userid and aggregate the grades for this user
if ($rs = $this->lib_wrapper->get_recordset_sql($sql)) {
if ($rs = get_recordset_sql($sql)) {
$prevuser = 0;
$grade_values = array();
$excluded = array();
$oldgrade = null;
while ($used = $this->lib_wrapper->rs_fetch_next_record($rs)) {
while ($used = rs_fetch_next_record($rs)) {
if ($used->userid != $prevuser) {
$this->aggregate_grades($prevuser, $items, $grade_values, $oldgrade, $excluded);
$prevuser = $used->userid;
@@ -451,7 +445,7 @@ class grade_category extends grade_object {
}
}
$this->aggregate_grades($prevuser, $items, $grade_values, $oldgrade, $excluded);//the last one
$this->lib_wrapper->rs_close($rs);
rs_close($rs);
}
return true;
@@ -481,12 +475,12 @@ class grade_category extends grade_object {
// we need proper floats here for !== comparison later
$oldfinalgrade = (float)$oldgrade->finalgrade;
}
$grade = $this->get_instance('grade_grade', $oldgrade, false);
$grade = new grade_grade($oldgrade, false);
$grade->grade_item =& $this->grade_item;
} else {
// insert final grade - it will be needed later anyway
$grade = $this->get_instance('grade_grade', array('itemid'=>$this->grade_item->id, 'userid'=>$userid), false);
$grade = new grade_grade(array('itemid'=>$this->grade_item->id, 'userid'=>$userid), false);
$grade->grade_item =& $this->grade_item;
$grade->insert('system');
$oldfinalgrade = null;
@@ -758,14 +752,13 @@ class grade_category extends grade_object {
* @return array
*/
function fetch_course_tree($courseid, $include_category_items=false) {
$obj = grade_object::get_instance('grade_category');
$course_category = $obj->fetch_course_category($courseid);
$course_category = grade_category::fetch_course_category($courseid);
$category_array = array('object'=>$course_category, 'type'=>'category', 'depth'=>1,
'children'=>$course_category->get_children($include_category_items));
$sortorder = 1;
$course_category->set_sortorder($sortorder);
$course_category->sortorder = $sortorder;
return $obj->_fetch_course_tree_recursion($category_array, $sortorder);
return grade_category::_fetch_course_tree_recursion($category_array, $sortorder);
}
function _fetch_course_tree_recursion($category_array, &$sortorder) {
@@ -789,12 +782,12 @@ class grade_category extends grade_object {
$cat_item_id = null;
foreach($category_array['children'] as $oldorder=>$child_array) {
if ($child_array['type'] == 'courseitem' or $child_array['type'] == 'categoryitem') {
$result['children'][$sortorder] = $this->_fetch_course_tree_recursion($child_array, $sortorder);
$result['children'][$sortorder] = grade_category::_fetch_course_tree_recursion($child_array, $sortorder);
}
}
foreach($category_array['children'] as $oldorder=>$child_array) {
if ($child_array['type'] != 'courseitem' and $child_array['type'] != 'categoryitem') {
$result['children'][++$sortorder] = $this->_fetch_course_tree_recursion($child_array, $sortorder);
$result['children'][++$sortorder] = grade_category::_fetch_course_tree_recursion($child_array, $sortorder);
}
}
}
@@ -814,8 +807,8 @@ class grade_category extends grade_object {
// fetch all course grade items and categories into memory - we do not expect hundreds of these in course
// we have to limit the number of queries though, because it will be used often in grade reports
$cats = $this->lib_wrapper->get_records('grade_categories', 'courseid', $this->courseid);
$items = $this->lib_wrapper->get_records('grade_items', 'courseid', $this->courseid);
$cats = get_records('grade_categories', 'courseid', $this->courseid);
$items = get_records('grade_items', 'courseid', $this->courseid);
// init children array first
foreach ($cats as $catid=>$cat) {
@@ -859,6 +852,7 @@ class grade_category extends grade_object {
$cats[$cat->parent]->children[$sortorder] = $cat;
}
if ($catid == $this->id) {
$category = &$cats[$catid];
}
@@ -867,7 +861,7 @@ class grade_category extends grade_object {
unset($items); // not needed
unset($cats); // not needed
$children_array = $this->_get_children_recursion($category);
$children_array = grade_category::_get_children_recursion($category);
ksort($children_array);
@@ -880,7 +874,7 @@ class grade_category extends grade_object {
$children_array = array();
foreach($category->children as $sortorder=>$child) {
if (array_key_exists('itemtype', $child)) {
$grade_item = $this->get_instance('grade_item', $child, false);
$grade_item = new grade_item($child, false);
if (in_array($grade_item->itemtype, array('course', 'category'))) {
$type = $grade_item->itemtype.'item';
$depth = $category->depth;
@@ -891,8 +885,8 @@ class grade_category extends grade_object {
$children_array[$sortorder] = array('object'=>$grade_item, 'type'=>$type, 'depth'=>$depth);
} else {
$children = $this->_get_children_recursion($child);
$grade_category = $this->get_instance('grade_category', $child, false);
$children = grade_category::_get_children_recursion($child);
$grade_category = new grade_category($child, false);
if (empty($children)) {
$children = array();
}
@@ -935,11 +929,9 @@ class grade_category extends grade_object {
$params = array('courseid'=>$this->courseid, 'itemtype'=>'category', 'iteminstance'=>$this->id);
}
$grade_item = grade_object::get_instance('grade_item');
if (!$grade_items = $grade_item->fetch_all($params)) {
if (!$grade_items = grade_item::fetch_all($params)) {
// create a new one
$grade_item = $this->get_instance('grade_item', $params, false);
$grade_item = new grade_item($params, false);
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->insert('system');
@@ -974,7 +966,7 @@ class grade_category extends grade_object {
*/
function get_parent_category() {
if (!empty($this->parent)) {
$parent_category = $this->get_instance('grade_category', array('id' => $this->parent));
$parent_category = new grade_category(array('id' => $this->parent));
return $parent_category;
} else {
return null;
@@ -988,7 +980,7 @@ class grade_category extends grade_object {
*/
function get_name() {
if (empty($this->parent)) {
$course = $this->lib_wrapper->get_record('course', 'id', $this->courseid);
$course = get_record('course', 'id', $this->courseid);
return format_string($course->fullname);
} else {
return $this->fullname;
@@ -1014,8 +1006,7 @@ class grade_category extends grade_object {
}
// find parent and check course id
$obj = grade_object::get_instance('grade_category');
if (!$parent_category = $obj->fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
if (!$parent_category = grade_category::fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
return false;
}
@@ -1098,13 +1089,12 @@ class grade_category extends grade_object {
function fetch_course_category($courseid) {
// course category has no parent
$obj = grade_object::get_instance('grade_category');
if ($course_category = $obj->fetch(array('courseid'=>$courseid, 'parent'=>null))) {
if ($course_category = grade_category::fetch(array('courseid'=>$courseid, 'parent'=>null))) {
return $course_category;
}
// create a new one
$course_category = grade_object::get_instance('grade_category');
$course_category = new grade_category();
$course_category->insert_course_category($courseid);
return $course_category;
@@ -1143,8 +1133,7 @@ class grade_category extends grade_object {
if ($cascade) {
//process all children - items and categories
$grade_item = grade_object::get_instance('grade_item');
if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
if ($children = grade_item::fetch_all(array('categoryid'=>$this->id))) {
foreach($children as $child) {
$child->set_locked($lockedstate, true, false);
if (empty($lockedstate) and $refresh) {
@@ -1153,8 +1142,7 @@ class grade_category extends grade_object {
}
}
}
$obj = grade_object::get_instance('grade_category');
if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
if ($children = grade_category::fetch_all(array('parent'=>$this->id))) {
foreach($children as $child) {
$child->set_locked($lockedstate, true, true);
}
@@ -1194,14 +1182,12 @@ class grade_category extends grade_object {
$this->load_grade_item();
$this->grade_item->set_hidden($hidden);
if ($cascade) {
$grade_item = grade_object::get_instance('grade_item');
if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
if ($children = grade_item::fetch_all(array('categoryid'=>$this->id))) {
foreach($children as $child) {
$child->set_hidden($hidden, $cascade);
}
}
$obj = grade_object::get_instance('grade_category');
if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
if ($children = grade_category::fetch_all(array('parent'=>$this->id))) {
foreach($children as $child) {
$child->set_hidden($hidden, $cascade);
}
@@ -1254,7 +1240,7 @@ class grade_category extends grade_object {
function updated_forced_settings() {
global $CFG;
$sql = "UPDATE {$CFG->prefix}grade_items SET needsupdate=1 WHERE itemtype='course' or itemtype='category'";
$this->lib_wrapper->execute_sql($sql, false);
execute_sql($sql, false);
}
}
?>
lib/grade/grade_grade.php
+15 -19
View File
@@ -158,8 +158,7 @@ class grade_grade extends grade_object {
* @return array userid=>grade_grade array
*/
function fetch_users_grades($grade_item, $userids, $include_missing=true) {
$obj = grade_object::get_instance('grade_grade');
// hmm, there might be a problem with length of sql query
// if there are too many users requested - we might run out of memory anyway
$limit = 2000;
@@ -168,20 +167,20 @@ class grade_grade extends grade_object {
$half = (int)($count/2);
$first = array_slice($userids, 0, $half);
$second = array_slice($userids, $half);
return $obj->fetch_users_grades($grade_item, $first, $include_missing) + $obj->fetch_users_grades($grade_item, $second, $include_missing);
return grade_grade::fetch_users_grades($grade_item, $first, $include_missing) + grade_grade::fetch_users_grades($grade_item, $second, $include_missing);
}
$user_ids_cvs = implode(',', $userids);
$result = array();
if ($grade_records = $obj->lib_wrapper->get_records_select('grade_grades', "itemid={$grade_item->id} AND userid IN ($user_ids_cvs)")) {
if ($grade_records = get_records_select('grade_grades', "itemid={$grade_item->id} AND userid IN ($user_ids_cvs)")) {
foreach ($grade_records as $record) {
$result[$record->userid] = $obj->get_instance('grade_grade', $record, false);
$result[$record->userid] = new grade_grade($record, false);
}
}
if ($include_missing) {
foreach ($userids as $userid) {
if (!array_key_exists($userid, $result)) {
$grade_grade = grade_object::get_instance('grade_grade');
$grade_grade = new grade_grade();
$grade_grade->userid = $userid;
$grade_grade->itemid = $grade_item->id;
$result[$userid] = $grade_grade;
@@ -204,12 +203,11 @@ class grade_grade extends grade_object {
}
if (empty($this->grade_item)) {
$grade_item = grade_object::get_instance('grade_item');
$this->grade_item = $grade_item->fetch(array('id'=>$this->itemid));
$this->grade_item = grade_item::fetch(array('id'=>$this->itemid));
} else if ($this->grade_item->id != $this->itemid) {
debugging('Itemid mismatch');
$this->grade_item = $grade_item->fetch(array('id'=>$this->itemid));
$this->grade_item = grade_item::fetch(array('id'=>$this->itemid));
}
return $this->grade_item;
@@ -388,14 +386,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
$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);
if ($rs = get_recordset_select('grade_grades', "itemid IN ($items_sql) AND locked = 0 AND locktime > 0 AND locktime < $now")) {
while ($grade = rs_fetch_next_record($rs)) {
$grade_grade = new grade_grade($grade, false);
$grade_grade->locked = time();
$grade_grade->update('locktime');
}
$obj->lib_wrapper->rs_close($rs);
rs_close($rs);
}
}
@@ -505,8 +503,7 @@ class grade_grade extends grade_object {
* @return object grade_grade instance or false if none found.
*/
function fetch($params) {
$obj = grade_object::get_instance('grade_grade');
return $obj->fetch_helper('grade_grades', 'grade_grade', $params);
return grade_object::fetch_helper('grade_grades', 'grade_grade', $params);
}
/**
@@ -517,8 +514,7 @@ class grade_grade extends grade_object {
* @return array array of grade_grade insatnces or false if none found.
*/
function fetch_all($params) {
$obj = grade_object::get_instance('grade_grade');
return $obj->fetch_all_helper('grade_grades', 'grade_grade', $params);
return grade_object::fetch_all_helper('grade_grades', 'grade_grade', $params);
}
/**
@@ -559,7 +555,7 @@ class grade_grade extends grade_object {
global $CFG;
if (count($grade_grades) !== count($grade_items)) {
error('Incorrent size of arrays in params of grade_grade::get_hiding_affected()!');
error('Incorrect size of arrays in params of grade_grade::get_hiding_affected()!');
}
$dependson = array();
lib/grade/grade_item.php
+64 -82
View File
@@ -281,18 +281,18 @@ class grade_item extends grade_object {
return false;
}
$db_item = $this->get_instance('grade_item', array('id' => $this->id));
$db_item = new grade_item(array('id' => $this->id));
$calculationdiff = $db_item->calculation != $this->calculation;
$categorydiff = $db_item->categoryid != $this->categoryid;
$gradetypediff = $db_item->gradetype != $this->gradetype;
$grademaxdiff = $db_item->grademax != $this->grademax;
$grademindiff = $db_item->grademin != $this->grademin;
$scaleiddiff = $db_item->scaleid != $this->scaleid;
$outcomeiddiff = $db_item->outcomeid != $this->outcomeid;
$multfactordiff = $db_item->multfactor != $this->multfactor;
$plusfactordiff = $db_item->plusfactor != $this->plusfactor;
$locktimediff = $db_item->locktime != $this->locktime;
$calculationdiff = $db_item->calculation != $this->calculation;
$categorydiff = $db_item->categoryid != $this->categoryid;
$gradetypediff = $db_item->gradetype != $this->gradetype;
$grademaxdiff = $db_item->grademax != $this->grademax;
$grademindiff = $db_item->grademin != $this->grademin;
$scaleiddiff = $db_item->scaleid != $this->scaleid;
$outcomeiddiff = $db_item->outcomeid != $this->outcomeid;
$multfactordiff = $db_item->multfactor != $this->multfactor;
$plusfactordiff = $db_item->plusfactor != $this->plusfactor;
$locktimediff = $db_item->locktime != $this->locktime;
$acoefdiff = $db_item->aggregationcoef != $this->aggregationcoef;
$needsupdatediff = !$db_item->needsupdate && $this->needsupdate; // force regrading only if setting the flag first time
@@ -311,8 +311,7 @@ class grade_item extends grade_object {
* @return object grade_item instance or false if none found.
*/
function fetch($params) {
$obj = grade_object::get_instance('grade_item');
return $obj->fetch_helper('grade_items', 'grade_item', $params);
return grade_object::fetch_helper('grade_items', 'grade_item', $params);
}
/**
@@ -323,8 +322,7 @@ class grade_item extends grade_object {
* @return array array of grade_item insatnces or false if none found.
*/
function fetch_all($params) {
$obj = grade_object::get_instance('grade_item');
return $obj->fetch_all_helper('grade_items', 'grade_item', $params);
return grade_object::fetch_all_helper('grade_items', 'grade_item', $params);
}
/**
@@ -337,8 +335,7 @@ class grade_item extends grade_object {
$this->force_regrading();
}
$grade_grade = grade_object::get_instance('grade_grade');
if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
if ($grades = grade_grade::fetch_all(array('itemid'=>$this->id))) {
foreach ($grades as $grade) {
$grade->delete($source);
}
@@ -363,15 +360,14 @@ class grade_item extends grade_object {
$this->load_scale();
// add parent category if needed
$grade_category = grade_object::get_instance('grade_category');
if (empty($this->categoryid) and !$this->is_course_item() and !$this->is_category_item()) {
$course_category = $grade_category->fetch_course_category($this->courseid);
$course_category = grade_category::fetch_course_category($this->courseid);
$this->categoryid = $course_category->id;
}
// always place the new items at the end, move them after insert if needed
$last_sortorder = $this->lib_wrapper->get_field_select('grade_items', 'MAX(sortorder)', "courseid = {$this->courseid}");
$last_sortorder = get_field_select('grade_items', 'MAX(sortorder)', "courseid = {$this->courseid}");
if (!empty($last_sortorder)) {
$this->sortorder = $last_sortorder + 1;
} else {
@@ -414,13 +410,13 @@ class grade_item extends grade_object {
}
if ($this->itemtype == 'mod' and !$this->is_outcome_item()) {
if (!$cm = $this->lib_wrapper->get_coursemodule_from_instance($this->itemmodule, $this->iteminstance, $this->courseid)) {
if (!$cm = get_coursemodule_from_instance($this->itemmodule, $this->iteminstance, $this->courseid)) {
return false;
}
if (!empty($cm->idnumber)) {
return false;
}
if ($this->lib_wrapper->set_field('course_modules', 'idnumber', addslashes($idnumber), 'id', $cm->id)) {
if (set_field('course_modules', 'idnumber', addslashes($idnumber), 'id', $cm->id)) {
$this->idnumber = $idnumber;
return $this->update();
}
@@ -446,8 +442,7 @@ class grade_item extends grade_object {
}
if (!empty($userid)) {
$grade_grade = grade_object::get_instance('grade_grade');
if ($grade = $grade_grade->fetch(array('itemid'=>$this->id, 'userid'=>$userid))) {
if ($grade = grade_grade::fetch(array('itemid'=>$this->id, 'userid'=>$userid))) {
$grade->grade_item =& $this; // prevent db fetching of cached grade_item
return $grade->is_locked();
}
@@ -476,7 +471,7 @@ class grade_item extends grade_object {
if ($cascade) {
$grades = $this->get_final();
foreach($grades as $g) {
$grade = $this->get_instance('grade_grade', $g, false);
$grade = new grade_grade($g, false);
$grade->grade_item =& $this;
$grade->set_locked(1, null, false);
}
@@ -495,8 +490,7 @@ class grade_item extends grade_object {
$this->update();
if ($cascade) {
$grade_grade = grade_object::get_instance('grade_grade');
if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
if ($grades = grade_grade::fetch_all(array('itemid'=>$this->id))) {
foreach($grades as $grade) {
$grade->grade_item =& $this;
$grade->set_locked(0, null, false);
@@ -582,8 +576,7 @@ class grade_item extends grade_object {
$this->update();
if ($cascade) {
$grade_grade = grade_object::get_instance('grade_grade');
if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
if ($grades = grade_grade::fetch_all(array('itemid'=>$this->id))) {
foreach($grades as $grade) {
$grade->grade_item =& $this;
$grade->set_hidden($hidden, $cascade);
@@ -598,7 +591,7 @@ class grade_item extends grade_object {
*/
function has_hidden_grades($groupsql="", $groupwheresql="") {
global $CFG;
return $this->lib_wrapper->get_field_sql("SELECT COUNT(*) FROM {$CFG->prefix}grade_grades g LEFT JOIN "
return get_field_sql("SELECT COUNT(*) FROM {$CFG->prefix}grade_grades g LEFT JOIN "
."{$CFG->prefix}user u ON g.userid = u.id $groupsql WHERE itemid = $this->id AND hidden = 1 $groupwheresql");
}
@@ -608,7 +601,7 @@ class grade_item extends grade_object {
function regrading_finished() {
$this->needsupdate = 0;
//do not use $this->update() because we do not want this logged in grade_item_history
$this->lib_wrapper->set_field('grade_items', 'needsupdate', 0, 'id', $this->id);
set_field('grade_items', 'needsupdate', 0, 'id', $this->id);
}
/**
@@ -662,16 +655,16 @@ class grade_item extends grade_object {
// normal grade item - just new final grades
$result = true;
$grade_inst = grade_object::get_instance('grade_grade');
$grade_inst = new grade_grade();
$fields = implode(',', $grade_inst->required_fields);
if ($userid) {
$rs = $this->lib_wrapper->get_recordset_select('grade_grades', "itemid={$this->id} AND userid=$userid", '', $fields);
$rs = get_recordset_select('grade_grades', "itemid={$this->id} AND userid=$userid", '', $fields);
} else {
$rs = $this->lib_wrapper->get_recordset('grade_grades', 'itemid', $this->id, '', $fields);
$rs = get_recordset('grade_grades', 'itemid', $this->id, '', $fields);
}
if ($rs) {
while ($grade_record = $this->lib_wrapper->rs_fetch_next_record($rs)) {
$grade = $this->get_instance('grade_grade', $grade_record, false);
while ($grade_record = rs_fetch_next_record($rs)) {
$grade = new grade_grade($grade_record, false);
if (!empty($grade_record->locked) or !empty($grade_record->overridden)) {
// this grade is locked - final grade must be ok
@@ -686,7 +679,7 @@ class grade_item extends grade_object {
}
}
}
$this->lib_wrapper->rs_close($rs);
rs_close($rs);
}
return $result;
@@ -752,8 +745,8 @@ class grade_item extends grade_object {
return null;
} else {
dubugging("Unkown grade type");
return null;;
debugging("Unkown grade type");
return null;
}
}
@@ -765,7 +758,7 @@ class grade_item extends grade_object {
$this->needsupdate = 1;
//mark this item and course item only - categories and calculated items are always regraded
$wheresql = "(itemtype='course' OR id={$this->id}) AND courseid={$this->courseid}";
$this->lib_wrapper->set_field_select('grade_items', 'needsupdate', 1, $wheresql);
set_field_select('grade_items', 'needsupdate', 1, $wheresql);
}
/**
@@ -781,8 +774,7 @@ class grade_item extends grade_object {
if (!empty($this->scaleid)) {
//do not load scale if already present
if (empty($this->scale->id) or $this->scale->id != $this->scaleid) {
$grade_scale = grade_object::get_instance('grade_scale');
$this->scale = $grade_scale->fetch(array('id'=>$this->scaleid));
$this->scale = grade_scale::fetch(array('id'=>$this->scaleid));
$this->scale->load_items();
}
@@ -805,8 +797,7 @@ class grade_item extends grade_object {
*/
function load_outcome() {
if (!empty($this->outcomeid)) {
$grade_outcome = grade_object::get_instance('grade_outcome');
$this->outcome = $grade_outcome->fetch(array('id'=>$this->outcomeid));
$this->outcome = grade_outcome::fetch(array('id'=>$this->outcomeid));
}
return $this->outcome;
}
@@ -822,8 +813,7 @@ class grade_item extends grade_object {
return $this->get_item_category();
} else {
$grade_category = grade_object::get_instance('grade_category');
return $grade_category->fetch(array('id'=>$this->categoryid));
return grade_category::fetch(array('id'=>$this->categoryid));
}
}
@@ -848,8 +838,7 @@ class grade_item extends grade_object {
if (!$this->is_course_item() and !$this->is_category_item()) {
return false;
}
$grade_category = grade_object::get_instance('grade_category');
return $grade_category->fetch(array('id'=>$this->iteminstance));
return grade_category::fetch(array('id'=>$this->iteminstance));
}
/**
@@ -926,16 +915,14 @@ class grade_item extends grade_object {
* @return course item object
*/
function fetch_course_item($courseid) {
$obj = grade_object::get_instance('grade_item');;
if ($course_item = $obj->fetch(array('courseid'=>$courseid, 'itemtype'=>'course'))) {
if ($course_item = grade_item::fetch(array('courseid'=>$courseid, 'itemtype'=>'course'))) {
return $course_item;
}
// first get category - it creates the associated grade item
$grade_category = grade_object::get_instance('grade_category');
$course_category = $grade_category->fetch_course_category($courseid);
$course_category = grade_category::fetch_course_category($courseid);
return $obj->fetch(array('courseid'=>$courseid, 'itemtype'=>'course'));
return grade_item::fetch(array('courseid'=>$courseid, 'itemtype'=>'course'));
}
/**
@@ -975,7 +962,7 @@ class grade_item extends grade_object {
*/
function get_calculation() {
if ($this->is_calculated()) {
return $this->denormalize_formula($this->calculation, $this->courseid);
return grade_item::denormalize_formula($this->calculation, $this->courseid);
} else {
return NULL;
@@ -990,7 +977,7 @@ class grade_item extends grade_object {
* @return boolean success
*/
function set_calculation($formula) {
$this->calculation = $this->normalize_formula($formula, $this->courseid);
$this->calculation = grade_item::normalize_formula($formula, $this->courseid);
$this->calculation_normalized = true;
return $this->update();
}
@@ -1009,8 +996,7 @@ class grade_item extends grade_object {
// denormalize formula - convert ##giXX## to [[idnumber]]
if (preg_match_all('/##gi(\d+)##/', $formula, $matches)) {
foreach ($matches[1] as $id) {
$obj = grade_object::get_instance('grade_item');;
if ($grade_item = $obj->fetch(array('id'=>$id, 'courseid'=>$courseid))) {
if ($grade_item = grade_item::fetch(array('id'=>$id, 'courseid'=>$courseid))) {
if (!empty($grade_item->idnumber)) {
$formula = str_replace('##gi'.$grade_item->id.'##', '[['.$grade_item->idnumber.']]', $formula);
}
@@ -1037,8 +1023,7 @@ class grade_item extends grade_object {
}
// normalize formula - we want grade item ids ##giXXX## instead of [[idnumber]]
$obj = grade_object::get_instance('grade_item');;
if ($grade_items = $obj->fetch_all(array('courseid'=>$courseid))) {
if ($grade_items = grade_item::fetch_all(array('courseid'=>$courseid))) {
foreach ($grade_items as $grade_item) {
$formula = str_replace('[['.$grade_item->idnumber.']]', '##gi'.$grade_item->id.'##', $formula);
}
@@ -1054,12 +1039,12 @@ class grade_item extends grade_object {
*/
function get_final($userid=NULL) {
if ($userid) {
if ($user = $this->lib_wrapper->get_record('grade_grades', 'itemid', $this->id, 'userid', $userid)) {
if ($user = get_record('grade_grades', 'itemid', $this->id, 'userid', $userid)) {
return $user;
}
} else {
if ($grades = $this->lib_wrapper->get_records('grade_grades', 'itemid', $this->id)) {
if ($grades = get_records('grade_grades', 'itemid', $this->id)) {
//TODO: speed up with better SQL
$result = array();
foreach ($grades as $grade) {
@@ -1083,7 +1068,7 @@ class grade_item extends grade_object {
return false;
}
$grade = $this->get_instance('grade_grade', array('userid'=>$userid, 'itemid'=>$this->id));
$grade = new grade_grade(array('userid'=>$userid, 'itemid'=>$this->id));
if (empty($grade->id) and $create) {
$grade->insert();
}
@@ -1136,7 +1121,7 @@ class grade_item extends grade_object {
$sql = "UPDATE {$CFG->prefix}grade_items
SET sortorder = sortorder + 1
WHERE sortorder > $sortorder AND courseid = {$this->courseid}";
$this->lib_wrapper->execute_sql($sql, false);
execute_sql($sql, false);
$this->set_sortorder($sortorder + 1);
}
@@ -1177,8 +1162,7 @@ class grade_item extends grade_object {
}
// find parent and check course id
$grade_category = grade_object::get_instance('grade_category');
if (!$parent_category = $grade_category->fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
if (!$parent_category = grade_category::fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
return false;
}
@@ -1263,7 +1247,7 @@ class grade_item extends grade_object {
$outcomes_sql";
}
if ($children = $this->lib_wrapper->get_records_sql($sql)) {
if ($children = get_records_sql($sql)) {
$this->dependson_cache = array_keys($children);
return $this->dependson_cache;
} else {
@@ -1288,12 +1272,12 @@ class grade_item extends grade_object {
return;
}
if (!$activity = $this->lib_wrapper->get_record($this->itemmodule, 'id', $this->iteminstance)) {
if (!$activity = get_record($this->itemmodule, 'id', $this->iteminstance)) {
debugging("Can not find $this->itemmodule activity with id $this->iteminstance");
return;
}
if (!$cm = $this->lib_wrapper->get_coursemodule_from_instance($this->itemmodule, $activity->id, $this->courseid)) {
if (!$cm = get_coursemodule_from_instance($this->itemmodule, $activity->id, $this->courseid)) {
debugging('Can not find course module');
return;
}
@@ -1329,7 +1313,7 @@ class grade_item extends grade_object {
return false;
}
$grade = $this->get_instance('grade_grade', array('itemid'=>$this->id, 'userid'=>$userid));
$grade = new grade_grade(array('itemid'=>$this->id, 'userid'=>$userid));
$grade->grade_item =& $this; // prevent db fetching of this grade_item
if (empty($usermodified)) {
@@ -1412,8 +1396,7 @@ class grade_item extends grade_object {
}
} else if (!$this->needsupdate) {
$obj = grade_object::get_instance('grade_item');;
$course_item = $obj->fetch_course_item($this->courseid);
$course_item = grade_item::fetch_course_item($this->courseid);
if (!$course_item->needsupdate) {
if (!grade_regrade_final_grades($this->courseid, $userid, $this)) {
$this->force_regrading();
@@ -1453,7 +1436,7 @@ class grade_item extends grade_object {
return false;
}
$grade = $this->get_instance('grade_grade', array('itemid'=>$this->id, 'userid'=>$userid));
$grade = new grade_grade(array('itemid'=>$this->id, 'userid'=>$userid));
$grade->grade_item =& $this; // prevent db fetching of this grade_item
if (empty($usermodified)) {
@@ -1536,8 +1519,7 @@ class grade_item extends grade_object {
$this->force_regrading();
} else if (!$this->needsupdate) {
$obj = grade_object::get_instance('grade_item');;
$course_item = $obj->fetch_course_item($this->courseid);
$course_item = grade_item::fetch_course_item($this->courseid);
if (!$course_item->needsupdate) {
if (!grade_regrade_final_grades($this->courseid, $userid, $this)) {
$this->force_regrading();
@@ -1585,7 +1567,7 @@ class grade_item extends grade_object {
$usersql = "";
}
$grade_inst = grade_object::get_instance('grade_grade');
$grade_inst = new grade_grade();
$fields = 'g.'.implode(',g.', $grade_inst->required_fields);
$sql = "SELECT $fields
@@ -1596,11 +1578,11 @@ class grade_item extends grade_object {
$return = true;
// group the grades by userid and use formula on the group
if ($rs = $this->lib_wrapper->get_recordset_sql($sql)) {
if ($rs = get_recordset_sql($sql)) {
$prevuser = 0;
$grade_records = array();
$oldgrade = null;
while ($used = $this->lib_wrapper->rs_fetch_next_record($rs)) {
while ($used = rs_fetch_next_record($rs)) {
if ($used->userid != $prevuser) {
if (!$this->use_formula($prevuser, $grade_records, $useditems, $oldgrade)) {
$return = false;
@@ -1618,7 +1600,7 @@ class grade_item extends grade_object {
$return = false;
}
}
$this->lib_wrapper->rs_close($rs);
rs_close($rs);
return $return;
}
@@ -1652,11 +1634,11 @@ class grade_item extends grade_object {
// we need proper floats here for !== comparison later
$oldfinalgrade = (float)$oldgrade->finalgrade;
}
$grade = $this->get_instance('grade_grade', $oldgrade, false); // fetching from db is not needed
$grade = new grade_grade($oldgrade, false); // fetching from db is not needed
$grade->grade_item =& $this;
} else {
$grade = $this->get_instance('grade_grade', array('itemid'=>$this->id, 'userid'=>$userid), false);
$grade = new grade_grade(array('itemid'=>$this->id, 'userid'=>$userid), false);
$grade->grade_item =& $this;
$grade->insert('system');
$oldfinalgrade = null;
@@ -1709,7 +1691,7 @@ class grade_item extends grade_object {
global $CFG;
require_once($CFG->libdir.'/mathslib.php');
$formulastr = $this->normalize_formula($formulastr, $this->courseid);
$formulastr = grade_item::normalize_formula($formulastr, $this->courseid);
if (empty($formulastr)) {
return true;
@@ -1749,7 +1731,7 @@ class grade_item extends grade_object {
FROM {$CFG->prefix}grade_items gi
WHERE gi.id IN ($gis) and gi.courseid={$this->courseid}"; // from the same course only!
if (!$grade_items = $this->lib_wrapper->get_records_sql($sql)) {
if (!$grade_items = get_records_sql($sql)) {
$grade_items = array();
}
}
lib/grade/grade_object.php
+17 -69
View File
@@ -59,12 +59,6 @@ class grade_object {
*/
var $timemodified;
/**
* A wrapper object around moodle procedural functions (especially dmllib).
* @var object $lib_wrapper
*/
var $lib_wrapper;
/**
* Constructor. Optionally (and by default) attempts to fetch corresponding row from DB.
* @param array $params an array with required parameters for this grade object.
@@ -72,23 +66,21 @@ class grade_object {
* optional fields might not be defined if false used
*/
function grade_object($params=NULL, $fetch=true) {
$this->lib_wrapper = new grade_lib_wrapper();
if (!empty($params) and (is_array($params) or is_object($params))) {
if ($fetch) {
if ($data = $this->fetch($params)) {
$this->set_properties($this, $data);
grade_object::set_properties($this, $data);
} else {
$this->set_properties($this, $this->optional_fields);//apply defaults for optional fields
$this->set_properties($this, $params);
grade_object::set_properties($this, $this->optional_fields);//apply defaults for optional fields
grade_object::set_properties($this, $params);
}
} else {
$this->set_properties($this, $params);
grade_object::set_properties($this, $params);
}
} else {
$this->set_properties($this, $this->optional_fields);//apply defaults for optional fields
grade_object::set_properties($this, $this->optional_fields);//apply defaults for optional fields
}
}
@@ -105,7 +97,7 @@ class grade_object {
if (empty($this->id)) {
$this->$field = $default;
} else {
$this->$field = $this->lib_wrapper->get_field($this->table, $field, 'id', $this->id);
$this->$field = get_field($this->table, $field, 'id', $this->id);
}
}
}
@@ -138,8 +130,7 @@ class grade_object {
* @return mixed object instance or false if not found
*/
function fetch_helper($table, $classname, $params) {
$obj = new grade_object();
if ($instances = $obj->fetch_all_helper($table, $classname, $params)) {
if ($instances = grade_object::fetch_all_helper($table, $classname, $params)) {
if (count($instances) > 1) {
// we should not tolerate any errors here - problems might appear later
error('Found more than one record in fetch() !');
@@ -156,7 +147,6 @@ class grade_object {
* @return mixed array of object instances or false if not found
*/
function fetch_all_helper($table, $classname, $params) {
$obj = new grade_object();
$instance = new $classname();
$classvars = (array)$instance;
@@ -183,11 +173,11 @@ class grade_object {
$wheresql = implode("AND", $wheresql);
}
if ($datas = $obj->lib_wrapper->get_records_select($table, $wheresql, 'id')) {
if ($datas = get_records_select($table, $wheresql, 'id')) {
$result = array();
foreach($datas as $data) {
$instance = new $classname();
$obj->set_properties($instance, $data);
grade_object::set_properties($instance, $data);
$result[$instance->id] = $instance;
}
return $result;
@@ -212,7 +202,7 @@ class grade_object {
$data = $this->get_record_data();
if (!$this->lib_wrapper->update_record($this->table, addslashes_recursive($data))) {
if (!update_record($this->table, addslashes_recursive($data))) {
return false;
}
@@ -223,7 +213,7 @@ class grade_object {
$data->source = $source;
$data->timemodified = time();
$data->userlogged = $USER->id;
$this->lib_wrapper->insert_record($this->table.'_history', addslashes_recursive($data));
insert_record($this->table.'_history', addslashes_recursive($data));
}
return true;
@@ -244,7 +234,7 @@ class grade_object {
$data = $this->get_record_data();
if ($this->lib_wrapper->delete_records($this->table, 'id', $this->id)) {
if (delete_records($this->table, 'id', $this->id)) {
if (empty($CFG->disablegradehistory)) {
unset($data->id);
unset($data->timecreated);
@@ -253,7 +243,7 @@ class grade_object {
$data->source = $source;
$data->timemodified = time();
$data->userlogged = $USER->id;
$this->lib_wrapper->insert_record($this->table.'_history', addslashes_recursive($data));
insert_record($this->table.'_history', addslashes_recursive($data));
}
return true;
@@ -297,7 +287,7 @@ class grade_object {
$data = $this->get_record_data();
if (!$this->id = $this->lib_wrapper->insert_record($this->table, addslashes_recursive($data))) {
if (!$this->id = insert_record($this->table, addslashes_recursive($data))) {
debugging("Could not insert object into db");
return false;
}
@@ -314,7 +304,7 @@ class grade_object {
$data->source = $source;
$data->timemodified = time();
$data->userlogged = $USER->id;
$this->lib_wrapper->insert_record($this->table.'_history', addslashes_recursive($data));
insert_record($this->table.'_history', addslashes_recursive($data));
}
return $this->id;
@@ -332,12 +322,12 @@ class grade_object {
return false;
}
if (!$params = $this->lib_wrapper->get_record($this->table, 'id', $this->id)) {
if (!$params = get_record($this->table, 'id', $this->id)) {
debugging("Object with this id:{$this->id} does not exist in table:{$this->table}, can not update from db!");
return false;
}
$this->set_properties($this, $params);
grade_object::set_properties($this, $params);
return true;
}
@@ -355,47 +345,5 @@ class grade_object {
}
}
}
/**
* The following function is a helper for making the code more testable. It allows
* unit tests to mock the objects instantiated and used within method bodies. If no params are given,
* a static instance is returned.
* @param string $class
* @param array $params
* @param bool $fetch
* @param bool $set Whether or not to set the instance instead of getting it
*/
function get_instance($class, $params=NULL, $fetch=true, $set=false, $object=null) {
static $grade_instances = array();
$classes = array('grade_item', 'grade_category', 'grade_grade', 'grade_outcome', 'grade_scale');
if ($set) {
if (!is_object($object)) {
debugging('grade_object::set_instance was given a non-object as parameter!');
return false;
}
if (in_array($class, $classes)) {
$grade_instances[$class] =& $object;
return true;
} else {
debugging("grade_object::set_instance was given an object that is not supported ($class)!");
return false;
}
} else {
if (!in_array($class, $classes)) {
return false;
} elseif (is_null($params)) {
if (!array_key_exists($class, $grade_instances)) {
$grade_instances[$class] =& new $class;
}
$instance =& $grade_instances[$class];
return $instance;
} else {
return new $class($params, $fetch);
}
}
}
}
?>
lib/grade/grade_outcome.php
+16 -23
View File
@@ -92,7 +92,7 @@ class grade_outcome extends grade_object {
*/
function delete($source=null) {
if (!empty($this->courseid)) {
$this->lib_wrapper->delete_records('grade_outcomes_courses', 'outcomeid', $this->id, 'courseid', $this->courseid);
delete_records('grade_outcomes_courses', 'outcomeid', $this->id, 'courseid', $this->courseid);
}
return parent::delete($source);
}
@@ -113,7 +113,7 @@ class grade_outcome extends grade_object {
$goc = new object();
$goc->courseid = $this->courseid;
$goc->outcomeid = $this->id;
$this->lib_wrapper->insert_record('grade_outcomes_courses', $goc);
insert_record('grade_outcomes_courses', $goc);
}
}
return $result;
@@ -129,11 +129,11 @@ class grade_outcome extends grade_object {
if ($result = parent::update($source)) {
if (!empty($this->courseid)) {
if (!$this->lib_wrapper->get_records('grade_outcomes_courses', 'courseid', $this->courseid, 'outcomeid', $this->id)) {
if (!get_records('grade_outcomes_courses', 'courseid', $this->courseid, 'outcomeid', $this->id)) {
$goc = new object();
$goc->courseid = $this->courseid;
$goc->outcomeid = $this->id;
$this->lib_wrapper->insert_record('grade_outcomes_courses', $goc);
insert_record('grade_outcomes_courses', $goc);
}
}
}
@@ -148,8 +148,7 @@ class grade_outcome extends grade_object {
* @return object grade_outcome instance or false if none found.
*/
function fetch($params) {
$obj = grade_object::get_instance('grade_outcome');
return $obj->fetch_helper('grade_outcomes', 'grade_outcome', $params);
return grade_object::fetch_helper('grade_outcomes', 'grade_outcome', $params);
}
/**
@@ -160,8 +159,7 @@ class grade_outcome extends grade_object {
* @return array array of grade_outcome insatnces or false if none found.
*/
function fetch_all($params) {
$obj = grade_object::get_instance('grade_outcome');
return $obj->fetch_all_helper('grade_outcomes', 'grade_outcome', $params);
return grade_object::fetch_all_helper('grade_outcomes', 'grade_outcome', $params);
}
/**
@@ -170,8 +168,7 @@ class grade_outcome extends grade_object {
*/
function load_scale() {
if (empty($this->scale->id) or $this->scale->id != $this->scaleid) {
$grade_scale = grade_object::get_instance('grade_scale');
$this->scale = $grade_scale->fetch(array('id'=>$this->scaleid));
$this->scale = grade_scale::fetch(array('id'=>$this->scaleid));
$this->scale->load_items();
}
return $this->scale;
@@ -183,8 +180,7 @@ class grade_outcome extends grade_object {
* @return object
*/
function fetch_all_global() {
$obj = grade_object::get_instance('grade_outcome');
if (!$outcomes = $obj->fetch_all(array('courseid'=>null))) {
if (!$outcomes = grade_outcome::fetch_all(array('courseid'=>null))) {
$outcomes = array();
}
return $outcomes;
@@ -197,8 +193,7 @@ class grade_outcome extends grade_object {
* @return object
*/
function fetch_all_local($courseid) {
$obj = grade_object::get_instance('grade_outcome');
if (!$outcomes =$obj->fetch_all(array('courseid'=>$courseid))) {
if (!$outcomes =grade_outcome::fetch_all(array('courseid'=>$courseid))) {
$outcomes = array();
}
return $outcomes;
@@ -213,8 +208,6 @@ class grade_outcome extends grade_object {
function fetch_all_available($courseid) {
global $CFG;
$obj = grade_object::get_instance('grade_outcome');
$result = array();
$sql = "SELECT go.*
FROM {$CFG->prefix}grade_outcomes go, {$CFG->prefix}grade_outcomes_courses goc
@@ -223,8 +216,8 @@ class grade_outcome extends grade_object {
if ($datas = get_records_sql($sql)) {
foreach($datas as $data) {
$instance = grade_object::get_instance('grade_outcome');
$obj->set_properties($instance, $data);
$instance = new grade_outcome();
grade_object::set_properties($instance, $data);
$result[$instance->id] = $instance;
}
}
@@ -276,7 +269,7 @@ class grade_outcome extends grade_object {
return 1;
}
return $this->lib_wrapper->count_records('grade_outcomes_courses', 'outcomeid', $this->id);
return count_records('grade_outcomes_courses', 'outcomeid', $this->id);
}
/**
@@ -284,7 +277,7 @@ class grade_outcome extends grade_object {
* @return int
*/
function get_item_uses_count() {
return $this->lib_wrapper->count_records('grade_items', 'outcomeid', $this->id);
return count_records('grade_items', 'outcomeid', $this->id);
}
/**
@@ -308,7 +301,7 @@ class grade_outcome extends grade_object {
}
if ($average === false && $items === false) {
debugging('Either the 1st or 2nd param of $this->get_grade_info() must be true, or both, but not both false!');
debugging('Either the 1st or 2nd param of grade_outcome::get_grade_info() must be true, or both, but not both false!');
return false;
}
@@ -329,7 +322,7 @@ class grade_outcome extends grade_object {
AND {$CFG->prefix}grade_outcomes.id = $this->id
$wheresql";
$grades = $this->lib_wrapper->get_records_sql($sql);
$grades = get_records_sql($sql);
$retval = array();
if ($average !== false && count($grades) > 0) {
@@ -350,7 +343,7 @@ class grade_outcome extends grade_object {
if ($items !== false) {
foreach ($grades as $grade) {
$retval['items'][$grade->id] = $this->get_instance('grade_item', $grade);
$retval['items'][$grade->id] = new grade_item($grade);
}
}
lib/grade/grade_scale.php
+10 -14
View File
@@ -82,8 +82,7 @@ class grade_scale extends grade_object {
* @return object grade_scale instance or false if none found.
*/
function fetch($params) {
$obj = grade_object::get_instance('grade_scale');
return $obj->fetch_helper('scale', 'grade_scale', $params);
return grade_object::fetch_helper('scale', 'grade_scale', $params);
}
/**
@@ -94,8 +93,7 @@ class grade_scale extends grade_object {
* @return array array of grade_scale insatnces or false if none found.
*/
function fetch_all($params) {
$obj = grade_object::get_instance('grade_scale');
return $obj->fetch_all_helper('scale', 'grade_scale', $params);
return grade_object::fetch_all_helper('scale', 'grade_scale', $params);
}
/**
@@ -192,7 +190,7 @@ class grade_scale extends grade_object {
*/
function get_nearest_item($grade) {
// Obtain nearest scale item from average
$scales_array = $this->lib_wrapper->get_records_list('scale', 'id', $this->id);
$scales_array = get_records_list('scale', 'id', $this->id);
$scale = $scales_array[$this->id];
$scales = explode(",", $scale->scale);
@@ -209,8 +207,7 @@ class grade_scale extends grade_object {
* @return object
*/
function fetch_all_global() {
$obj = grade_object::get_instance('grade_scale');
return $obj->fetch_all(array('courseid'=>0));
return grade_scale::fetch_all(array('courseid'=>0));
}
/**
@@ -218,8 +215,7 @@ class grade_scale extends grade_object {
* @return object
*/
function fetch_all_local($courseid) {
$obj = grade_object::get_instance('grade_scale');
return $obj->fetch_all(array('courseid'=>$courseid));
return grade_scale::fetch_all(array('courseid'=>$courseid));
}
/**
@@ -239,18 +235,18 @@ class grade_scale extends grade_object {
// count grade items excluding the
$sql = "SELECT COUNT(id) FROM {$CFG->prefix}grade_items WHERE scaleid = {$this->id} AND outcomeid IS NULL";
if ($this->lib_wrapper->count_records_sql($sql)) {
if (count_records_sql($sql)) {
return true;
}
// count outcomes
$sql = "SELECT COUNT(id) FROM {$CFG->prefix}grade_outcomes WHERE scaleid = {$this->id}";
if ($this->lib_wrapper->count_records_sql($sql)) {
if (count_records_sql($sql)) {
return true;
}
$legacy_mods = false;
if ($mods = $this->lib_wrapper->get_records('modules', 'visible', 1)) {
if ($mods = get_records('modules', 'visible', 1)) {
foreach ($mods as $mod) {
//Check cm->name/lib.php exists
if (file_exists($CFG->dirroot.'/mod/'.$mod->name.'/lib.php')) {
@@ -274,12 +270,12 @@ class grade_scale extends grade_object {
// some mods are missing the new xxx_scale_used_anywhere() - use the really slow old way
if ($legacy_mods) {
if (!empty($this->courseid)) {
if ($this->lib_wrapper->course_scale_used($this->courseid,$this->id)) {
if (course_scale_used($this->courseid,$this->id)) {
return true;
}
} else {
$courses = array();
if ($this->lib_wrapper->site_scale_used($this->id,$courses)) {
if (site_scale_used($this->id,$courses)) {
return true;
}
}
lib/grade/simpletest/testgradecategory.php
+264 -440
View File
@@ -26,7 +26,7 @@
/**
* Unit tests for grade_category object.
*
* @author nicolasconnault@gmail.com
* @author nicolas@moodle.com
* @license http://www.gnu.org/copyleft/gpl.html GNU Public License
* @package moodlecore
*/
@@ -39,124 +39,105 @@ require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
class grade_category_test extends grade_test {
function setUp() {
parent::setUp();
$this->load_grade_items();
function test_grade_category_construct() {
$course_category = grade_category::fetch_course_category($this->courseid);
$params = new stdClass();
$params->courseid = $this->courseid;
$params->fullname = 'unittestcategory4';
$grade_category = new grade_category($params, false);
$grade_category->insert();
$this->assertEqual($params->courseid, $grade_category->courseid);
$this->assertEqual($params->fullname, $grade_category->fullname);
$this->assertEqual(2, $grade_category->depth);
$this->assertEqual("/$course_category->id/$grade_category->id/", $grade_category->path);
$parentpath = $grade_category->path;
// Test a child category
$params->parent = $grade_category->id;
$params->fullname = 'unittestcategory5';
$grade_category = new grade_category($params, false);
$grade_category->insert();
$this->assertEqual(3, $grade_category->depth);
$this->assertEqual($parentpath.$grade_category->id."/", $grade_category->path);
$parentpath = $grade_category->path;
// Test a third depth category
$params->parent = $grade_category->id;
$params->fullname = 'unittestcategory6';
$grade_category = new grade_category($params, false);
$grade_category->insert();
$this->assertEqual(4, $grade_category->depth);
$this->assertEqual($parentpath.$grade_category->id."/", $grade_category->path);
}
function test_grade_category_build_path() {
$grade_category = new grade_category(array('parent' => 2, 'id' => 3, 'path' => '/1/2/3/'), false);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($grade_category, 'build_path'));
// Mock get_record of parent category (2) then (1)
$obj = grade_object::get_instance('grade_category');
$obj->lib_wrapper->expectCallCount('get_record', 2);
$parent2 = new stdClass();
$parent2->parent = 1;
$parent2->id = 2;
$obj->lib_wrapper->setReturnValueAt(0, 'get_record', $parent2);
$parent1 = new stdClass();
$parent1->parent = null;
$parent1->id = 1;
$obj->lib_wrapper->setReturnValueAt(1, 'get_record', $parent1);
$path = $grade_category->build_path($grade_category);
$path = grade_category::build_path($grade_category);
$this->assertEqual($grade_category->path, $path);
}
function test_grade_category_fetch() {
$grade_category = new grade_category();
$this->assertTrue(method_exists($grade_category, 'fetch'));
$grade_category = grade_category::fetch(array('id'=>$this->grade_categories[0]->id));
$this->assertEqual($this->grade_categories[0]->id, $grade_category->id);
$this->assertEqual($this->grade_categories[0]->fullname, $grade_category->fullname);
}
function test_grade_category_fetch_all() {
$grade_category = new grade_category();
$this->assertTrue(method_exists($grade_category, 'fetch_all'));
$grade_categories = grade_category::fetch_all(array('courseid'=>$this->courseid));
$this->assertEqual(count($this->grade_categories), count($grade_categories)-1);
}
function test_grade_category_update() {
Mock::generatePartial('grade_category', 'partial_mock', array('load_grade_item',
'build_path',
'apply_forced_settings',
'qualifies_for_regrading',
'force_regrading'));
$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);
$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_category->droplow = 1;
$grade_category->keephigh = 1;
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category->lib_wrapper->expectOnce('update_record');
$grade_category->lib_wrapper->setReturnValue('update_record', true);
$grade_item = new grade_item(array('id' => 99, 'itemtype' => 'course', 'courseid' => $this->courseid, 'needsupdate' => 0), false);
$grade_category->grade_item = $grade_item;
$grade_item = $grade_category->get_grade_item();
$this->assertEqual(0, $grade_item->needsupdate);
// Set method expectations
$grade_category->expectOnce('load_grade_item');
$grade_category->expectOnce('apply_forced_settings');
$grade_category->setReturnValue('qualifies_for_regrading', true);
$grade_category->expectOnce('force_regrading');
$this->assertTrue($grade_category->update());
$this->assertEqual(0, $grade_category->keephigh);
$this->assertEqual(1, $grade_category->droplow);
$this->assertTrue($grade_category->timemodified > 0);
$this->assertTrue($grade_category->timemodified <= time());
$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_delete() {
Mock::generatePartial('grade_category', 'mock_grade_category_for_delete', array('load_grade_item',
'is_course_category',
'load_parent_category',
'force_regrading'));
$grade_category = &new mock_grade_category_for_delete($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category->id = 1;
$grade_category->expectOnce('load_grade_item');
$grade_category->setReturnValue('is_course_category', false);
$grade_category->expectOnce('force_regrading');
$grade_category->expectOnce('load_parent_category');
$parent_category = new mock_grade_category();
$grade_category->lib_wrapper = new mock_lib_wrapper();
$parent_category->id = 1;
$grade_category->setReturnReference('load_parent_category', $parent_category);
$grade_item = new mock_grade_item();
$grade_item->id = 2;
$grade_category->setReturnReference('load_grade_item', $grade_item);
$grade_category->lib_wrapper->expectOnce('delete_records', array('grade_categories', 'id', $grade_category->id));
$grade_category->lib_wrapper->setReturnValue('delete_records', true);
$grade_category->lib_wrapper->expectOnce('insert_record'); // grade_history entry
$grade_category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($grade_category, 'delete'));
$this->assertTrue($grade_category->delete());
$this->assertFalse(get_record('grade_categories', 'id', $grade_category->id));
}
function test_grade_category_insert() {
$course_category = grade_category::fetch_course_category($this->courseid);
Mock::generatePartial('grade_category', 'mock_grade_category_for_insert', array('update',
'apply_forced_settings',
'force_regrading'));
$course_category = $this->grade_categories[0];
$grade_category = new mock_grade_category_for_insert($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category = new grade_category();
$this->assertTrue(method_exists($grade_category, 'insert'));
$grade_category->fullname = 'unittestcategory4';
@@ -166,438 +147,281 @@ class grade_category_test extends grade_test {
$grade_category->keephigh = 100;
$grade_category->droplow = 10;
$grade_category->hidden = 0;
$grade_category->parent = $this->grade_categories[1]->id;
$grade_category->lib_wrapper->expectCallCount('insert_record', 2); // main insert and history table insert
$grade_category->lib_wrapper->setReturnValue('insert_record', 4);
$grade_category->lib_wrapper->expectOnce('get_record'); // for update_from_db() method
$grade_category->lib_wrapper->setReturnValue('get_record', array(1));
$grade_category->parent = $this->grade_categories[0]->id;
$grade_category->insert();
// Don't test path and depth, they're the job of the update method
$this->assertEqual($grade_category->id, 4);
$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);
$this->assertFalse(empty($grade_category->grade_item));
$this->assertEqual($grade_category->id, $grade_category->grade_item->iteminstance);
$this->assertEqual('category', $grade_category->grade_item->itemtype);
$this->assertEqual($grade_category->id, $last_grade_category->id + 1);
$this->assertFalse(empty($grade_category->timecreated));
$this->assertFalse(empty($grade_category->timemodified));
}
function test_grade_category_insert_course_category() {
$grade_category = new mock_grade_category_for_insert($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category = new grade_category();
$this->assertTrue(method_exists($grade_category, 'insert_course_category'));
$grade_category->expectOnce('apply_forced_settings');
$grade_category->expectOnce('update', array('system'));
$grade_category->lib_wrapper->expectCallCount('insert_record', 2); // main insert and history table insert
$grade_category->lib_wrapper->setReturnValue('insert_record', 1);
$grade_category->lib_wrapper->expectOnce('get_record'); // for update_from_db() method
$grade_category->lib_wrapper->setReturnValue('get_record', array(1));
$id = $grade_category->insert_course_category($this->courseid);
$this->assertNotNull($id);
$this->assertEqual(get_string('coursegradecategory', 'grades'), $grade_category->fullname);
$this->assertEqual(GRADE_AGGREGATE_MEAN, $grade_category->aggregation);
$this->assertEqual('Course grade category', $grade_category->fullname);
$this->assertEqual(GRADE_AGGREGATE_MEAN, $grade_category->aggregate);
$this->assertEqual("/$id/", $grade_category->path);
$this->assertEqual(1, $grade_category->depth);
$this->assertNull($grade_category->parent);
$this->assertFalse(empty($grade_category->timecreated));
$this->assertFalse(empty($grade_category->timemodified));
}
function test_grade_category_qualifies_for_regrading() {
$grade_category = new grade_category($this->grade_categories[0], false);
$grade_category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
$obj = grade_object::get_instance('grade_category');
$obj->expectCallCount('fetch', 4, array(array('id' => $grade_category->id)));
$obj->setReturnValue('fetch', fullclone($grade_category));
$grade_item = new stdClass();
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->aggregation = GRADE_AGGREGATE_MEAN;
$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();
$this->assertEqual(0, $grade_category->grade_item->needsupdate);
$grade_category->force_regrading();
$grade_category->grade_item = null;
$grade_category->load_grade_item();
$this->assertEqual(1, $grade_category->grade_item->needsupdate);
}
function test_grade_category_generate_grades() {
$category = new grade_category($this->grade_categories[3]);
$this->assertTrue(method_exists($category, 'generate_grades'));
$category->load_grade_item();
Mock::generatePartial('grade_category', 'mock_grade_category_for_generate_grades', array('load_grade_item',
'aggregate_grades'));
$grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
$this->assertFalse($grades);
// No generating should occur if the item is locked, but the method still returns true
$grade_category = new mock_grade_category_for_generate_grades($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_item = new mock_grade_item();
$grade_item->setReturnValue('is_locked', true);
$grade_category->grade_item = $grade_item;
$this->assertTrue(method_exists($grade_category, 'generate_grades'));
$grade_category->expectNever('aggregate_grades');
$this->assertTrue($grade_category->generate_grades());
// We can't verify DB records, so let's check method calls
$grade_category = new mock_grade_category_for_generate_grades($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_item = new mock_grade_item();
$grade_item->id = 1;
$grade_category->grade_item = $grade_item;
$grade_item->setReturnValue('is_locked', false);
$grade_item->setReturnValue('depends_on', array(1, 2, 3));
$grade_category->lib_wrapper->expectOnce('get_records_sql');
$grade_category->lib_wrapper->setReturnValue('get_records_sql', array($this->grade_items[2], $this->grade_items[3], $this->grade_items[4]));
$grade_category->lib_wrapper->expectOnce('get_recordset_sql');
$grade_category->lib_wrapper->setReturnValue('get_recordset_sql', 1);
$grade_category->lib_wrapper->expectCallCount('rs_fetch_next_record', 4);
$category->generate_grades();
$grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
$this->assertEqual(3, count($grades));
$record = new stdClass();
$record->userid = 1;
$record->itemid = 1;
$record->finalgrade = 20;
$record->excluded = false;
$grade_category->lib_wrapper->setReturnValueAt(0, 'rs_fetch_next_record', $record);
$record2 = new stdClass();
$record2->userid = 2;
$record2->itemid = 2;
$record2->finalgrade = 20;
$record2->excluded = false;
$grade_category->lib_wrapper->setReturnValueAt(1, 'rs_fetch_next_record', $record2);
$record3 = new stdClass();
$record3->userid = 3;
$record3->itemid = 3;
$record3->finalgrade = 20;
$record3->excluded = false;
$grade_category->lib_wrapper->setReturnValueAt(2, 'rs_fetch_next_record', $record3);
$this->assertTrue($grade_category->generate_grades());
$rawvalues = array();
foreach ($grades as $grade) {
$this->assertWithinMargin($grade->rawgrade, $grade->rawgrademin, $grade->rawgrademax);
$rawvalues[] = (int)$grade->rawgrade;
}
sort($rawvalues);
// calculated mean results
$this->assertEqual($rawvalues, array(20,50,100));
}
function test_grade_category_aggregate_grades() {
Mock::generatePartial('grade_category', 'mock_grade_category_for_aggregate_grades', array('aggregate_values', 'apply_limit_rules'));
// Setup method arguments (no optionals!)
$arg_userid = null;
$arg_items = array();
$arg_grade_values = array(1 => 20); // should get unset early on in the method
$arg_oldgrade = new stdClass();
$arg_oldgrade->finalgrade = null; // These two are set to null to avoid a grade_grade->update() in the aggregate_grades() method
$arg_oldgrade->rawgrade = null;
$arg_oldgrade->itemid = 1;
$arg_oldgrade->rawgrademin = 0;
$arg_oldgrade->rawgrademax = 100;
$arg_oldgrade->rawscaleid = null;
$arg_excluded = false;
// Set up rest of objects
$grade_category = new mock_grade_category_for_aggregate_grades($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_item = new mock_grade_item();
$grade_item->id = 1;
$grade_item->gradetype = GRADE_TYPE_VALUE;
$this->assertTrue(method_exists($grade_category, 'aggregate_grades'));
// If no userid given, should return null;
$grade_category->expectNever('aggregate_values');
$grade_category->expectNever('apply_limit_rules');
$this->assertNull($grade_category->aggregate_grades($arg_userid, $arg_items, $arg_grade_values, $arg_oldgrade, $arg_excluded));
// Return without doing anything if the grade or grade_item is locked (we have control over the grade_item here because
// the grade_grade->grade_item is the same as the grade_category->grade_item
$arg_userid = 1;
$grade_item->setReturnValueAt(0, 'is_locked', true);
$grade_category->grade_item = $grade_item;
$this->assertNull($grade_category->aggregate_grades($arg_userid, $arg_items, $arg_grade_values, $arg_oldgrade, $arg_excluded));
// Proceed further by setting grade_item->is_locked to false. Still return null because no other grade_values than main item's
$grade_item->setReturnValueAt(1, 'is_locked', false);
$this->assertNull($grade_category->aggregate_grades($arg_userid, $arg_items, $arg_grade_values, $arg_oldgrade, $arg_excluded));
// Going further now with a proper array of gradevalues and items. Also provide an excluded itemid
$gi = new mock_grade_item();
$gi->grademin = 0;
$gi->grademax = 100;
$arg_items = array(1 => $grade_item, 2 => fullclone($gi), 3 => fullclone($gi), 4 => fullclone($gi), 5 => fullclone($gi));
$arg_grade_values = array(1 => 20, 2 => null, 3 => 8, 4 => 67, 5 => 53);
$arg_excluded = array(3);
$grade_category = new mock_grade_category_for_aggregate_grades($this);
$grade_item->grademin = 0;
$grade_item->grademax = 100;
$grade_item->scaleid = null;
$grade_category->grade_item = $grade_item;
$grade_category->expectOnce('apply_limit_rules');
$grade_category->expectOnce('aggregate_values');
$grade_category->aggregateonlygraded = true;
$this->assertNull($grade_category->aggregate_grades($arg_userid, $arg_items, $arg_grade_values, $arg_oldgrade, $arg_excluded));
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'aggregate_grades'));
// tested above in test_grade_category_generate_grades()
}
function test_grade_category_apply_limit_rules() {
$grade_category = new grade_category();
$category = new grade_category();
$grades = array(5.374, 9.4743, 2.5474, 7.3754);
$grade_category->droplow = 2;
$grade_category->apply_limit_rules($grades);
$category->droplow = 2;
$category->apply_limit_rules($grades);
sort($grades, SORT_NUMERIC);
$this->assertEqual(array(7.3754, 9.4743), $grades);
$grade_category = new grade_category();
$category = new grade_category();
$grades = array(5.374, 9.4743, 2.5474, 7.3754);
$grade_category->keephigh = 1;
$grade_category->droplow = 0;
$grade_category->apply_limit_rules($grades);
$category->keephigh = 1;
$category->droplow = 0;
$category->apply_limit_rules($grades);
$this->assertEqual(count($grades), 1);
$grade = reset($grades);
$this->assertEqual(9.4743, $grade);
}
/**
* TODO implement
*/
function test_grade_category_is_aggregationcoef_used() {
}
function test_grade_category_fetch_course_tree() {
$grade_category = new grade_category();
$this->assertTrue(method_exists($grade_category, 'fetch_course_tree'));
$category = new grade_category();
$this->assertTrue(method_exists($category, 'fetch_course_tree'));
//TODO: add some tests
}
function test_grade_category_get_children() {
$grade_category = new grade_category();
$grade_category->id = 1;
$grade_category->lib_wrapper = new mock_lib_wrapper();
$course_category = grade_category::fetch_course_category($this->courseid);
// Setup course cats and items:
// 1 course
// |_ 2 category
// | |_ 3 item
// | |_ 4 item
// |_ 5 category
// | |_ 6 item
// | |_ 7 item
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'get_children'));
$cats = array();
$cat = new stdClass();
$cat->id = 1;
$cat->parent = null;
$cat->sortorder = 1;
$cat->depth = 0;
$cats[1] = fullclone($cat);
$cat->id = 3;
$cat->parent = 1;
$cat->sortorder = 2;
$cat->depth = 1;
$cats[3] = fullclone($cat);
$cat->id = 4;
$cat->sortorder = 5;
$cat->depth = 1;
$cats[4] = fullclone($cat);
$item = new stdClass();
$item->itemtype = 'course';
$item->iteminstance = 1;
$item->sortorder = 1;
$items = array();
$items[5] = fullclone($item);
$item->itemtype = 'category';
$item->iteminstance = 3;
$item->sortorder = 2;
$items[6] = fullclone($item);
$item->iteminstance = 4;
$item->sortorder = 5;
$items[7] = fullclone($item);
$item->itemtype = 'item';
$item->categoryid = 3;
$item->sortorder = 3;
$items[8] = fullclone($item);
$item->categoryid = 3;
$item->sortorder = 4;
$items[9] = fullclone($item);
$item->categoryid = 4;
$item->sortorder = 6;
$items[10] = fullclone($item);
$item->categoryid = 4;
$item->sortorder = 7;
$items[11] = fullclone($item);
$grade_category->lib_wrapper->setReturnValueAt(0, 'get_records', $cats);
$grade_category->lib_wrapper->setReturnValueAt(1, 'get_records', $items);
$this->assertTrue(method_exists($grade_category, 'get_children'));
// Do not test recursion
$children_array = $grade_category->get_children(true);
$children_array = $category->get_children(0);
$this->assertTrue(is_array($children_array));
$this->assertEqual(3, count($children_array));
$this->assertEqual('grade_item', get_class($children_array[1]['object']));
$this->assertEqual('courseitem', $children_array[1]['type']);
$this->assertequal(0, $children_array[1]['depth']);
$this->assertEqual('course', $children_array[1]['object']->itemtype);
$this->assertFalse(empty($children_array[2]));
$this->assertFalse(empty($children_array[2]['object']));
$this->assertFalse(empty($children_array[2]['children']));
$this->assertEqual($this->grade_categories[1]->id, $children_array[2]['object']->id);
$this->assertEqual($this->grade_categories[2]->id, $children_array[5]['object']->id);
$this->assertEqual($this->grade_items[0]->id, $children_array[2]['children'][3]['object']->id);
$this->assertEqual($this->grade_items[1]->id, $children_array[2]['children'][4]['object']->id);
$this->assertEqual($this->grade_items[2]->id, $children_array[5]['children'][6]['object']->id);
}
$this->assertEqual('grade_category', get_class($children_array[2]['object']));
$this->assertEqual('category', $children_array[2]['type']);
$this->assertequal(1, $children_array[2]['depth']);
$this->assertEqual(3, count($children_array[2]['children']));
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_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_parent_category() {
Mock::generatePartial('grade_category', 'mock_grade_category_for_load_parent_category', array('get_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);
}
$grade_category = new mock_grade_category_for_load_parent_category($this);;
$grade_category->parent = 1;
$parent = new grade_category($this->grade_categories[0], false);
$grade_category->setReturnReference('get_parent_category', $parent);
$grade_category->expectOnce('get_parent_category', array());
$this->assertTrue(method_exists($grade_category, 'load_parent_category'));
$this->assertEqual(null, $grade_category->parent_category);
$grade_category->load_parent_category();
$this->assertEqual($this->grade_categories[0]->id, $grade_category->parent_category->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_get_name() {
$grade_category = new grade_category($this->grade_categories[0], false);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$this->assertTrue(method_exists($grade_category, 'get_name'));
$grade_category->lib_wrapper->expectOnce('get_record', array('course', 'id', $this->courseid));
$course = new stdClass();
$course->fullname = $grade_category->fullname;
$grade_category->lib_wrapper->setReturnValue('get_record', $course);
$grade_category->parent = null;
$this->assertEqual(format_string($this->grade_categories[0]->fullname), $grade_category->get_name());
// Test with a parent id
$grade_category = new grade_category($this->grade_categories[0], false);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$grade_category->parent = 1;
$grade_category->lib_wrapper->expectNever('get_record');
$this->assertEqual(format_string($this->grade_categories[0]->fullname), $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_set_parent() {
$methods_to_mock = array('is_course_category', 'update', 'fetch', 'force_regrading');
Mock::generatePartial('grade_category', 'mock_grade_category_for_set_parent', $methods_to_mock);
$grade_category_template = new mock_grade_category_for_set_parent($this);
$grade_category_template->parent = 1;
$grade_category_template->courseid = $this->courseid;
$this->assertTrue(method_exists($grade_category_template, 'set_parent'));
// Test when requested parentid is already the category's parent id (1 in this case)
$grade_category = fullclone($grade_category_template);
$grade_category->expectNever('is_course_category');
$grade_category->expectNever('update');
$grade_category->expectNever('fetch');
$this->assertTrue($grade_category->set_parent(1));
$category = new grade_category($this->grade_categories[1]);
$this->assertTrue(method_exists($category, 'set_parent'));
// TODO: implement detailed tests
$grade_category_template->parent = 2;
// Test when parent category is not found in DB
$this->reset_mocks();
$grade_category = fullclone($grade_category_template);
$grade_category->expectOnce('is_course_category');
$grade_category->setReturnValue('is_course_category', false);
$obj = grade_object::get_instance('grade_category');
$obj->expectOnce('fetch', array(array('id' => 1, 'courseid' => $this->courseid)));
$obj->setReturnValue('fetch', false);
$grade_category->expectNever('update');
$grade_category->expectNever('force_regrading');
$this->assertFalse($grade_category->set_parent(1));
// Test when parent category is found in DB
$this->reset_mocks();
$grade_category = fullclone($grade_category_template);
$grade_category->expectOnce('is_course_category');
$grade_category->setReturnValue('is_course_category', false);
$obj = grade_object::get_instance('grade_category');
$obj->expectOnce('fetch', array(array('id' => 1, 'courseid' => $this->courseid)));
$obj->setReturnValue('fetch', $this->grade_categories[0]);
$grade_category->expectOnce('force_regrading', array());
$grade_category->expectOnce('update');
$grade_category->setReturnValue('update', true);
$this->assertTrue($grade_category->set_parent(1));
$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_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_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() {
$methods_to_mock = array('instantiate_new_grade_category', 'fetch', 'insert_course_category');
Mock::generatePartial('grade_category', 'mock_grade_category_for_fetch_course_category', $methods_to_mock);
$grade_category = new mock_grade_category_for_fetch_course_category($this);
$grade_category->lib_wrapper = new mock_lib_wrapper();
$this->assertTrue(method_exists($grade_category, 'fetch_course_category'));
// Test method when course category already exists
$grade_category->expectNever('instantiate_new_grade_category');
$obj = grade_object::get_instance('grade_category');
$obj->setReturnValue('fetch', $this->grade_categories[0]);
$this->assertEqual($this->grade_categories[0], $grade_category->fetch_course_category($this->courseid));
// Test method when course category does not exists
$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));
}
/**
* TODO implement
*/
function test_grade_category_is_editable() {
}
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() {
$methods_to_mock = array('load_grade_item', 'instantiate_new_grade_item', 'fetch_all');
$lockedstate = true;
$cascade = false;
$refresh = false;
// Test non-cascading set_locked
Mock::generatePartial('grade_category', 'mock_grade_category_for_set_locked', $methods_to_mock);
$grade_item = new mock_grade_item();
$grade_item->expectCallCount('set_locked', 2, array($lockedstate, $cascade, true));
$grade_item->setReturnValue('set_locked', true);
$grade_item->expectNever('fetch_all');
$grade_category = new mock_grade_category_for_set_locked($this);
$grade_category->expectOnce('load_grade_item');
$grade_category->expectNever('instantiate_new_grade_item');
$this->assertTrue(method_exists($grade_category, 'set_locked'));
$grade_category->grade_item = $grade_item;
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'set_locked'));
$this->assertTrue($category->set_locked(1));
}
$this->assertTrue($grade_category->set_locked($lockedstate, $cascade, $refresh));
// Test cascading set_locked
$cascading = true;
$grade_category = new mock_grade_category_for_set_locked($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;
$this->assertTrue($grade_category->set_locked($lockedstate, $cascade, $refresh));
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() {
$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->grade_item = $grade_item;
$category = new grade_category($this->grade_categories[0]);
$this->assertTrue(method_exists($category, 'set_hidden'));
$category->set_hidden(1);
$category->load_grade_item();
$this->assertEqual(true, $category->grade_item->is_hidden());
}
$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);
}
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;
}
}
?>
lib/grade/simpletest/testgradegrades.php
+46 -77
View File
@@ -38,15 +38,6 @@ if (!defined('MOODLE_INTERNAL')) {
require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
class grade_grade_test extends grade_test {
function setUp() {
parent::setUp();
$this->load_grade_grades();
}
function tearDown() {
parent::tearDown();
}
function test_grade_grade_construct() {
$params = new stdClass();
@@ -64,7 +55,6 @@ class grade_grade_test extends grade_test {
function test_grade_grade_insert() {
$grade_grade = new grade_grade();
$grade_grade->lib_wrapper = new mock_lib_wrapper();
$this->assertTrue(method_exists($grade_grade, 'insert'));
$grade_grade->itemid = $this->grade_items[0]->id;
@@ -72,101 +62,86 @@ class grade_grade_test extends grade_test {
$grade_grade->rawgrade = 88;
$grade_grade->rawgrademax = 110;
$grade_grade->rawgrademin = 18;
$grade_item = new grade_item($this->grade_items[0], false);
$grade_grade->grade_item = $grade_item;
// Check the grade_item's needsupdate variable first
$grade_grade->load_grade_item();
$this->assertFalse($grade_grade->grade_item->needsupdate);
$grade_grade->lib_wrapper->expectCallCount('insert_record', 2); // main insert and history table insert
$grade_grade->lib_wrapper->setReturnValue('insert_record', 1);
$grade_grade->lib_wrapper->expectOnce('get_record'); // for update_from_db() method
$grade_grade->lib_wrapper->setReturnValue('get_record', array(1));
$grade_grade->insert();
$this->assertEqual($grade_grade->id, 1);
$last_grade_grade = end($this->grade_grades);
// timecreated doesn't refer to creation in the DB, but to time of submission. Timemodified refers to date of grading
$this->assertTrue(empty($grade_grade->timecreated));
$this->assertTrue(empty($grade_grade->timemodified));
$this->assertEqual($grade_grade->id, $last_grade_grade->id + 1);
$this->assertFalse(empty($grade_grade->timecreated));
$this->assertFalse(empty($grade_grade->timemodified));
}
function test_grade_grade_update() {
$grade_grade = new grade_grade($this->grade_grades[0], false);
$grade_grade->lib_wrapper = new mock_lib_wrapper();
$grade_grade->lib_wrapper->expectOnce('update_record');
$grade_grade->lib_wrapper->setReturnValue('update_record', true);
$grade_grade = new grade_grade($this->grade_grades[0]);
$this->assertTrue(method_exists($grade_grade, 'update'));
$grade_grade->update();
}
function test_grade_grade_fetch() {
$grade_grade = new grade_grade();
$this->assertTrue(method_exists($grade_grade, 'fetch'));
$grades = grade_grade::fetch(array('id'=>$this->grade_grades[0]->id));
$this->assertEqual($this->grade_grades[0]->id, $grades->id);
$this->assertEqual($this->grade_grades[0]->rawgrade, $grades->rawgrade);
}
function test_grade_grade_fetch_all() {
$grade_grade = new grade_grade();
$this->assertTrue(method_exists($grade_grade, 'fetch_all'));
$grades = grade_grade::fetch_all(array());
$this->assertEqual(count($this->grade_grades), count($grades));
}
function test_grade_grade_load_grade_item() {
$grade_grade = new grade_grade($this->grade_grades[0], false);
$grade_grade->lib_wrapper = new mock_lib_wrapper();
$grade_grade->itemid = $this->grade_items[0]->id;
$grade_grade = new grade_grade($this->grade_grades[0]);
$this->assertTrue(method_exists($grade_grade, 'load_grade_item'));
$this->assertNull($grade_grade->grade_item);
$this->assertTrue($grade_grade->itemid);
$grade_item = grade_object::get_instance('grade_item');
$grade_item->expectOnce('fetch', array(array('id' => $grade_grade->itemid)));
$gi = $this->grade_items[0];
$grade_item->setReturnReference('fetch', $gi);
$this->assertNotNull($grade_grade->load_grade_item());
$this->assertNotNull($grade_grade->grade_item);
$this->assertEqual($this->grade_items[0]->id, $grade_grade->grade_item->id);
}
function test_grade_grade_standardise_score() {
$this->assertEqual(4, round(grade_grade::standardise_score(6, 0, 7, 0, 5)));
$this->assertEqual(40, grade_grade::standardise_score(50, 30, 80, 0, 100));
}
/**
* In this test we always set the 2nd param of set_locked() to false, because it
* would otherwise trigger the refresh_grades method, which is not being tested here.
*/
function test_grade_grade_set_locked() {
$grade_item = new grade_item($this->grade_items[0], false);
$grade = new grade_grade($this->grade_grades[0], false);
$grade->lib_wrapper = new mock_lib_wrapper();
$grade->lib_wrapper->expectCallCount('update_record', 2);
$grade->lib_wrapper->setReturnValue('update_record', true);
$grade->grade_item = $grade_item;
$grade->itemid = $grade_item->id;
function test_grade_grade_set_locked() {
$grade_item = new grade_item($this->grade_items[0]);
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue(method_exists($grade, 'set_locked'));
$this->assertTrue(empty($grade_item->locked));
$this->assertTrue(empty($grade->locked));
// Test locking the grade when needsupdate is true
$grade->grade_item->needsupdate = true;
$this->assertFalse($grade->set_locked(true, false, false));
// Test locking the grade when needsupdate is false
$grade->grade_item->needsupdate = false;
$this->assertTrue($grade->set_locked(true, false, false));
$this->assertTrue($grade->set_locked(true));
$this->assertFalse(empty($grade->locked));
$this->assertTrue($grade->set_locked(false, false, false));
$this->assertTrue($grade->set_locked(false));
$this->assertTrue(empty($grade->locked));
$grade = new grade_grade($this->grade_grades[0], false);
$grade->lib_wrapper = new mock_lib_wrapper();
$grade->lib_wrapper->expectOnce('update_record');
$grade->lib_wrapper->setreturnvalue('update_record', true);
$grade->grade_item = $grade_item;
$grade->itemid = $grade_item->id;
$this->assertTrue($grade_item->set_locked(true));
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue($grade->set_locked(false, false, false));
$this->assertFalse(empty($grade->locked));
$this->assertFalse($grade->set_locked(false));
$this->assertTrue($grade_item->set_locked(false));
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue($grade->set_locked(false));
}
function test_grade_grade_is_locked() {
$grade = new grade_grade($this->grade_grades[0], false);
$grade->grade_item = new grade_item($this->grade_items[0], false);
$grade = new grade_grade($this->grade_grades[0]);
$this->assertTrue(method_exists($grade, 'is_locked'));
$this->assertFalse($grade->is_locked());
@@ -175,30 +150,22 @@ class grade_grade_test extends grade_test {
}
function test_grade_grade_set_hidden() {
$grade_item = new grade_item($this->grade_items[0], false);
$grade = new grade_grade($this->grade_grades[0], false);
$grade->lib_wrapper = new mock_lib_wrapper();
$grade->lib_wrapper->expectCallCount('update_record', 2);
$grade->lib_wrapper->setreturnvalue('update_record', true);
$grade->grade_item = $grade_item;
$grade->itemid = $grade_item->id;
$grade_item = new grade_item($this->grade_items[0]);
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue(method_exists($grade, 'set_hidden'));
$this->assertEqual(0, $grade_item->hidden);
$this->assertEqual(0, $grade->hidden);
$grade->set_hidden(0);
$this->assertEqual(0, $grade->hidden);
$grade->set_hidden(1);
$this->assertEqual(1, $grade->hidden);
// @TODO test with cascading on (2nd param set to true)
}
function test_grade_grade_is_hidden() {
$grade = new grade_grade($this->grade_grades[0], false);
$grade->grade_item = new grade_item($this->grade_items[0], false);
$grade = new grade_grade($this->grade_grades[0]);
$this->assertTrue(method_exists($grade, 'is_hidden'));
$this->assertFalse($grade->is_hidden());
@@ -211,5 +178,7 @@ class grade_grade_test extends grade_test {
$grade->hidden = time()+666;
$this->assertTrue($grade->is_hidden());
}
}
?>
lib/grade/simpletest/testgradeitem.php
+168 -311
View File
@@ -40,12 +40,7 @@ require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
@set_time_limit(0);
class grade_item_test extends grade_test {
function setUp() {
parent::setUp();
$this->load_grade_items();
}
function test_grade_item_construct() {
$params = new stdClass();
@@ -64,11 +59,7 @@ class grade_item_test extends grade_test {
}
function test_grade_item_insert() {
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();
$grade_item = new grade_item();
$this->assertTrue(method_exists($grade_item, 'insert'));
$grade_item->courseid = $this->courseid;
@@ -78,344 +69,230 @@ 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();
$this->assertEqual($grade_item->id, 4);
$last_grade_item = end($this->grade_items);
$this->assertFalse(empty($grade_item->timecreated));
$this->assertFalse(empty($grade_item->timemodified));
$this->assertEqual($grade_item->id, $last_grade_item->id + 1);
$this->assertEqual(11, $grade_item->sortorder);
}
function test_grade_item_delete() {
$source = 'unit tests';
Mock::generatePartial('grade_item', 'mock_grade_item_for_delete', array('is_course_item', 'force_regrading'));
Mock::generatePartial('grade_grade', 'mock_grade_grade_for_item_delete', array('delete'));
$grade_item =& new mock_grade_item_for_delete($this);
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->id = 1;
$grade_item->lib_wrapper->expectOnce('delete_records', array($grade_item->table, 'id', $grade_item->id));
$grade_item->lib_wrapper->setReturnValue('delete_records', true);
$grade_grade_instance = grade_object::get_instance('grade_grade');
$grade_grades = array();
$grade_grades[1] = new mock_grade_grade_for_item_delete($this);
$grade_grades[1]->expectOnce('delete', array($source));
$grade_grades[2] = new mock_grade_grade_for_item_delete($this);
$grade_grades[2]->expectOnce('delete', array($source));
$grade_grades[3] = new mock_grade_grade_for_item_delete($this);
$grade_grades[3]->expectOnce('delete', array($source));
$grade_grade_instance->expectOnce('fetch_all', array(array('itemid' => $grade_item->id)));
$grade_grade_instance->setReturnValue('fetch_all', $grade_grades);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'delete'));
$this->assertTrue($grade_item->delete($source));
$this->assertTrue($grade_item->delete());
$this->assertFalse(get_record('grade_items', 'id', $grade_item->id));
}
function test_grade_item_update() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_update', array('force_regrading', 'qualifies_for_regrading', 'load_scale'));
$grade_item = new mock_grade_item_for_update($this);
grade_object::set_properties($grade_item, $this->grade_items[0]);
$grade_item->iteminfo = 'Updated info for this unittest grade_item';
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->lib_wrapper->expectOnce('update_record', array($grade_item->table, '*'));
$grade_item->lib_wrapper->setReturnValue('update_record', true);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'update'));
$grade_item->expectOnce('load_scale', array());
$grade_item->expectOnce('qualifies_for_regrading', array());
$grade_item->setReturnValue('qualifies_for_regrading', true);
$grade_item->expectOnce('force_regrading', array());
$this->assertTrue($grade_item->update());
$grade_item->iteminfo = 'Updated info for this unittest grade_item';
$this->assertTrue($grade_item->update());
$grade_item->grademin = 14;
$this->assertTrue($grade_item->qualifies_for_regrading());
$this->assertTrue($grade_item->update());
$iteminfo = get_field('grade_items', 'iteminfo', 'id', $this->grade_items[0]->id);
$this->assertEqual($grade_item->iteminfo, $iteminfo);
}
function test_grade_item_load_scale() {
$grade_item = new grade_item($this->grade_items[2], false);
$grade_item = new grade_item($this->grade_items[2]);
$this->assertTrue(method_exists($grade_item, 'load_scale'));
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->gradetype = GRADE_TYPE_VALUE; // Should return null
$this->assertNull($grade_item->load_scale());
$grade_item->gradetype = GRADE_TYPE_SCALE;
$grade_item->scaleid = 1;
$grade_scale = grade_object::get_instance('grade_scale');
$grade_scale->expectOnce('fetch', array(array('id' => $grade_item->scaleid)));
$item_grade_scale = new mock_grade_scale();
$item_grade_scale->expectOnce('load_items', array());
$item_grade_scale->scale_items = array(1, 2, 3);
$grade_scale->setReturnValue('fetch', $item_grade_scale);
$grade_item->scale = $grade_scale;
$this->assertEqual($item_grade_scale, $grade_item->load_scale());
$this->assertEqual(3, $grade_item->grademax);
$this->assertEqual(1, $grade_item->grademin);
$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() {
$this->load_grade_outcomes();
$grade_item = new grade_item($this->grade_items[0], false);
$grade_item->outcomeid = 1;
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'load_outcome'));
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_outcome = grade_object::get_instance('grade_outcome');
$grade_outcome->expectOnce('fetch', array(array('id' => $grade_item->outcomeid)));
$return_outcome = new grade_outcome($this->grade_outcomes[0], false);
$grade_outcome->setReturnValue('fetch', $return_outcome);
$this->assertEqual($return_outcome, $grade_item->load_outcome());
//TODO: add tests
}
function test_grade_item_qualifies_for_regrading() {
// Setup
Mock::generatePartial('grade_item', 'mock_grade_item_for_qualifies', array('get_instance'));
$grade_item = new mock_grade_item_for_qualifies($this);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'qualifies_for_regrading'));
grade_object::set_properties($grade_item, $this->grade_items[0]);
// Should return false when no item->id given
$grade_item->id = null;
$this->assertFalse($grade_item->qualifies_for_regrading());
// Returns false because new record is identical to original
$grade_item->id = 1;
$grade_item->expectCallCount('get_instance', 2, array('grade_item', array('id' => $grade_item->id)));
$db_item = grade_object::get_instance('grade_item', $this->grade_items[0], false);
$grade_item->setReturnValue('get_instance', $db_item);
$this->assertFalse($grade_item->qualifies_for_regrading());
// Should return true when one of the fields is different
$grade_item->gradetype = GRADE_TYPE_NONE;
$grade_item->iteminfo = 'Updated info for this unittest grade_item';
$this->assertFalse($grade_item->qualifies_for_regrading());
$grade_item->grademin = 14;
$this->assertTrue($grade_item->qualifies_for_regrading());
}
function test_grade_item_force_regrading() {
$grade_item = new grade_item($this->grade_items[0], false);
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->lib_wrapper->expectOnce('set_field_select', array('grade_items', 'needsupdate', 1, '*'));
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'force_regrading'));
$this->assertEqual(0, $grade_item->needsupdate);
$grade_item->force_regrading();
$this->assertEqual(1, $grade_item->needsupdate);
$grade_item->update_from_db();
$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], false);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_final'));
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->lib_wrapper->expectOnce('get_records', array('grade_grades', 'itemid', $grade_item->id));
$grade_grades = array();
$grade_grades[1] = new mock_grade_grade();
$grade_grades[1]->userid = 1;
$grade_grades[2] = new mock_grade_grade();
$grade_grades[2]->userid = 2;
$grade_grades[3] = new mock_grade_grade();
$grade_grades[3]->userid = 3;
$grade_grades[4] = new mock_grade_grade(); // final grades are indexed by userid, so if 2 are given with the same userid, the last one will override the first
$grade_grades[4]->userid = 3;
$grade_item->lib_wrapper->setReturnValue('get_records', $grade_grades);
$final_grades = $grade_item->get_final();
$this->assertEqual(3, count($final_grades));
}
}
/**
* Retrieve all final scores for a specific userid.
*/
function test_grade_item_get_final() {
$this->load_grade_grades();
$grade_item = new grade_item($this->grade_items[0], false);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_final'));
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->lib_wrapper->expectOnce('get_record', array('grade_grades', 'itemid', $grade_item->id, 'userid', $this->userid));
$grade_item->lib_wrapper->setReturnValue('get_record', $this->grade_grades[0]);
$final_grade = $grade_item->get_final($this->userid);
$this->assertEqual($this->grade_grades[0]->finalgrade, $final_grade->finalgrade);
}
function test_grade_item_set_sortorder() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_set_sortorder', array('update'));
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);
}
$grade_item = new mock_grade_item_for_set_sortorder($this);
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->expectOnce('update', array());
$grade_item->sortorder = 1;
$grade_item->set_sortorder(999);
$this->assertEqual($grade_item->sortorder, 999);
}
function test_grade_item_move_after_sortorder() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_move_after', array('set_sortorder'));
$sortorder = 5;
$grade_item = new mock_grade_item_for_move_after($this);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'move_after_sortorder'));
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item->lib_wrapper->expectOnce('execute_sql', array('*', false));
$grade_item->expectOnce('set_sortorder', array($sortorder + 1));
$grade_item->move_after_sortorder($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() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_set_parent', array('force_regrading', 'update'));
$grade_item = new mock_grade_item_for_set_parent($this);
$grade_item->lib_wrapper = new mock_lib_wrapper();
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_parent'));
// When categoryid == $parentid param, method should return true but no force_regrading or update should be called
$grade_item->categoryid = 1;
$grade_item->expectNever('update');
$grade_item->expectNever('force_regrading');
$this->assertTrue($grade_item->set_parent(1));
// When parentid param is different from categoryid, force_regrading and update must be called
$grade_item = new mock_grade_item_for_set_parent($this);
$grade_item->categoryid = 2;
$grade_item->courseid = $this->courseid;
$parentid = 4;
$grade_item->expectOnce('update', array());
$grade_item->setReturnValue('update', true);
$grade_item->expectOnce('force_regrading', array());
$grade_category = grade_object::get_instance('grade_category');
$parent_category = new mock_grade_category();
$parent_category->id = 1;
$grade_category->expectOnce('fetch', array(array('id' => $parentid, 'courseid' => $this->courseid)));
$grade_category->setReturnValue('fetch', $parent_category);
$this->assertTrue($grade_item->set_parent($parentid));
$old = $grade_item->get_parent_category();
$new = new grade_category($this->grade_categories[3]);
$new_item = $new->get_grade_item();
$this->assertTrue($grade_item->set_parent($new->id));
$new_item->update_from_db();
$grade_item->update_from_db();
$this->assertEqual($grade_item->categoryid, $new->id);
}
function test_grade_item_get_parent_category() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_get_parent_category', array('is_category_item', 'is_course_item', 'get_item_category'));
// When item is a course or category item, the method should return the item category
$grade_item = new mock_grade_item_for_get_parent_category($this);
$grade_item->expectOnce('is_category_item', array());
$grade_item->expectOnce('is_course_item', array());
$grade_item->expectOnce('get_item_category', array());
$grade_item->setReturnValue('is_category_item', false);
$grade_item->setReturnValue('is_course_item', true);
$grade_item->setReturnValue('get_item_category', 'item_category');
$this->assertEqual('item_category', $grade_item->get_parent_category());
// When the item is a normal grade item, the method should return the parent category
$grade_item = new mock_grade_item_for_get_parent_category($this);
$grade_item->expectOnce('is_category_item', array());
$grade_item->expectOnce('is_course_item', array());
$grade_item->setReturnValue('is_category_item', false);
$grade_item->setReturnValue('is_course_item', false);
$grade_item->categoryid = 4;
$grade_category = grade_object::get_instance('grade_category');
$grade_category->expectOnce('fetch', array(array('id' => $grade_item->categoryid)));
$grade_category->setReturnValue('fetch', true);
$this->assertTrue($grade_item->get_parent_category());
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'get_parent_category'));
$category = $grade_item->get_parent_category();
$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
*/
function test_grade_item_regrade_final_grades() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_regrade_final', array('is_locked', 'is_calculated', 'compute', 'is_outcome_item',
'is_category_item', 'is_course_item', 'get_item_category', 'is_manual_item', 'is_raw_used', 'get_instance', 'adjust_raw_grade'));
// If grade_item is locked, no regrading occurs but the method returns true
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_locked', array());
$grade_item->setReturnValue('is_locked', true);
$grade_item->expectNever('get_item_category');
$this->assertTrue($grade_item->regrade_final_grades());
// If the item is calculated and the computation is OK, no regrading occurs and the method returns true
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_calculated', array());
$grade_item->setReturnValue('is_calculated', true);
$grade_item->expectOnce('compute', array($this->userid));
$grade_item->setReturnValue('compute', true);
$grade_item->expectNever('get_item_category');
$this->assertTrue($grade_item->regrade_final_grades($this->userid));
// If the item is calculated but the grades cannot be calculated, method should return an error message
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_calculated', array());
$grade_item->setReturnValue('is_calculated', true);
$grade_item->expectOnce('compute', array($this->userid));
$grade_item->setReturnValue('compute', false);
$this->assertEqual("Could not calculate grades for grade item", $grade_item->regrade_final_grades($this->userid));
// If the item is an outcome item, return true before regrading
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_outcome_item', array());
$grade_item->setReturnValue('is_outcome_item', true);
$this->assertTrue($grade_item->regrade_final_grades($this->userid));
// If the item is a category or course item, category must generate grades, then return true
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectCallCount('is_category_item', 2, array());
$grade_item->expectCallCount('is_course_item', 2, array());
$grade_item->setReturnValue('is_category_item', false);
$grade_item->setReturnValue('is_course_item', true);
$grade_item->expectCallCount('get_item_category', 2, array());
$category = new mock_grade_category();
$category->expectCallCount('generate_grades', 2, array($this->userid));
$category->setReturnValueAt(0, 'generate_grades', true);
$category->setReturnValueAt(1, 'generate_grades', false); // if generate_grades() is false, method should return false
$grade_item->setReturnValue('get_item_category', $category);
$this->assertTrue($grade_item->regrade_final_grades($this->userid));
$this->assertEqual("Could not aggregate final grades for category:".$grade_item->id, $grade_item->regrade_final_grades($this->userid));
// If the item is a manual item, method should return true before regrading
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_manual_item', array());
$grade_item->setReturnValue('is_manual_item', true);
$this->assertTrue($grade_item->regrade_final_grades($this->userid));
// If the item is not using raw grades, method should return true without regrading
$grade_item = new mock_grade_item_for_regrade_final($this);
$grade_item->expectOnce('is_raw_used', array());
$grade_item->setReturnValue('is_raw_used', false);
$this->assertTrue($grade_item->regrade_final_grades($this->userid));
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'regrade_final_grades'));
$this->assertEqual(true, $grade_item->regrade_final_grades());
//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], false);
$grade_scale = new mock_grade_scale();
$grade_scale->id = 1;
$grade_items->scale = $grade_scale;
$grade_items->scaleid = $grade_scale->id;
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
$grade_raw = new stdClass();
$grade_raw->rawgrade = 40;
$grade_raw->grademax = 100;
$grade_raw->grademin = 0;
$this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
$grade_item->gradetype = GRADE_TYPE_TEXT;
$this->assertNull($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
$grade_item->gradetype = GRADE_TYPE_NONE;
$this->assertNull($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
$grade_item->gradetype = GRADE_TYPE_SCALE;
$grade_item->grademax = -1;
$this->assertNull($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
$grade_item->grademax = 0;
$this->assertEqual(0, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->grademax = 20;
$grade_item->grademin = 21;
$this->assertNull($grade_item->adjust_raw_grade(null, 0, 10)); // null raw = null
$this->assertNull($grade_item->adjust_raw_grade(20, 0, 10)); // item->min > item->max = null
$grade_item->multfactor = 1;
$grade_item->plusfactor = 0;
$grade_item->grademax = 50;
@@ -467,53 +344,30 @@ 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() {
Mock::generatePartial('grade_item', 'mock_grade_item_for_set_locked', array('get_final', 'update', 'get_instance', 'refresh_grades'));
$grade_item = new mock_grade_item_for_set_locked($this);
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'set_locked'));
$grade_item->needsupdate = true;
$this->assertFalse($grade_item->set_locked(true));
$grade_item->needsupdate = false;
$grade_item->expectOnce('update', array());
$grade_item->expectNever('get_final');
$this->assertTrue($grade_item->set_locked(true, false));
$this->assertTrue($grade_item->locked > 0);
$this->assertTrue($grade_item->locked <= time());
// Add cascading to the previous call
$grade_item = new mock_grade_item_for_set_locked($this);
$grade_item->needsupdate = false;
$grade = new mock_grade_grade();
$grade->expectCallCount('set_locked', 2, array(1, null, false));
$grade_item->expectOnce('update', array());
$grade_item->expectCallCount('get_instance', 2);
$grade_item->expectOnce('get_final', array());
$grade_item->setReturnValue('get_final', array(1, 2)); // array returned by get_final is irrelevant: grade_grade objects get instantiated using get_instance
$grade_item->setReturnValue('get_instance', $grade);
$this->assertTrue($grade_item->set_locked(true, true));
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue(empty($grade_item->locked));
$this->assertTrue(empty($grade->locked));
// Try with lock set to false
$grade_item = new mock_grade_item_for_set_locked($this);
$grade_item->locked = time() - 3600;
$grade_item->expectOnce('update', array());
$grade_item->expectNever('refresh_grades', array());
$this->assertTrue($grade_item->set_locked(false, false, false));
$this->assertEqual(0, $grade_item->locktime);
$this->assertEqual(0, $grade_item->locked);
$this->assertTrue($grade_item->set_locked(true));
$grade = new grade_grade($grade_item->get_final(1));
// Add refresh and cascading to the previous call
$grade_item = new mock_grade_item_for_set_locked($this);
$grade_item->id = 1;
$grade_grade = grade_object::get_instance('grade_grade');
$grade_grade->expectOnce('fetch_all', array(array('itemid' => $grade_item->id)));
$grade = new mock_grade_grade();
$grade_grade->setReturnValue('fetch_all', array(clone($grade), clone($grade)));
$this->assertTrue($grade_item->set_locked(false, true, true));
$this->assertFalse(empty($grade_item->locked));
$this->assertFalse(empty($grade->locked)); // individual grades should be locked too
$this->assertTrue($grade_item->set_locked(false));
$grade = new grade_grade($grade_item->get_final(1));
$this->assertTrue(empty($grade_item->locked));
$this->assertTrue(empty($grade->locked)); // individual grades should be unlocked too
}
/*
function test_grade_item_is_locked() {
$grade_item = new grade_item($this->grade_items[0]);
$this->assertTrue(method_exists($grade_item, 'is_locked'));
@@ -525,6 +379,9 @@ 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'));
@@ -533,7 +390,7 @@ class grade_item_test extends grade_test {
$this->assertEqual(0, $grade_item->hidden);
$this->assertEqual(0, $grade->hidden);
$grade_item->set_hidden(666, true);
$grade_item->set_hidden(666);
$grade = new grade_grade($grade_item->get_final(1));
$this->assertEqual(666, $grade_item->hidden);
@@ -654,6 +511,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);
}
*/
}
?>
lib/grade/simpletest/testgradeoutcome.php
+28 -48
View File
@@ -38,14 +38,6 @@ if (!defined('MOODLE_INTERNAL')) {
require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
class grade_outcome_test extends grade_test {
function setUp() {
parent::setUp();
$this->load_grade_outcomes();
}
function tearDown() {
parent::tearDown();
}
function test_grade_outcome_construct() {
$params = new stdClass();
@@ -60,67 +52,55 @@ class grade_outcome_test extends grade_test {
function test_grade_outcome_insert() {
$grade_outcome = new grade_outcome();
$grade_outcome->lib_wrapper = new mock_lib_wrapper();
$this->assertTrue(method_exists($grade_outcome, 'insert'));
$grade_outcome->courseid = $this->courseid;
$grade_outcome->shortname = 'tw';
$grade_outcome->fullname = 'Team work';
$grade_outcome->lib_wrapper->expectCallCount('insert_record', 3); // main insert, history table insert and grade_outcomes_courses insert
$grade_outcome->lib_wrapper->setReturnValue('insert_record', 1);
$grade_outcome->lib_wrapper->expectOnce('get_record'); // for update_from_db() method
$grade_outcome->lib_wrapper->setReturnValue('get_record', array(1));
$grade_outcome->insert();
$this->assertEqual($grade_outcome->id, 1);
$last_grade_outcome = end($this->grade_outcomes);
$this->assertEqual($grade_outcome->id, $last_grade_outcome->id + 1);
$this->assertFalse(empty($grade_outcome->timecreated));
$this->assertFalse(empty($grade_outcome->timemodified));
}
function test_grade_outcome_update() {
$grade_outcome = new grade_outcome($this->grade_outcomes[0], false);
$grade_outcome->lib_wrapper = new mock_lib_wrapper();
$grade_outcome->timecreated = time() - 200000;
$grade_outcome->timemodified = $grade_outcome->timecreated;
$grade_outcome->timemodified = $grade_outcome->timecreated;
$timemodified = $grade_outcome->timemodified;
$timecreated = $grade_outcome->timecreated;
$grade_outcome->courseid = $this->courseid;
function test_grade_outcome_update() {
$grade_outcome = new grade_outcome($this->grade_outcomes[0]);
$this->assertTrue(method_exists($grade_outcome, 'update'));
$grade_outcome->shortname = 'Team work';
$grade_outcome->lib_wrapper->expectOnce('update_record');
$grade_outcome->lib_wrapper->setReturnValue('update_record', true);
$grade_outcome->lib_wrapper->expectOnce('get_records');
$grade_outcome->lib_wrapper->setReturnValue('get_records', false); // Pretend there is no record in grade_outcoms_courses table
$grade_outcome->lib_wrapper->expectCallCount('insert_record', 2); // 1. grade_outcome_courses, 2. grade_outcomes_history
$this->assertTrue($grade_outcome->update());
// We expect timecreated to be unchanged, and timemodified to be updated
$this->assertTrue($grade_outcome->timemodified > $timemodified);
$this->assertTrue($grade_outcome->timemodified > $grade_outcome->timecreated);
$this->assertTrue($grade_outcome->timecreated == $timecreated);
$shortname = get_field('grade_outcomes', 'shortname', 'id', $this->grade_outcomes[0]->id);
$this->assertEqual($grade_outcome->shortname, $shortname);
}
function test_grade_outcome_delete() {
$grade_outcome = new grade_outcome($this->grade_outcomes[0], false);
$grade_outcome->courseid = $this->courseid;
$grade_outcome->lib_wrapper = new mock_lib_wrapper();
$grade_outcome->lib_wrapper->expectCallCount('delete_records', 2);
$grade_outcome->lib_wrapper->expectAt(0, 'delete_records', array('grade_outcomes_courses', 'outcomeid', $grade_outcome->id, 'courseid', $this->courseid));
$grade_outcome->lib_wrapper->expectAt(1, 'delete_records', array('grade_outcomes', 'id', $grade_outcome->id));
$grade_outcome->lib_wrapper->setReturnValue('delete_records', true);
$grade_outcome = new grade_outcome($this->grade_outcomes[0]);
$this->assertTrue(method_exists($grade_outcome, 'delete'));
$grade_outcome->lib_wrapper->expectOnce('insert_record'); // grade_history entry
$this->assertTrue(method_exists($grade_outcome, 'delete'));
$this->assertTrue($grade_outcome->delete());
$this->assertFalse(get_record('grade_outcomes', 'id', $grade_outcome->id));
}
function test_grade_outcome_fetch() {
$grade_outcome = new grade_outcome();
$this->assertTrue(method_exists($grade_outcome, 'fetch'));
$grade_outcome = grade_outcome::fetch(array('id'=>$this->grade_outcomes[0]->id));
$this->assertEqual($this->grade_outcomes[0]->id, $grade_outcome->id);
$this->assertEqual($this->grade_outcomes[0]->shortname, $grade_outcome->shortname);
$this->assertEqual($this->scale[2]->id, $grade_outcome->scale->id);
}
function test_grade_outcome_fetch_all() {
$grade_outcome = new grade_outcome();
$this->assertTrue(method_exists($grade_outcome, 'fetch_all'));
$grade_outcomes = grade_outcome::fetch_all(array());
$this->assertEqual(count($this->grade_outcomes), count($grade_outcomes));
}
}
?>
lib/grade/simpletest/testgradescale.php
+12
View File
@@ -125,6 +125,18 @@ class grade_scale_test extends grade_test {
$this->assertTrue($grade_scale->delete());
}
function test_grade_scale_fetch() {
$grade_scale = new grade_scale();
$grade_scale->lib_wrapper = new mock_lib_wrapper();
$grade_scale->lib_wrapper->expectOnce('get_records_select');
$grade_scale->lib_wrapper->setReturnValue('get_records_select', array($this->scale[0]));
$this->assertTrue(method_exists($grade_scale, 'fetch'));
$grade_scale = $grade_scale->fetch(array('id'=>$this->scale[0]->id));
$this->assertEqual($this->scale[0]->id, $grade_scale->id);
$this->assertEqual($this->scale[0]->name, $grade_scale->name);
}
function test_scale_load_items() {
$scale = new grade_scale($this->scale[0], false);
$this->assertTrue(method_exists($scale, 'load_items'));
lib/gradelib.php
-2
View File
@@ -38,7 +38,6 @@ require_once($CFG->libdir . '/grade/grade_item.php');
require_once($CFG->libdir . '/grade/grade_grade.php');
require_once($CFG->libdir . '/grade/grade_scale.php');
require_once($CFG->libdir . '/grade/grade_outcome.php');
require_once($CFG->libdir . '/grade/lib_wrapper.php');
/***** PUBLIC GRADE API - only these functions should be used in modules *****/
@@ -588,7 +587,6 @@ function grade_get_course_grade($user, $course = null) {
}
}
/***** END OF PUBLIC API *****/
lib/simpletest/fixtures/gradetest.php
+772 -331
View File
File diff suppressed because it is too large Load Diff