More fine-tuning of gradebook classes

diff --git a/lib/grade/grade_category.php b/lib/grade/grade_category.php
index 3984c1b28bf7b3284fad120a57c72af57acd633c..b0e0714860fcdcebc625d66780df7eb76811b971 100644 (file)
--- a/lib/grade/grade_category.php
+++ b/lib/grade/grade_category.php
@@ -227,9 +227,10 @@ 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 = $this->fetch_all(array('courseid'=>$this->courseid))) {
+            if ($categories = $obj->fetch_all(array('courseid'=>$this->courseid))) {
                 foreach ($categories as $category) {
                     if ($category->id == $this->id) {
                         continue; // do not delete course category yet
@@ -258,7 +259,7 @@ class grade_category extends grade_object {
                     $child->set_parent($parent->id);
                 }
             }
-            if ($children = $this->fetch_all(array('parent'=>$this->id))) {
+            if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
                 foreach ($children as $child) {
                     $child->set_parent($parent->id);
                 }
@@ -289,7 +290,7 @@ class grade_category extends grade_object {
         }
 
         if (empty($this->parent)) {
-            $course_category = $this->fetch_course_category($this->courseid);
+            $course_category = $obj->fetch_course_category($this->courseid);
             $this->parent = $course_category->id;
         }
 
@@ -349,8 +350,8 @@ class grade_category extends grade_object {
             debugging("Can not regrade non existing category");
             return false;
         }
-
-        $db_item = $this->fetch(array('id'=>$this->id));
+        $obj = grade_object::get_instance('grade_category');
+        $db_item = $obj->fetch(array('id'=>$this->id));
 
         $aggregationdiff = $db_item->aggregation         != $this->aggregation;
         $keephighdiff    = $db_item->keephigh            != $this->keephigh;
@@ -414,7 +415,7 @@ class grade_category extends grade_object {
             $usersql = "";
         }
 
-        $grade_inst = $this->get_instance('grade_grade');
+        $grade_inst = grade_object::get_instance('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
@@ -518,7 +519,7 @@ class grade_category extends grade_object {
                 unset($grade_values[$itemid]);
                 continue;
             }
-            $grade_grade = $this->get_instance('grade_grade');
+            $grade_grade = grade_object::get_instance('grade_grade');
             $grade_values[$itemid] = $grade_grade->standardise_score($v, $items[$itemid]->grademin, $items[$itemid]->grademax, 0, 1);
         }
 
@@ -556,7 +557,7 @@ class grade_category extends grade_object {
         $grade->rawgrade    = null; // categories do not use raw grades
         
         // recalculate the rawgrade back to requested range
-        $grade_grade= $this->get_instance('grade_grade');
+        $grade_grade= grade_object::get_instance('grade_grade');
         $finalgrade = $grade_grade->standardise_score($agg_grade, 0, 1, $this->grade_item->grademin, $this->grade_item->grademax);
 
         if (!is_null($finalgrade)) {
@@ -693,7 +694,7 @@ class grade_category extends grade_object {
      * @return array
      */
     function fetch_course_tree($courseid, $include_category_items=false) {
-        $obj = new grade_category();
+        $obj = grade_object::get_instance('grade_category');
         $course_category = $obj->fetch_course_category($courseid);
         $category_array = array('object'=>$course_category, 'type'=>'category', 'depth'=>1,
                                 'children'=>$course_category->get_children($include_category_items));
@@ -870,7 +871,7 @@ class grade_category extends grade_object {
             $params = array('courseid'=>$this->courseid, 'itemtype'=>'category', 'iteminstance'=>$this->id);
         }
         
-        $grade_item = $this->get_instance('grade_item');
+        $grade_item = grade_object::get_instance('grade_item');
 
         if (!$grade_items = $grade_item->fetch_all($params)) {
             // create a new one
@@ -949,7 +950,8 @@ class grade_category extends grade_object {
         }
 
         // find parent and check course id
-        if (!$parent_category = $this->fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
+        $obj = grade_object::get_instance('grade_category');
+        if (!$parent_category = $obj->fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
             return false;
         }
 
@@ -1032,12 +1034,13 @@ class grade_category extends grade_object {
     function fetch_course_category($courseid) {
 
         // course category has no parent
-        if ($course_category = $this->fetch(array('courseid'=>$courseid, 'parent'=>null))) {
+        $obj = grade_object::get_instance('grade_category');
+        if ($course_category = $obj->fetch(array('courseid'=>$courseid, 'parent'=>null))) {
             return $course_category;
         }
 
         // create a new one
-        $course_category = $this->get_instance('grade_category');
+        $course_category = grade_object::get_instance('grade_category');
         $course_category->insert_course_category($courseid);
 
         return $course_category;
@@ -1076,7 +1079,7 @@ class grade_category extends grade_object {
 
         if ($cascade) {
             //process all children - items and categories
-            $grade_item = $this->get_instance('grade_item');
+            $grade_item = grade_object::get_instance('grade_item');
             if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
                 foreach($children as $child) {
                     $child->set_locked($lockedstate, true, false);
@@ -1086,7 +1089,8 @@ class grade_category extends grade_object {
                     }
                 }
             }
-            if ($children = $this->fetch_all(array('parent'=>$this->id))) {
+            $obj = grade_object::get_instance('grade_category');
+            if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
                 foreach($children as $child) {
                     $child->set_locked($lockedstate, true, true);
                 }
@@ -1126,13 +1130,14 @@ class grade_category extends grade_object {
         $this->load_grade_item();
         $this->grade_item->set_hidden($hidden);
         if ($cascade) {
-            $grade_item = $this->get_instance('grade_item');
+            $grade_item = grade_object::get_instance('grade_item');
             if ($children = $grade_item->fetch_all(array('categoryid'=>$this->id))) {
                 foreach($children as $child) {
                     $child->set_hidden($hidden, $cascade);
                 }
             }
-            if ($children = $this->fetch_all(array('parent'=>$this->id))) {
+            $obj = grade_object::get_instance('grade_category');
+            if ($children = $obj->fetch_all(array('parent'=>$this->id))) {
                 foreach($children as $child) {
                     $child->set_hidden($hidden, $cascade);
                 }

diff --git a/lib/grade/grade_grade.php b/lib/grade/grade_grade.php
index 033933880209a2bf11afde80e7b43b442f396637..ed01fc5bee0d5290552962fe30915edec8545a2b 100644 (file)
--- a/lib/grade/grade_grade.php
+++ b/lib/grade/grade_grade.php
@@ -180,7 +180,7 @@ class grade_grade extends grade_object {
         if ($include_missing) {
             foreach ($userids as $userid) {
                 if (!array_key_exists($userid, $result)) {
-                    $grade_grade = $this->get_instance('grade_grade');
+                    $grade_grade = grade_object::get_instance('grade_grade');
                     $grade_grade->userid = $userid;
                     $grade_grade->itemid = $grade_item->id;
                     $result[$userid] = $grade_grade;
@@ -203,7 +203,7 @@ class grade_grade extends grade_object {
         }
 
         if (empty($this->grade_item)) {
-            $grade_item = $this->get_instance('grade_item');
+            $grade_item = grade_object::get_instance('grade_item');
             $this->grade_item = $grade_item->fetch(array('id'=>$this->itemid));
 
         } else if ($this->grade_item->id != $this->itemid) {
@@ -504,7 +504,8 @@ class grade_grade extends grade_object {
      * @return object grade_grade instance or false if none found.
      */
     function fetch($params) {
-        return $this->fetch_helper('grade_grades', 'grade_grade', $params);
+        $obj = grade_object::get_instance('grade_grade');
+        return $obj->fetch_helper('grade_grades', 'grade_grade', $params);
     }
 
     /**
@@ -515,7 +516,8 @@ class grade_grade extends grade_object {
      * @return array array of grade_grade insatnces or false if none found.
      */
     function fetch_all($params) {
-        return $this->fetch_all_helper('grade_grades', 'grade_grade', $params);
+        $obj = grade_object::get_instance('grade_grade');
+        return $obj->fetch_all_helper('grade_grades', 'grade_grade', $params);
     }
 
     /**
@@ -554,9 +556,11 @@ class grade_grade extends grade_object {
      */
     function get_hiding_affected(&$grade_grades, &$grade_items) {
         global $CFG;
+        
+        $obj = grade_object::get_instance('grade_grade');
 
         if (count($grade_grades) !== count($grade_items)) {
-            error("Incorrent size of arrays in params of $this->get_hiding_affected()!");
+            error('Incorrent size of arrays in params of grade_grade::get_hiding_affected()!');
         }
 
         $dependson = array();
@@ -628,7 +632,7 @@ class grade_grade extends grade_object {
                                     unset($values[$itemid]);
                                     continue;
                                 }
-                                $values[$itemid] = $this->standardise_score($value, $grade_items[$itemid]->grademin, $grade_items[$itemid]->grademax, 0, 1);
+                                $values[$itemid] = $obj->standardise_score($value, $grade_items[$itemid]->grademin, $grade_items[$itemid]->grademax, 0, 1);
                             }
 
                             if ($grade_category->aggregateonlygraded) {
@@ -661,7 +665,7 @@ class grade_grade extends grade_object {
                             $agg_grade = $grade_category->aggregate_values($values, $grade_items);
 
                             // recalculate the rawgrade back to requested range
-                            $finalgrade = $this->standardise_score($agg_grade, 0, 1, $grade_items[$do]->grademin, $grade_items[$do]->grademax);
+                            $finalgrade = $obj->standardise_score($agg_grade, 0, 1, $grade_items[$do]->grademin, $grade_items[$do]->grademax);
 
                             if (!is_null($finalgrade)) {
                                 $finalgrade = bounded_number($grade_items[$do]->grademin, $finalgrade, $grade_items[$do]->grademax);

diff --git a/lib/grade/grade_item.php b/lib/grade/grade_item.php
index 36076cb86ce79a1efc766f1afe985d2e17cc294d..361c29d293cbf2f2f6779ab446bdfbe5a186017f 100644 (file)
--- a/lib/grade/grade_item.php
+++ b/lib/grade/grade_item.php
@@ -336,7 +336,7 @@ class grade_item extends grade_object {
             $this->force_regrading();
         }
         
-        $grade_grade = $this->get_instance('grade_grade');
+        $grade_grade = grade_object::get_instance('grade_grade');
         if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
             foreach ($grades as $grade) {
                 $grade->delete($source);
@@ -362,7 +362,7 @@ class grade_item extends grade_object {
         $this->load_scale();
 
         // add parent category if needed
-        $grade_category = $this->get_instance('grade_category');
+        $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);
             $this->categoryid = $course_category->id;
@@ -445,7 +445,7 @@ class grade_item extends grade_object {
         }
 
         if (!empty($userid)) {
-            $grade_grade = $this->get_instance('grade_grade');
+            $grade_grade = grade_object::get_instance('grade_grade');
             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();
@@ -494,7 +494,7 @@ class grade_item extends grade_object {
             $this->update();
 
             if ($cascade) {
-                $grade_grade = $this->get_instance('grade_grade');
+                $grade_grade = grade_object::get_instance('grade_grade');
                 if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
                     foreach($grades as $grade) {
                         $grade->grade_item =& $this;
@@ -581,7 +581,7 @@ class grade_item extends grade_object {
         $this->update();
 
         if ($cascade) {
-            $grade_grade = $this->get_instance('grade_grade');
+            $grade_grade = grade_object::get_instance('grade_grade');
             if ($grades = $grade_grade->fetch_all(array('itemid'=>$this->id))) {
                 foreach($grades as $grade) {
                     $grade->grade_item =& $this;
@@ -661,7 +661,7 @@ class grade_item extends grade_object {
 
         // normal grade item - just new final grades
         $result = true;
-        $grade_inst = $this->get_instance('grade_grade');
+        $grade_inst = grade_object::get_instance('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);
@@ -715,7 +715,7 @@ class grade_item extends grade_object {
             // Standardise score to the new grade range
             // NOTE: this is not compatible with current assignment grading
             if ($rawmin != $this->grademin or $rawmax != $this->grademax) {
-                $grade_grade = $this->get_instance('grade_grade');
+                $grade_grade = grade_object::get_instance('grade_grade');
                 $rawgrade = $grade_grade->standardise_score($rawgrade, $rawmin, $rawmax, $this->grademin, $this->grademax);
             }
 
@@ -741,7 +741,7 @@ class grade_item extends grade_object {
             // Convert scale if needed
             // NOTE: this is not compatible with current assignment grading
             if ($rawmin != $this->grademin or $rawmax != $this->grademax) {
-                $grade_grade = $this->get_instance('grade_grade');
+                $grade_grade = grade_object::get_instance('grade_grade');
                 $rawgrade = $grade_grade->standardise_score($rawgrade, $rawmin, $rawmax, $this->grademin, $this->grademax);
             }
 
@@ -782,7 +782,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 = $this->get_instance('grade_scale');
+                $grade_scale = grade_object::get_instance('grade_scale');
                 $this->scale = $grade_scale->fetch(array('id'=>$this->scaleid));
                 $this->scale->load_items();
             }
@@ -806,7 +806,7 @@ class grade_item extends grade_object {
      */
     function load_outcome() {
         if (!empty($this->outcomeid)) {
-            $grade_outcome = $this->get_instance('grade_outcome');
+            $grade_outcome = grade_object::get_instance('grade_outcome');
             $this->outcome = $grade_outcome->fetch(array('id'=>$this->outcomeid));
         }
         return $this->outcome;
@@ -823,7 +823,7 @@ class grade_item extends grade_object {
             return $this->get_item_category();
 
         } else {
-            $grade_category = $this->get_instance('grade_category');
+            $grade_category = grade_object::get_instance('grade_category');
             return $grade_category->fetch(array('id'=>$this->categoryid));
         }
     }
@@ -849,7 +849,7 @@ class grade_item extends grade_object {
         if (!$this->is_course_item() and !$this->is_category_item()) {
             return false;
         }
-        $grade_category = $this->get_instance('grade_category');
+        $grade_category = grade_object::get_instance('grade_category');
         return $grade_category->fetch(array('id'=>$this->iteminstance));
     }
 
@@ -927,13 +927,13 @@ class grade_item extends grade_object {
      * @return course item object
      */
     function fetch_course_item($courseid) {
-        $obj = new grade_item();
+        $obj = grade_object::get_instance('grade_item');;
         if ($course_item = $obj->fetch(array('courseid'=>$courseid, 'itemtype'=>'course'))) {
             return $course_item;
         }
 
         // first get category - it creates the associated grade item
-        $grade_category = $obj->get_instance('grade_category');
+        $grade_category = grade_object::get_instance('grade_category');
         $course_category = $grade_category->fetch_course_category($courseid);
 
         return $obj->fetch(array('courseid'=>$courseid, 'itemtype'=>'course'));
@@ -1010,7 +1010,8 @@ 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) {
-                if ($grade_item = $this->fetch(array('id'=>$id, 'courseid'=>$courseid))) {
+                $obj = grade_object::get_instance('grade_item');;
+                if ($grade_item = $obj->fetch(array('id'=>$id, 'courseid'=>$courseid))) {
                     if (!empty($grade_item->idnumber)) {
                         $formula = str_replace('##gi'.$grade_item->id.'##', '[['.$grade_item->idnumber.']]', $formula);
                     }
@@ -1037,7 +1038,8 @@ class grade_item extends grade_object {
         }
 
         // normalize formula - we want grade item ids ##giXXX## instead of [[idnumber]]
-        if ($grade_items = $this->fetch_all(array('courseid'=>$courseid))) {
+        $obj = grade_object::get_instance('grade_item');;
+        if ($grade_items = $obj->fetch_all(array('courseid'=>$courseid))) {
             foreach ($grade_items as $grade_item) {
                 $formula = str_replace('[['.$grade_item->idnumber.']]', '##gi'.$grade_item->id.'##', $formula);
             }
@@ -1176,7 +1178,7 @@ class grade_item extends grade_object {
         }
 
         // find parent and check course id
-        $grade_category = $this->get_instance('grade_category');
+        $grade_category = grade_object::get_instance('grade_category');
         if (!$parent_category = $grade_category->fetch(array('id'=>$parentid, 'courseid'=>$this->courseid))) {
             return false;
         }
@@ -1407,7 +1409,8 @@ class grade_item extends grade_object {
             }
 
         } else if (!$this->needsupdate) {
-            $course_item = $this->fetch_course_item($this->courseid);
+            $obj = grade_object::get_instance('grade_item');;
+            $course_item = $obj->fetch_course_item($this->courseid);
             if (!$course_item->needsupdate) {
                 if (!grade_regrade_final_grades($this->courseid, $userid, $this)) {
                     $this->force_regrading();
@@ -1527,7 +1530,8 @@ class grade_item extends grade_object {
             $this->force_regrading();
 
         } else if (!$this->needsupdate) {
-            $course_item = $this->fetch_course_item($this->courseid);
+            $obj = grade_object::get_instance('grade_item');;
+            $course_item = $obj->fetch_course_item($this->courseid);
             if (!$course_item->needsupdate) {
                 if (!grade_regrade_final_grades($this->courseid, $userid, $this)) {
                     $this->force_regrading();
@@ -1575,7 +1579,7 @@ class grade_item extends grade_object {
             $usersql = "";
         }
 
-        $grade_inst = $this->get_instance('grade_grade');
+        $grade_inst = grade_object::get_instance('grade_grade');
         $fields = 'g.'.implode(',g.', $grade_inst->required_fields);
 
         $sql = "SELECT $fields

diff --git a/lib/grade/grade_outcome.php b/lib/grade/grade_outcome.php
index f624ad960963f317cb0573bac9e27a61d24bd415..8429b9cca2f3cd074a7946950b55bf497516aa04 100644 (file)
--- a/lib/grade/grade_outcome.php
+++ b/lib/grade/grade_outcome.php
@@ -148,7 +148,8 @@ class grade_outcome extends grade_object {
      * @return object grade_outcome instance or false if none found.
      */
     function fetch($params) {
-        return $this->fetch_helper('grade_outcomes', 'grade_outcome', $params);
+        $obj = grade_object::get_instance('grade_outcome');
+        return $obj->fetch_helper('grade_outcomes', 'grade_outcome', $params);
     }
 
     /**
@@ -159,7 +160,8 @@ class grade_outcome extends grade_object {
      * @return array array of grade_outcome insatnces or false if none found.
      */
     function fetch_all($params) {
-        return $this->fetch_all_helper('grade_outcomes', 'grade_outcome', $params);
+        $obj = grade_object::get_instance('grade_outcome');
+        return $obj->fetch_all_helper('grade_outcomes', 'grade_outcome', $params);
     }
 
     /**
@@ -168,7 +170,7 @@ class grade_outcome extends grade_object {
      */
     function load_scale() {
         if (empty($this->scale->id) or $this->scale->id != $this->scaleid) {
-            $grade_scale = $this->get_instance('grade_scale');
+            $grade_scale = grade_object::get_instance('grade_scale');
             $this->scale = $grade_scale->fetch(array('id'=>$this->scaleid));
             $this->scale->load_items();
         }
@@ -181,7 +183,8 @@ class grade_outcome extends grade_object {
      * @return object
      */
     function fetch_all_global() {
-        if (!$outcomes = $this->fetch_all(array('courseid'=>null))) {
+        $obj = grade_object::get_instance('grade_outcome');
+        if (!$outcomes = $obj->fetch_all(array('courseid'=>null))) {
             $outcomes = array();
         }
         return $outcomes;
@@ -194,7 +197,8 @@ class grade_outcome extends grade_object {
      * @return object
      */
     function fetch_all_local($courseid) {
-        if (!$outcomes =$this->fetch_all(array('courseid'=>$courseid))) {
+        $obj = grade_object::get_instance('grade_outcome');
+        if (!$outcomes =$obj->fetch_all(array('courseid'=>$courseid))) {
             $outcomes = array();
         }
         return $outcomes;
@@ -209,6 +213,8 @@ 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
@@ -217,8 +223,8 @@ class grade_outcome extends grade_object {
 
         if ($datas = get_records_sql($sql)) {
             foreach($datas as $data) {
-                $instance = $this->get_instance('grade_outcome');
-                $this->set_properties($instance, $data);
+                $instance = grade_object::get_instance('grade_outcome');
+                $obj->set_properties($instance, $data);
                 $result[$instance->id] = $instance;
             }
         }

diff --git a/lib/grade/grade_scale.php b/lib/grade/grade_scale.php
index e26cb1dec29d5e511c3ac035b1437b887d809a9d..294b525cfe057582be63a586697c3f2fdcef0940 100644 (file)
--- a/lib/grade/grade_scale.php
+++ b/lib/grade/grade_scale.php
@@ -82,7 +82,7 @@ class grade_scale extends grade_object {
      * @return object grade_scale instance or false if none found.
      */
     function fetch($params) {
-        $obj = new grade_scale();
+        $obj = grade_object::get_instance('grade_scale');
         return $obj->fetch_helper('scale', 'grade_scale', $params);
     }
 
@@ -94,7 +94,8 @@ class grade_scale extends grade_object {
      * @return array array of grade_scale insatnces or false if none found.
      */
     function fetch_all($params) {
-        return $this->fetch_all_helper('scale', 'grade_scale', $params);
+        $obj = grade_object::get_instance('grade_scale');
+        return $obj->fetch_all_helper('scale', 'grade_scale', $params);
     }
 
     /**
@@ -208,7 +209,8 @@ class grade_scale extends grade_object {
      * @return object
      */
     function fetch_all_global() {
-        return $this->fetch_all(array('courseid'=>0));
+        $obj = grade_object::get_instance('grade_scale');
+        return $obj->fetch_all(array('courseid'=>0));
     }
 
     /**
@@ -216,7 +218,8 @@ class grade_scale extends grade_object {
      * @return object
      */
     function fetch_all_local($courseid) {
-        return $this->fetch_all(array('courseid'=>$courseid));
+        $obj = grade_object::get_instance('grade_scale');
+        return $obj->fetch_all(array('courseid'=>$courseid));
     }
 
     /**

diff --git a/lib/grade/simpletest/testgradecategory.php b/lib/grade/simpletest/testgradecategory.php
index c06b15a976cdd7d690c3145d3c170fdb3d998669..ec6bf982ab945d1879395d1db8275d7c48519513 100755 (executable)
--- a/lib/grade/simpletest/testgradecategory.php
+++ b/lib/grade/simpletest/testgradecategory.php
@@ -64,30 +64,6 @@ class grade_category_test extends grade_test {
         $this->assertEqual($grade_category->path, $path);
     }
 
-    function test_grade_category_fetch() {
-        $grade_category = new grade_category();
-        $grade_category->lib_wrapper = new mock_lib_wrapper();
-        $this->assertTrue(method_exists($grade_category, 'fetch'));
-        
-        $obj = grade_object::get_instance('grade_category');
-        $obj->setReturnValue('fetch', $this->grade_categories[1]);
-        $grade_category = $obj->fetch(array('id'=>$this->grade_categories[1]->id));
-        $this->assertEqual($this->grade_categories[1]->id, $grade_category->id);
-        $this->assertEqual($this->grade_categories[1]->fullname, $grade_category->fullname);
-    }
-
-    function test_grade_category_fetch_all() {
-        $grade_category = new grade_category();
-        $grade_category->lib_wrapper = new mock_lib_wrapper();
-        $this->assertTrue(method_exists($grade_category, 'fetch_all'));
-
-        $obj = grade_object::get_instance('grade_category');
-        $obj->setReturnValue('fetch_all', $this->grade_categories);
-        
-        $grade_categories = $obj->fetch_all(array('courseid'=>$this->courseid));
-        $this->assertEqual(count($this->grade_categories), count($grade_categories));
-    }
-
     function test_grade_category_update() {
 
         Mock::generatePartial('grade_category', 'partial_mock', array('load_grade_item',
@@ -223,12 +199,11 @@ class grade_category_test extends grade_test {
 
     function test_grade_category_qualifies_for_regrading() {
         $grade_category = new grade_category($this->grade_categories[0], false);
-        $grade_category->lib_wrapper = new mock_lib_wrapper();
         $this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
         
-        // Mock fetch of grade_item
-        $grade_category->lib_wrapper->expectCallCount('get_records_select', 2);
-        $grade_category->lib_wrapper->setReturnValue('get_records_select', (array) fullclone($grade_category));
+        $obj = grade_object::get_instance('grade_category');
+        $obj->expectCallCount('fetch', 4, array(array('id' => $grade_category->id)));
+        $obj->setReturnValueAt(0, 'fetch', fullclone($grade_category));
         $grade_item = new stdClass();
         $grade_item->lib_wrapper = new mock_lib_wrapper();
         $grade_item->aggregation = GRADE_AGGREGATE_MEAN;
@@ -236,20 +211,15 @@ class grade_category_test extends grade_test {
         $this->assertFalse($grade_category->qualifies_for_regrading());
 
         $grade_category->aggregation = GRADE_AGGREGATE_MAX;
+        $obj->setReturnValueAt(1, 'fetch', fullclone($grade_category));
         $this->assertTrue($grade_category->qualifies_for_regrading());
 
-        $grade_category = new grade_category($this->grade_categories[0], false);
-        $grade_category->lib_wrapper = new mock_lib_wrapper();
-        $grade_category->lib_wrapper->expectOnce('get_records_select');
-        $grade_category->lib_wrapper->setReturnValue('get_records_select', (array) fullclone($grade_category));
         $grade_category->droplow = 99;
+        $obj->setReturnValueAt(2, 'fetch', fullclone($grade_category));
         $this->assertTrue($grade_category->qualifies_for_regrading());
 
-        $grade_category = new grade_category($this->grade_categories[0], false);
-        $grade_category->lib_wrapper = new mock_lib_wrapper();
-        $grade_category->lib_wrapper->expectOnce('get_records_select');
-        $grade_category->lib_wrapper->setReturnValue('get_records_select', (array) fullclone($grade_category));
         $grade_category->keephigh = 99;
+        $obj->setReturnValueAt(3, 'fetch', fullclone($grade_category));
         $this->assertTrue($grade_category->qualifies_for_regrading());
     }
 
@@ -545,23 +515,31 @@ class grade_category_test extends grade_test {
         $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');
         $grade_category->expectOnce('fetch', array(array('courseid' => $this->courseid, 'parent' => null)));
-        $grade_category->setReturnValue('fetch', $this->grade_categories[0]);
+        $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
         $grade_category = new mock_grade_category_for_fetch_course_category($this);
+        $grade_category->lib_wrapper = new mock_lib_wrapper();
         $grade_category->expectOnce('instantiate_new_grade_category');
         $grade_category->expectOnce('fetch', array(array('courseid' => $this->courseid, 'parent' => null)));
         $grade_category->setReturnValue('fetch', false);
         $course_category = new mock_grade_category_for_fetch_course_category($this);
+        $course_category->lib_wrapper = new mock_lib_wrapper();
         $course_category->expectOnce('insert_course_category', array($this->courseid));
         $grade_category->setReturnValue('instantiate_new_grade_category', $course_category);
-        $this->assertEqual($course_category, $grade_category->fetch_course_category($this->courseid));
+        
+        // Instantiate proper objects (current ones are mock objects)
+        $cat1 = new grade_category($course_category, false);
+        $cat2 = new grade_category($grade_category->fetch_course_category($this->courseid), false);
+        $this->assertEqual($cat1, $cat2);
 
     }
     
@@ -589,7 +567,6 @@ class grade_category_test extends grade_test {
         
         // Test cascading set_locked
         $cascading = true;
-        Mock::generatePartial('grade_category', 'mock_grade_category_for_set_locked', $methods_to_mock);
         $grade_category = new mock_grade_category_for_set_locked($this);
         $grade_category->expectOnce('fetch_all');
         $grade_category->setReturnValue('fetch_all', array(fullclone($grade_item), fullclone($grade_item)));

diff --git a/lib/grade/simpletest/testgradegrades.php b/lib/grade/simpletest/testgradegrades.php
index 424255084601095c5f65ace6d701257be01eccae..c9fca730e0b0694fd0c9a232c6edda2975555e9f 100755 (executable)
--- a/lib/grade/simpletest/testgradegrades.php
+++ b/lib/grade/simpletest/testgradegrades.php
@@ -102,42 +102,18 @@ class grade_grade_test extends grade_test {
         $grade_grade->update();
     }
 
-    function test_grade_grade_fetch() {
-        $grade_grade = new grade_grade($this->grade_grades[0], false);
-        $grade_grade->lib_wrapper = new mock_lib_wrapper();
-        $this->assertTrue(method_exists($grade_grade, 'fetch'));
-
-        $grade_grade->lib_wrapper->expectOnce('get_records_select');
-        $grade_grade->lib_wrapper->setReturnValue('get_records_select', array($this->grade_grades[0]));
-        
-        $grades = $grade_grade->fetch(array('id'=>$grade_grade->id));
-
-        $this->assertEqual($grade_grade->id, $grades->id);
-        $this->assertEqual($grade_grade->rawgrade, $grades->rawgrade);
-    }
-
-    function test_grade_grade_fetch_all() {
-        $grade_grade = new grade_grade();
-        $grade_grade->lib_wrapper = new mock_lib_wrapper();
-        $this->assertTrue(method_exists($grade_grade, 'fetch_all'));
-
-        $grade_grade->lib_wrapper->expectOnce('get_records_select');
-        $grade_grade->lib_wrapper->setReturnValue('get_records_select', $this->grade_grades);
-
-        $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;
         $this->assertTrue(method_exists($grade_grade, 'load_grade_item'));
         $this->assertNull($grade_grade->grade_item);
         $this->assertTrue($grade_grade->itemid);
         
-        $grade_grade->lib_wrapper->expectOnce('get_records_select');
-        $grade_grade->lib_wrapper->setReturnValue('get_records_select', array($this->grade_items[0]));
-        
+        $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);

diff --git a/lib/grade/simpletest/testgradeoutcome.php b/lib/grade/simpletest/testgradeoutcome.php
index 32b80807cfc95b9af8b5ce7523a22e79fb62cfd1..c8a6d50850dbca9d43aa891dbabc9d0d0fa2e0cc 100644 (file)
--- a/lib/grade/simpletest/testgradeoutcome.php
+++ b/lib/grade/simpletest/testgradeoutcome.php
@@ -122,28 +122,5 @@ class grade_outcome_test extends grade_test {
         $this->assertTrue($grade_outcome->delete());
     }
 
-    function test_grade_outcome_fetch() {
-        $grade_outcome = new grade_outcome();
-        $grade_outcome->lib_wrapper = new mock_lib_wrapper();
-        $grade_outcome->lib_wrapper->expectOnce('get_records_select');
-        $grade_outcome->lib_wrapper->setReturnValue('get_records_select', array($this->grade_outcomes[0]));
-        $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);
-    }
-
-    function test_grade_outcome_fetch_all() {
-        $grade_outcome = new grade_outcome();
-        $grade_outcome->lib_wrapper = new mock_lib_wrapper();
-        $grade_outcome->lib_wrapper->expectOnce('get_records_select');
-        $grade_outcome->lib_wrapper->setReturnValue('get_records_select', $this->grade_outcomes);
-        $this->assertTrue(method_exists($grade_outcome, 'fetch_all'));
-
-        $grade_outcomes = $grade_outcome->fetch_all(array());
-        $this->assertEqual(count($this->grade_outcomes), count($grade_outcomes));
-    }
 }
 ?>

diff --git a/lib/grade/simpletest/testgradescale.php b/lib/grade/simpletest/testgradescale.php
index 94245da432c70a333ca3a5766f32c2e045a2500d..2a813f849a63c662b018a43ce50fe79601b8bb9d 100755 (executable)
--- a/lib/grade/simpletest/testgradescale.php
+++ b/lib/grade/simpletest/testgradescale.php
@@ -125,18 +125,6 @@ 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'));

diff --git a/lib/simpletest/fixtures/gradetest.php b/lib/simpletest/fixtures/gradetest.php
index 745ff9a5c2deec4cf0ab146b45b15e3a67939e14..235c8632d55f547e3663ba4c9ff9d9c375ba63e8 100644 (file)
--- a/lib/simpletest/fixtures/gradetest.php
+++ b/lib/simpletest/fixtures/gradetest.php
@@ -113,11 +113,21 @@ class grade_test extends UnitTestCase {
         $CFG->disablegradehistory = false;
                $this->real_db = fullclone($db);
         // $this->reset_mocks();
-        grade_object::get_instance('grade_item', null, false, true, new mock_grade_item_partial($this));
-        grade_object::get_instance('grade_category', null, false, true, new mock_grade_category_partial($this));
-        grade_object::get_instance('grade_grade', null, false, true, new mock_grade_grade_partial($this));
-        grade_object::get_instance('grade_outcome', null, false, true, new mock_grade_outcome_partial($this));
-        grade_object::get_instance('grade_scale', null, false, true, new mock_grade_scale_partial($this)); 
+        $mock_gi = new mock_grade_item_partial($this);
+        $mock_gc = new mock_grade_category_partial($this);
+        $mock_gg = new mock_grade_grade_partial($this);
+        $mock_go = new mock_grade_outcome_partial($this);
+        $mock_gs = new mock_grade_scale_partial($this);
+        $mock_gi->lib_wrapper = new mock_lib_wrapper();
+        $mock_gc->lib_wrapper = new mock_lib_wrapper();
+        $mock_gg->lib_wrapper = new mock_lib_wrapper();
+        $mock_go->lib_wrapper = new mock_lib_wrapper();
+        $mock_gs->lib_wrapper = new mock_lib_wrapper();
+        grade_object::get_instance('grade_item', null, false, true, $mock_gi);
+        grade_object::get_instance('grade_category', null, false, true, $mock_gc);
+        grade_object::get_instance('grade_grade', null, false, true, $mock_gg);
+        grade_object::get_instance('grade_outcome', null, false, true, $mock_go);
+        grade_object::get_instance('grade_scale', null, false, true, $mock_gs); 
     }
 
     /**