PageRenderTime 56ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/grade/simpletest/testgradeitem.php

http://github.com/moodle/moodle
PHP | 568 lines | 387 code | 127 blank | 54 comment | 1 complexity | 57b157db3a28a6ca4f94ea8d03ac03cb MD5 | raw file
Possible License(s): MIT, AGPL-3.0, MPL-2.0-no-copyleft-exception, LGPL-3.0, GPL-3.0, Apache-2.0, LGPL-2.1, BSD-3-Clause
  1. <?php
  2. ///////////////////////////////////////////////////////////////////////////
  3. // //
  4. // NOTICE OF COPYRIGHT //
  5. // //
  6. // Moodle - Modular Object-Oriented Dynamic Learning Environment //
  7. // http://moodle.org //
  8. // //
  9. // Copyright (C) 1999 onwards Martin Dougiamas http://dougiamas.com //
  10. // //
  11. // This program is free software; you can redistribute it and/or modify //
  12. // it under the terms of the GNU General Public License as published by //
  13. // the Free Software Foundation; either version 2 of the License, or //
  14. // (at your option) any later version. //
  15. // //
  16. // This program is distributed in the hope that it will be useful, //
  17. // but WITHOUT ANY WARRANTY; without even the implied warranty of //
  18. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
  19. // GNU General Public License for more details: //
  20. // //
  21. // http://www.gnu.org/copyleft/gpl.html //
  22. // //
  23. ///////////////////////////////////////////////////////////////////////////
  24. /**
  25. * Unit tests for grade_item object.
  26. *
  27. * @author nicolas@moodle.com
  28. * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  29. * @package moodlecore
  30. */
  31. if (!defined('MOODLE_INTERNAL')) {
  32. die('Direct access to this script is forbidden.'); /// It must be included from a Moodle page
  33. }
  34. require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
  35. Mock::generatePartial('grade_item', 'mock_grade_item_for_test_is_calculated', array('set_calculation'));
  36. @set_time_limit(0);
  37. class grade_item_test extends grade_test {
  38. function test_grade_item() {
  39. $this->sub_test_grade_item_construct();
  40. $this->sub_test_grade_item_insert();
  41. $this->sub_test_grade_item_delete();
  42. $this->sub_test_grade_item_update();
  43. $this->sub_test_grade_item_load_scale();
  44. $this->sub_test_grade_item_load_outcome();
  45. $this->sub_test_grade_item_qualifies_for_regrading();
  46. $this->sub_test_grade_item_force_regrading();
  47. $this->sub_test_grade_item_fetch();
  48. $this->sub_test_grade_item_fetch_all();
  49. $this->sub_test_grade_item_get_all_finals();
  50. $this->sub_test_grade_item_get_final();
  51. $this->sub_test_grade_item_get_sortorder();
  52. $this->sub_test_grade_item_set_sortorder();
  53. $this->sub_test_grade_item_move_after_sortorder();
  54. $this->sub_test_grade_item_get_name();
  55. $this->sub_test_grade_item_set_parent();
  56. $this->sub_test_grade_item_get_parent_category();
  57. $this->sub_test_grade_item_load_parent_category();
  58. $this->sub_test_grade_item_get_item_category();
  59. $this->sub_test_grade_item_load_item_category();
  60. $this->sub_test_grade_item_regrade_final_grades();
  61. $this->sub_test_grade_item_adjust_raw_grade();
  62. $this->sub_test_grade_item_set_locked();
  63. $this->sub_test_grade_item_is_locked();
  64. $this->sub_test_grade_item_set_hidden();
  65. $this->sub_test_grade_item_is_hidden();
  66. $this->sub_test_grade_item_is_category_item();
  67. $this->sub_test_grade_item_is_course_item();
  68. $this->sub_test_grade_item_fetch_course_item();
  69. $this->sub_test_grade_item_depends_on();
  70. $this->sub_test_grade_item_is_calculated();
  71. $this->sub_test_grade_item_set_calculation();
  72. $this->sub_test_grade_item_get_calculation();
  73. $this->sub_test_grade_item_compute();
  74. }
  75. function sub_test_grade_item_construct() {
  76. $params = new stdClass();
  77. $params->courseid = $this->courseid;
  78. $params->categoryid = $this->grade_categories[1]->id;
  79. $params->itemname = 'unittestgradeitem4';
  80. $params->itemtype = 'mod';
  81. $params->itemmodule = 'database';
  82. $params->iteminfo = 'Grade item used for unit testing';
  83. $grade_item = new grade_item($params, false);
  84. $this->assertEqual($params->courseid, $grade_item->courseid);
  85. $this->assertEqual($params->categoryid, $grade_item->categoryid);
  86. $this->assertEqual($params->itemmodule, $grade_item->itemmodule);
  87. }
  88. function sub_test_grade_item_insert() {
  89. $grade_item = new grade_item();
  90. $this->assertTrue(method_exists($grade_item, 'insert'));
  91. $grade_item->courseid = $this->courseid;
  92. $grade_item->categoryid = $this->grade_categories[1]->id;
  93. $grade_item->itemname = 'unittestgradeitem4';
  94. $grade_item->itemtype = 'mod';
  95. $grade_item->itemmodule = 'quiz';
  96. $grade_item->iteminfo = 'Grade item used for unit testing';
  97. $grade_item->insert();
  98. $last_grade_item = end($this->grade_items);
  99. $this->assertEqual($grade_item->id, $last_grade_item->id + 1);
  100. $this->assertEqual(11, $grade_item->sortorder);
  101. //keep our reference collection the same as what is in the database
  102. $this->grade_items[] = $grade_item;
  103. }
  104. function sub_test_grade_item_delete() {
  105. global $DB;
  106. $grade_item = new grade_item($this->grade_items[7]);//use a grade item not touched by previous (or future) tests
  107. $this->assertTrue(method_exists($grade_item, 'delete'));
  108. $this->assertTrue($grade_item->delete());
  109. $this->assertFalse($DB->get_record('grade_items', array('id' => $grade_item->id)));
  110. //keep our reference collection the same as the database
  111. unset($this->grade_items[7]);
  112. }
  113. function sub_test_grade_item_update() {
  114. global $DB;
  115. $grade_item = new grade_item($this->grade_items[0]);
  116. $this->assertTrue(method_exists($grade_item, 'update'));
  117. $grade_item->iteminfo = 'Updated info for this unittest grade_item';
  118. $this->assertTrue($grade_item->update());
  119. $grade_item->grademin = 14;
  120. $this->assertTrue($grade_item->qualifies_for_regrading());
  121. $this->assertTrue($grade_item->update());
  122. $iteminfo = $DB->get_field('grade_items', 'iteminfo', array('id' => $this->grade_items[0]->id));
  123. $this->assertEqual($grade_item->iteminfo, $iteminfo);
  124. }
  125. function sub_test_grade_item_load_scale() {
  126. $grade_item = new grade_item($this->grade_items[2]);
  127. $this->assertTrue(method_exists($grade_item, 'load_scale'));
  128. $scale = $grade_item->load_scale();
  129. $this->assertFalse(empty($grade_item->scale));
  130. $this->assertEqual($scale->id, $this->grade_items[2]->scaleid);
  131. }
  132. function sub_test_grade_item_load_outcome() {
  133. $grade_item = new grade_item($this->grade_items[0]);
  134. $this->assertTrue(method_exists($grade_item, 'load_outcome'));
  135. //TODO: add tests
  136. }
  137. function sub_test_grade_item_qualifies_for_regrading() {
  138. $grade_item = new grade_item($this->grade_items[1]);//use a grade item not touched by previous tests
  139. $this->assertTrue(method_exists($grade_item, 'qualifies_for_regrading'));
  140. $this->assertFalse($grade_item->qualifies_for_regrading());
  141. $grade_item->iteminfo = 'Updated info for this unittest grade_item';
  142. $this->assertFalse($grade_item->qualifies_for_regrading());
  143. $grade_item->grademin = 14;
  144. $this->assertTrue($grade_item->qualifies_for_regrading());
  145. }
  146. function sub_test_grade_item_force_regrading() {
  147. $grade_item = new grade_item($this->grade_items[2]);//use a grade item not touched by previous tests
  148. $this->assertTrue(method_exists($grade_item, 'force_regrading'));
  149. $this->assertEqual(0, $grade_item->needsupdate);
  150. $grade_item->force_regrading();
  151. $this->assertEqual(1, $grade_item->needsupdate);
  152. $grade_item->update_from_db();
  153. $this->assertEqual(1, $grade_item->needsupdate);
  154. }
  155. function sub_test_grade_item_fetch() {
  156. $grade_item = new grade_item();
  157. $this->assertTrue(method_exists($grade_item, 'fetch'));
  158. //not using $this->grade_items[0] as it's iteminfo was modified by sub_test_grade_item_qualifies_for_regrading()
  159. $grade_item = grade_item::fetch(array('id'=>$this->grade_items[1]->id));
  160. $this->assertEqual($this->grade_items[1]->id, $grade_item->id);
  161. $this->assertEqual($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
  162. $grade_item = grade_item::fetch(array('itemtype'=>$this->grade_items[1]->itemtype, 'itemmodule'=>$this->grade_items[1]->itemmodule));
  163. $this->assertEqual($this->grade_items[1]->id, $grade_item->id);
  164. $this->assertEqual($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
  165. }
  166. function sub_test_grade_item_fetch_all() {
  167. $grade_item = new grade_item();
  168. $this->assertTrue(method_exists($grade_item, 'fetch_all'));
  169. $grade_items = grade_item::fetch_all(array('courseid'=>$this->courseid));
  170. $this->assertEqual(count($this->grade_items), count($grade_items)-1);//-1 to account for the course grade item
  171. }
  172. // Retrieve all final scores for a given grade_item.
  173. function sub_test_grade_item_get_all_finals() {
  174. $grade_item = new grade_item($this->grade_items[0]);
  175. $this->assertTrue(method_exists($grade_item, 'get_final'));
  176. $final_grades = $grade_item->get_final();
  177. $this->assertEqual(3, count($final_grades));
  178. }
  179. // Retrieve all final scores for a specific userid.
  180. function sub_test_grade_item_get_final() {
  181. $grade_item = new grade_item($this->grade_items[0]);
  182. $this->assertTrue(method_exists($grade_item, 'get_final'));
  183. $final_grade = $grade_item->get_final($this->userid);
  184. $this->assertEqual($this->grade_grades[0]->finalgrade, $final_grade->finalgrade);
  185. }
  186. function sub_test_grade_item_get_sortorder() {
  187. $grade_item = new grade_item($this->grade_items[0]);
  188. $this->assertTrue(method_exists($grade_item, 'get_sortorder'));
  189. $sortorder = $grade_item->get_sortorder();
  190. $this->assertEqual($this->grade_items[0]->sortorder, $sortorder);
  191. }
  192. function sub_test_grade_item_set_sortorder() {
  193. $grade_item = new grade_item($this->grade_items[0]);
  194. $this->assertTrue(method_exists($grade_item, 'set_sortorder'));
  195. $grade_item->set_sortorder(999);
  196. $this->assertEqual($grade_item->sortorder, 999);
  197. }
  198. function sub_test_grade_item_move_after_sortorder() {
  199. $grade_item = new grade_item($this->grade_items[0]);
  200. $this->assertTrue(method_exists($grade_item, 'move_after_sortorder'));
  201. $grade_item->move_after_sortorder(5);
  202. $this->assertEqual($grade_item->sortorder, 6);
  203. $grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
  204. $this->assertEqual($grade_item->sortorder, 6);
  205. $after = grade_item::fetch(array('id'=>$this->grade_items[6]->id));
  206. $this->assertEqual($after->sortorder, 8);
  207. }
  208. function sub_test_grade_item_get_name() {
  209. $grade_item = new grade_item($this->grade_items[0]);
  210. $this->assertTrue(method_exists($grade_item, 'get_name'));
  211. $name = $grade_item->get_name();
  212. $this->assertEqual($this->grade_items[0]->itemname, $name);
  213. }
  214. function sub_test_grade_item_set_parent() {
  215. $grade_item = new grade_item($this->grade_items[0]);
  216. $this->assertTrue(method_exists($grade_item, 'set_parent'));
  217. $old = $grade_item->get_parent_category();
  218. $new = new grade_category($this->grade_categories[3]);
  219. $new_item = $new->get_grade_item();
  220. $this->assertTrue($grade_item->set_parent($new->id));
  221. $new_item->update_from_db();
  222. $grade_item->update_from_db();
  223. $this->assertEqual($grade_item->categoryid, $new->id);
  224. }
  225. function sub_test_grade_item_get_parent_category() {
  226. $grade_item = new grade_item($this->grade_items[0]);
  227. $this->assertTrue(method_exists($grade_item, 'get_parent_category'));
  228. $category = $grade_item->get_parent_category();
  229. $this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
  230. }
  231. function sub_test_grade_item_load_parent_category() {
  232. $grade_item = new grade_item($this->grade_items[0]);
  233. $this->assertTrue(method_exists($grade_item, 'load_parent_category'));
  234. $category = $grade_item->load_parent_category();
  235. $this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
  236. $this->assertEqual($this->grade_categories[1]->fullname, $grade_item->parent_category->fullname);
  237. }
  238. function sub_test_grade_item_get_item_category() {
  239. $grade_item = new grade_item($this->grade_items[3]);
  240. $this->assertTrue(method_exists($grade_item, 'get_item_category'));
  241. $category = $grade_item->get_item_category();
  242. $this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
  243. }
  244. function sub_test_grade_item_load_item_category() {
  245. $grade_item = new grade_item($this->grade_items[3]);
  246. $this->assertTrue(method_exists($grade_item, 'load_item_category'));
  247. $category = $grade_item->load_item_category();
  248. $this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
  249. $this->assertEqual($this->grade_categories[0]->fullname, $grade_item->item_category->fullname);
  250. }
  251. // Test update of all final grades
  252. function sub_test_grade_item_regrade_final_grades() {
  253. $grade_item = new grade_item($this->grade_items[0]);
  254. $this->assertTrue(method_exists($grade_item, 'regrade_final_grades'));
  255. $this->assertEqual(true, $grade_item->regrade_final_grades());
  256. //TODO: add more tests
  257. }
  258. // Test the adjust_raw_grade method
  259. function sub_test_grade_item_adjust_raw_grade() {
  260. $grade_item = new grade_item($this->grade_items[0]);
  261. $this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
  262. $grade_raw = new stdClass();
  263. $grade_raw->rawgrade = 40;
  264. $grade_raw->grademax = 100;
  265. $grade_raw->grademin = 0;
  266. $grade_item->multfactor = 1;
  267. $grade_item->plusfactor = 0;
  268. $grade_item->grademax = 50;
  269. $grade_item->grademin = 0;
  270. $original_grade_raw = clone($grade_raw);
  271. $original_grade_item = clone($grade_item);
  272. $this->assertEqual(20, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  273. // Try a larger maximum grade
  274. $grade_item->grademax = 150;
  275. $grade_item->grademin = 0;
  276. $this->assertEqual(60, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  277. // Try larger minimum grade
  278. $grade_item->grademin = 50;
  279. $this->assertEqual(90, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  280. // Rescaling from a small scale (0-50) to a larger scale (0-100)
  281. $grade_raw->grademax = 50;
  282. $grade_raw->grademin = 0;
  283. $grade_item->grademax = 100;
  284. $grade_item->grademin = 0;
  285. $this->assertEqual(80, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  286. // Rescaling from a small scale (0-50) to a larger scale with offset (40-100)
  287. $grade_item->grademax = 100;
  288. $grade_item->grademin = 40;
  289. $this->assertEqual(88, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  290. // Try multfactor and plusfactor
  291. $grade_raw = clone($original_grade_raw);
  292. $grade_item = clone($original_grade_item);
  293. $grade_item->multfactor = 1.23;
  294. $grade_item->plusfactor = 3;
  295. $this->assertEqual(27.6, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
  296. // Try multfactor below 0 and a negative plusfactor
  297. $grade_raw = clone($original_grade_raw);
  298. $grade_item = clone($original_grade_item);
  299. $grade_item->multfactor = 0.23;
  300. $grade_item->plusfactor = -3;
  301. $this->assertEqual(round(1.6), round($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax)));
  302. }
  303. // Test locking of grade items
  304. function sub_test_grade_item_set_locked() {
  305. //getting a grade_item from the DB as set_locked() will fail if the grade items needs to be updated
  306. //also needs to have at least one grade_grade or $grade_item->get_final(1) returns null
  307. //$grade_item = new grade_item($this->grade_items[8]);
  308. $grade_item = grade_item::fetch(array('id'=>$this->grade_items[8]->id));
  309. $this->assertTrue(method_exists($grade_item, 'set_locked'));
  310. $grade_grade = new grade_grade($grade_item->get_final(1));
  311. $this->assertTrue(empty($grade_item->locked));//not locked
  312. $this->assertTrue(empty($grade_grade->locked));//not locked
  313. $this->assertTrue($grade_item->set_locked(true, true, false));
  314. $grade_grade = new grade_grade($grade_item->get_final(1));
  315. $this->assertFalse(empty($grade_item->locked));//locked
  316. $this->assertFalse(empty($grade_grade->locked)); // individual grades should be locked too
  317. $this->assertTrue($grade_item->set_locked(false, true, false));
  318. $grade = new grade_grade($grade_item->get_final(1));
  319. $this->assertTrue(empty($grade_item->locked));
  320. $this->assertTrue(empty($grade->locked)); // individual grades should be unlocked too
  321. }
  322. function sub_test_grade_item_is_locked() {
  323. $grade_item = new grade_item($this->grade_items[10]);
  324. $this->assertTrue(method_exists($grade_item, 'is_locked'));
  325. $this->assertFalse($grade_item->is_locked());
  326. $this->assertFalse($grade_item->is_locked(1));
  327. $this->assertTrue($grade_item->set_locked(true, true, false));
  328. $this->assertTrue($grade_item->is_locked());
  329. $this->assertTrue($grade_item->is_locked(1));
  330. }
  331. // Test hiding of grade items
  332. function sub_test_grade_item_set_hidden() {
  333. $grade_item = new grade_item($this->grade_items[0]);
  334. $this->assertTrue(method_exists($grade_item, 'set_hidden'));
  335. $grade = new grade_grade($grade_item->get_final(1));
  336. $this->assertEqual(0, $grade_item->hidden);
  337. $this->assertEqual(0, $grade->hidden);
  338. $grade_item->set_hidden(666, true);
  339. $grade = new grade_grade($grade_item->get_final(1));
  340. $this->assertEqual(666, $grade_item->hidden);
  341. $this->assertEqual(666, $grade->hidden);
  342. }
  343. function sub_test_grade_item_is_hidden() {
  344. $grade_item = new grade_item($this->grade_items[0]);
  345. $this->assertTrue(method_exists($grade_item, 'is_hidden'));
  346. $this->assertFalse($grade_item->is_hidden());
  347. $this->assertFalse($grade_item->is_hidden(1));
  348. $grade_item->set_hidden(1);
  349. $this->assertTrue($grade_item->is_hidden());
  350. $this->assertTrue($grade_item->is_hidden(1));
  351. $grade_item->set_hidden(666);
  352. $this->assertFalse($grade_item->is_hidden());
  353. $this->assertFalse($grade_item->is_hidden(1));
  354. $grade_item->set_hidden(time()+666);
  355. $this->assertTrue($grade_item->is_hidden());
  356. $this->assertTrue($grade_item->is_hidden(1));
  357. }
  358. function sub_test_grade_item_is_category_item() {
  359. $grade_item = new grade_item($this->grade_items[3]);
  360. $this->assertTrue(method_exists($grade_item, 'is_category_item'));
  361. $this->assertTrue($grade_item->is_category_item());
  362. }
  363. function sub_test_grade_item_is_course_item() {
  364. $grade_item = grade_item::fetch_course_item($this->courseid);
  365. $this->assertTrue(method_exists($grade_item, 'is_course_item'));
  366. $this->assertTrue($grade_item->is_course_item());
  367. }
  368. function sub_test_grade_item_fetch_course_item() {
  369. $grade_item = grade_item::fetch_course_item($this->courseid);
  370. $this->assertTrue(method_exists($grade_item, 'fetch_course_item'));
  371. $this->assertTrue($grade_item->itemtype, 'course');
  372. }
  373. function sub_test_grade_item_depends_on() {
  374. $grade_item = new grade_item($this->grade_items[1]);
  375. // calculated grade dependency
  376. $deps = $grade_item->depends_on();
  377. sort($deps, SORT_NUMERIC); // for comparison
  378. $this->assertEqual(array($this->grade_items[0]->id), $deps);
  379. // simulate depends on returns none when locked
  380. $grade_item->locked = time();
  381. $grade_item->update();
  382. $deps = $grade_item->depends_on();
  383. sort($deps, SORT_NUMERIC); // for comparison
  384. $this->assertEqual(array(), $deps);
  385. // category dependency
  386. $grade_item = new grade_item($this->grade_items[3]);
  387. $deps = $grade_item->depends_on();
  388. sort($deps, SORT_NUMERIC); // for comparison
  389. $res = array($this->grade_items[4]->id, $this->grade_items[5]->id);
  390. $this->assertEqual($res, $deps);
  391. }
  392. function sub_test_grade_item_is_calculated() {
  393. $grade_item = new mock_grade_item_for_test_is_calculated($this);
  394. $grade_item->set_properties($grade_item, $this->grade_items[1]);
  395. $this->assertTrue(method_exists($grade_item, 'is_calculated'));
  396. $grade_itemsource = new grade_item($this->grade_items[0]);
  397. $normalizedformula = str_replace("[[$grade_itemsource->idnumber]]", "##gi$grade_itemsource->id##", $this->grade_items[1]->calculation);
  398. $grade_item->expectOnce('set_calculation', array($grade_item->calculation));
  399. $grade_item->setReturnValue('set_calculation', $normalizedformula);
  400. $this->assertTrue($grade_item->is_calculated());
  401. }
  402. function sub_test_grade_item_set_calculation() {
  403. $grade_item = new grade_item($this->grade_items[1]);
  404. $this->assertTrue(method_exists($grade_item, 'set_calculation'));
  405. $grade_itemsource = new grade_item($this->grade_items[0]);
  406. $grade_item->set_calculation('=[['.$grade_itemsource->idnumber.']]');
  407. $this->assertTrue(!empty($grade_item->needsupdate));
  408. $this->assertEqual('=##gi'.$grade_itemsource->id.'##', $grade_item->calculation);
  409. }
  410. function sub_test_grade_item_get_calculation() {
  411. $grade_item = new grade_item($this->grade_items[1]);
  412. $this->assertTrue(method_exists($grade_item, 'get_calculation'));
  413. $grade_itemsource = new grade_item($this->grade_items[0]);
  414. $denormalizedformula = str_replace('##gi'.$grade_itemsource->id.'##', '[['.$grade_itemsource->idnumber.']]', $this->grade_items[1]->calculation);
  415. $formula = $grade_item->get_calculation();
  416. $this->assertTrue(!empty($grade_item->needsupdate));
  417. $this->assertEqual($denormalizedformula, $formula);
  418. }
  419. function sub_test_grade_item_compute() {
  420. $grade_item = grade_item::fetch(array('id'=>$this->grade_items[1]->id));
  421. $this->assertTrue(method_exists($grade_item, 'compute'));
  422. //check the grade_grades in the array match those in the DB then delete $this->grade_items[1]'s grade_grades
  423. $this->grade_grades[3] = grade_grade::fetch(array('id'=>$this->grade_grades[3]->id));
  424. $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[3]->id));
  425. $grade_grade->delete();
  426. $this->grade_grades[4] = grade_grade::fetch(array('id'=>$this->grade_grades[4]->id));
  427. $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[4]->id));
  428. $grade_grade->delete();
  429. $this->grade_grades[5] = grade_grade::fetch(array('id'=>$this->grade_grades[5]->id));
  430. $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[5]->id));
  431. $grade_grade->delete();
  432. //recalculate the grades (its a calculation so pulls values from other grade_items) and reinsert them
  433. $grade_item->compute();
  434. $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[3]->userid, 'itemid'=>$this->grade_grades[3]->itemid));
  435. $this->assertEqual($this->grade_grades[3]->finalgrade, $grade_grade->finalgrade);
  436. $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[4]->userid, 'itemid'=>$this->grade_grades[4]->itemid));
  437. $this->assertEqual($this->grade_grades[4]->finalgrade, $grade_grade->finalgrade);
  438. $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[5]->userid, 'itemid'=>$this->grade_grades[5]->itemid));
  439. $this->assertEqual($this->grade_grades[5]->finalgrade, $grade_grade->finalgrade);
  440. }
  441. }