diff --git a/lib/grade/grade_category.php b/lib/grade/grade_category.php
index f4a770a7a60..f4c6524a732 100644
--- a/lib/grade/grade_category.php
+++ b/lib/grade/grade_category.php
@@ -137,7 +137,6 @@ class grade_category extends grade_object {
         }
     }
 
-
     /**
      * Finds and returns a grade_category instance based on params.
      * @static
@@ -173,15 +172,18 @@ class grade_category extends grade_object {
             $this->depth = substr_count($this->path, '/');
         }
 
-        if (!parent::update()) {
-            return false;
-        }
 
         // Recalculate grades if needed
         if ($this->qualifies_for_regrading()) {
+            if (!parent::update()) {
+                return false;
+            }
             $this->grade_item->force_regrading();
+            return true;
+
+        } else {
+            return parent::update();
         }
-        return true;
     }
 
     /**
@@ -270,10 +272,11 @@ class grade_category extends grade_object {
      */
     function qualifies_for_regrading() {
         if (empty($this->id)) {
+            debugging("Can not regrade non existing category");
             return false;
         }
 
-        $db_item = new grade_category(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;
@@ -293,7 +296,7 @@ class grade_category extends grade_object {
      */
     function force_regrading() {
         if (empty($this->id)) {
-            debugging("Needsupdate requested before insering grade category.");
+            debugging("Needsupdate requested before inserting grade category.");
             return true;
         }
 
@@ -781,25 +784,6 @@ class grade_category extends grade_object {
         }
     }
 
-    /**
-     * Returns this category's grade_item's id. This is specified for cases where we do not
-     * know an object's type, and want to get either an item's id or a category's item's id.
-     *
-     * @return int
-     */
-    function get_item_id() {
-        $this->load_grade_item();
-        return $this->grade_item->id;
-    }
-
-    /**
-     * Returns this category's parent id. A generic method shared by objects that have a parent id of some kind.
-     * @return id $parentid
-     */
-    function get_parent_id() {
-        return $this->parent;
-    }
-
     /**
      * Sets this category's parent id. A generic method shared by objects that have a parent id of some kind.
      * @param int parentid
@@ -867,6 +851,10 @@ class grade_category extends grade_object {
         $this->grade_item->set_sortorder($sortorder);
     }
 
+    /**
+     * Move this category after the given sortorder - does not change the parent
+     * @param int $sortorder to place after
+     */
     function move_after_sortorder($sortorder) {
         $this->load_grade_item();
         $this->grade_item->move_after_sortorder($sortorder);
diff --git a/lib/grade/grade_item.php b/lib/grade/grade_item.php
index 9ef65b36060..0c83228e048 100644
--- a/lib/grade/grade_item.php
+++ b/lib/grade/grade_item.php
@@ -1003,34 +1003,6 @@ class grade_item extends grade_object {
         }
     }
 
-    /**
-     * Returns this grade_item's id. This is specified for cases where we do not
-     * know an object's type, and want to get either an item's id or a category's item's id.
-     *
-     * @return int
-     */
-    function get_item_id() {
-        return $this->id;
-    }
-
-    /**
-     * Returns this item's category id. A generic method shared by objects that have a parent id of some kind.
-     * @return int $parentid
-     */
-    function get_parent_id() {
-        if ($this->is_course_item()) {
-            return false;
-
-        } else if ($this->is_category_item()) {
-
-            return $category->id;
-
-        } else {
-            return $this->categoryid;
-;
-        }
-    }
-
     /**
      * Sets this item's categoryid. A generic method shared by objects that have a parent id of some kind.
      * @param int $parentid
diff --git a/lib/simpletest/fixtures/gradetest.php b/lib/simpletest/fixtures/gradetest.php
index 33843fdaf45..9975b3fffeb 100644
--- a/lib/simpletest/fixtures/gradetest.php
+++ b/lib/simpletest/fixtures/gradetest.php
@@ -506,7 +506,7 @@ class grade_test extends UnitTestCase {
         $grade_item->grademax = 110;
         $grade_item->itemnumber = 1;
         $grade_item->idnumber = 'item id 0';
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 0 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 3;
@@ -529,7 +529,7 @@ class grade_test extends UnitTestCase {
         $grade_item->itemnumber = null;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 1 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 4;
@@ -551,7 +551,7 @@ class grade_test extends UnitTestCase {
         $grade_item->scaleid = $this->scale[0]->id;
         $grade_item->grademin = 0;
         $grade_item->grademax = $this->scalemax[0];
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 2 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 6;
@@ -567,12 +567,12 @@ class grade_test extends UnitTestCase {
         $grade_item->courseid = $this->courseid;
         $grade_item->iteminstance = $this->grade_categories[0]->id;
         $grade_item->itemname = 'unittestgradeitemcategory1';
-        $grade_item->needsupdate = true;
+        $grade_item->needsupdate = 0;
         $grade_item->itemtype = 'category';
         $grade_item->gradetype = GRADE_TYPE_VALUE;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 3 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 1;
@@ -589,10 +589,10 @@ class grade_test extends UnitTestCase {
         $grade_item->itemname = 'unittestgradeitemcategory2';
         $grade_item->itemtype = 'category';
         $grade_item->gradetype = GRADE_TYPE_VALUE;
-        $grade_item->needsupdate = true;
+        $grade_item->needsupdate = 0;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 4 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 2;
@@ -612,7 +612,7 @@ class grade_test extends UnitTestCase {
         $grade_item->needsupdate = true;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 5 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 5;
@@ -636,7 +636,7 @@ class grade_test extends UnitTestCase {
         $grade_item->grademin = 10;
         $grade_item->grademax = 120;
         $grade_item->locked = time();
-        $grade_item->iteminfo = 'Orphan Grade item used for unit testing';
+        $grade_item->iteminfo = 'Orphan Grade 6 item used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 7;
@@ -659,7 +659,7 @@ class grade_test extends UnitTestCase {
         $grade_item->scaleid = $this->scale[0]->id;
         $grade_item->grademin = 0;
         $grade_item->grademax = $this->scalemax[0];
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 7 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 9;
@@ -680,7 +680,7 @@ class grade_test extends UnitTestCase {
         $grade_item->gradetype = GRADE_TYPE_VALUE;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Grade item used for unit testing';
+        $grade_item->iteminfo = 'Grade item 8 used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 10;
@@ -702,7 +702,7 @@ class grade_test extends UnitTestCase {
         $grade_item->gradetype = GRADE_TYPE_VALUE;
         $grade_item->grademin = 0;
         $grade_item->grademax = 100;
-        $grade_item->iteminfo = 'Orphan Grade item used for unit testing';
+        $grade_item->iteminfo = 'Orphan Grade 9 item used for unit testing';
         $grade_item->timecreated = mktime();
         $grade_item->timemodified = mktime();
         $grade_item->sortorder = 8;
diff --git a/lib/simpletest/grade/simpletest/testgradecategory.php b/lib/simpletest/grade/simpletest/testgradecategory.php
index 7d2c4ec79be..d20b31b7377 100755
--- a/lib/simpletest/grade/simpletest/testgradecategory.php
+++ b/lib/simpletest/grade/simpletest/testgradecategory.php
@@ -92,6 +92,7 @@ class grade_category_test extends grade_test {
         $grade_category->insert();
 
         $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);
 
@@ -104,15 +105,77 @@ class grade_category_test extends grade_test {
         $this->assertFalse(empty($grade_category->timemodified));
     }
 
+    function test_grade_category_build_path() {
+        $grade_category = new grade_category($this->grade_categories[1]);
+        $path = grade_category::build_path($grade_category);
+        $this->assertEqual($grade_category->path, $path);
+    }
+
     function test_grade_category_update() {
         $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_item = $grade_category->get_grade_item();
+        $this->assertEqual(0, $grade_item->needsupdate);
+
         $this->assertTrue($grade_category->update());
+
         $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_qualifies_for_regrading() {
+        $grade_category = new grade_category($this->grade_categories[0]);
+        $this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
+
+        $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();
+        $parent_category = new grade_category($this->grade_categories[1]);
+        $parent_category->load_grade_item();
+
+        $this->assertEqual(0, $grade_category->grade_item->needsupdate);
+        $this->assertEqual(0, $parent_category->grade_item->needsupdate);
+
+        $this->assertTrue($grade_category->force_regrading());
+
+        $grade_category->grade_item = null;
+        $parent_category->grade_item = null;
+        $grade_category->load_grade_item();
+        $parent_category->load_grade_item();
+
+        $this->assertEqual(1, $grade_category->grade_item->needsupdate);
+        $this->assertEqual(1, $parent_category->grade_item->needsupdate);
     }
 
     function test_grade_category_delete() {
@@ -159,6 +222,98 @@ class grade_category_test extends grade_test {
         $this->assertEqual($this->grade_items[2]->id, $children_array[5]['children'][6]['object']->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_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_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_load_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);
+    }
+
+    function test_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_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_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() {
+        $category = new grade_category($this->grade_categories[0]);
+        $this->assertTrue(method_exists($category, 'set_locked'));
+        $category->load_grade_item();
+        $this->assertEqual($category->set_locked(1), $category->grade_item->set_locked(1));
+    }
+
+    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() {
+        $category = new grade_category($this->grade_categories[0]);
+        $this->assertTrue(method_exists($category, 'set_hidden'));
+        $category->load_grade_item();
+        $this->assertEqual($category->set_hidden(1), $category->grade_item->set_hidden(1));
+    }
+
     function test_grade_category_has_children() {
         $category = new grade_category($this->grade_categories[0]);
         $this->assertTrue(method_exists($category, 'has_children'));
@@ -207,7 +362,6 @@ class grade_category_test extends grade_test {
         return $grade->rawgrade;
     }
 
-/*
     function test_grade_category_apply_limit_rules() {
         $category = new grade_category();
         $grades = array(5.374, 9.4743, 2.5474, 7.3754);
@@ -224,6 +378,35 @@ class grade_category_test extends grade_test {
         $category->droplow = 0;
         $category->apply_limit_rules($grades);
         $this->assertEqual(array(9.4743), $grades);
-    }*/
+    }
+
+    function test_grade_category_set_parent() {
+        $category = new grade_category($this->grade_categories[1]);
+        $this->assertTrue(method_exists($category, 'set_parent'));
+        // TODO: implement detailed tests
+
+        $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_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() {
+        $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));
+    }
+
+    function test_grade_category_fetch_course_tree() {
+        $category = new grade_category();
+        $this->assertTrue(method_exists($category, 'fetch_course_tree'));
+        //TODO: add some tests
+    }
 }
 ?>