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

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

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

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

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