PageRenderTime 42ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/trunk/MoodleWebRole/lib/grade/simpletest/testgradecategory.php

#
PHP | 471 lines | 322 code | 82 blank | 67 comment | 1 complexity | 7552eeea561fbbd12e95c045a4998b72 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, LGPL-2.0, GPL-2.0
  1. <?php // $Id: testgradecategory.php,v 1.7.2.3 2009/04/29 13:44:17 skodak Exp $
  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_category 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. class grade_category_test extends grade_test {
  36. function test_grade_category_construct() {
  37. $course_category = grade_category::fetch_course_category($this->courseid);
  38. $params = new stdClass();
  39. $params->courseid = $this->courseid;
  40. $params->fullname = 'unittestcategory4';
  41. $grade_category = new grade_category($params, false);
  42. $grade_category->insert();
  43. $this->assertEqual($params->courseid, $grade_category->courseid);
  44. $this->assertEqual($params->fullname, $grade_category->fullname);
  45. $this->assertEqual(2, $grade_category->depth);
  46. $this->assertEqual("/$course_category->id/$grade_category->id/", $grade_category->path);
  47. $parentpath = $grade_category->path;
  48. // Test a child category
  49. $params->parent = $grade_category->id;
  50. $params->fullname = 'unittestcategory5';
  51. $grade_category = new grade_category($params, false);
  52. $grade_category->insert();
  53. $this->assertEqual(3, $grade_category->depth);
  54. $this->assertEqual($parentpath.$grade_category->id."/", $grade_category->path);
  55. $parentpath = $grade_category->path;
  56. // Test a third depth category
  57. $params->parent = $grade_category->id;
  58. $params->fullname = 'unittestcategory6';
  59. $grade_category = new grade_category($params, false);
  60. $grade_category->insert();
  61. $this->assertEqual(4, $grade_category->depth);
  62. $this->assertEqual($parentpath.$grade_category->id."/", $grade_category->path);
  63. }
  64. function test_grade_category_build_path() {
  65. $grade_category = new grade_category($this->grade_categories[1]);
  66. $this->assertTrue(method_exists($grade_category, 'build_path'));
  67. $path = grade_category::build_path($grade_category);
  68. $this->assertEqual($grade_category->path, $path);
  69. }
  70. function test_grade_category_fetch() {
  71. $grade_category = new grade_category();
  72. $this->assertTrue(method_exists($grade_category, 'fetch'));
  73. $grade_category = grade_category::fetch(array('id'=>$this->grade_categories[0]->id));
  74. $this->assertEqual($this->grade_categories[0]->id, $grade_category->id);
  75. $this->assertEqual($this->grade_categories[0]->fullname, $grade_category->fullname);
  76. }
  77. function test_grade_category_fetch_all() {
  78. $grade_category = new grade_category();
  79. $this->assertTrue(method_exists($grade_category, 'fetch_all'));
  80. $grade_categories = grade_category::fetch_all(array('courseid'=>$this->courseid));
  81. $this->assertEqual(count($this->grade_categories), count($grade_categories)-1);
  82. }
  83. function test_grade_category_update() {
  84. $grade_category = new grade_category($this->grade_categories[0]);
  85. $this->assertTrue(method_exists($grade_category, 'update'));
  86. $grade_category->fullname = 'Updated info for this unittest grade_category';
  87. $grade_category->path = null; // path must be recalculated if missing
  88. $grade_category->depth = null;
  89. $grade_category->aggregation = GRADE_AGGREGATE_MAX; // should force regrading
  90. $grade_item = $grade_category->get_grade_item();
  91. $this->assertEqual(0, $grade_item->needsupdate);
  92. $this->assertTrue($grade_category->update());
  93. $fullname = get_field('grade_categories', 'fullname', 'id', $this->grade_categories[0]->id);
  94. $this->assertEqual($grade_category->fullname, $fullname);
  95. $path = get_field('grade_categories', 'path', 'id', $this->grade_categories[0]->id);
  96. $this->assertEqual($grade_category->path, $path);
  97. $depth = get_field('grade_categories', 'depth', 'id', $this->grade_categories[0]->id);
  98. $this->assertEqual($grade_category->depth, $depth);
  99. $grade_item = $grade_category->get_grade_item();
  100. $this->assertEqual(1, $grade_item->needsupdate);
  101. }
  102. function test_grade_category_delete() {
  103. $grade_category = new grade_category($this->grade_categories[0]);
  104. $this->assertTrue(method_exists($grade_category, 'delete'));
  105. $this->assertTrue($grade_category->delete());
  106. $this->assertFalse(get_record('grade_categories', 'id', $grade_category->id));
  107. }
  108. function test_grade_category_insert() {
  109. $course_category = grade_category::fetch_course_category($this->courseid);
  110. $grade_category = new grade_category();
  111. $this->assertTrue(method_exists($grade_category, 'insert'));
  112. $grade_category->fullname = 'unittestcategory4';
  113. $grade_category->courseid = $this->courseid;
  114. $grade_category->aggregation = GRADE_AGGREGATE_MEAN;
  115. $grade_category->aggregateonlygraded = 1;
  116. $grade_category->keephigh = 100;
  117. $grade_category->droplow = 10;
  118. $grade_category->hidden = 0;
  119. $grade_category->parent = $this->grade_categories[0]->id;
  120. $grade_category->insert();
  121. $this->assertEqual('/'.$course_category->id.'/'.$this->grade_categories[0]->id.'/'.$grade_category->id.'/', $grade_category->path);
  122. $this->assertEqual(3, $grade_category->depth);
  123. $last_grade_category = end($this->grade_categories);
  124. $this->assertFalse(empty($grade_category->grade_item));
  125. $this->assertEqual($grade_category->id, $grade_category->grade_item->iteminstance);
  126. $this->assertEqual('category', $grade_category->grade_item->itemtype);
  127. $this->assertEqual($grade_category->id, $last_grade_category->id + 1);
  128. $this->assertFalse(empty($grade_category->timecreated));
  129. $this->assertFalse(empty($grade_category->timemodified));
  130. }
  131. function test_grade_category_insert_course_category() {
  132. $grade_category = new grade_category();
  133. $this->assertTrue(method_exists($grade_category, 'insert_course_category'));
  134. $id = $grade_category->insert_course_category($this->courseid);
  135. $this->assertNotNull($id);
  136. $this->assertEqual('?', $grade_category->fullname);
  137. $this->assertEqual(GRADE_AGGREGATE_WEIGHTED_MEAN2, $grade_category->aggregation);
  138. $this->assertEqual("/$id/", $grade_category->path);
  139. $this->assertEqual(1, $grade_category->depth);
  140. $this->assertNull($grade_category->parent);
  141. }
  142. function test_grade_category_qualifies_for_regrading() {
  143. $grade_category = new grade_category($this->grade_categories[0]);
  144. $this->assertTrue(method_exists($grade_category, 'qualifies_for_regrading'));
  145. $this->assertFalse($grade_category->qualifies_for_regrading());
  146. $grade_category->aggregation = GRADE_AGGREGATE_MAX;
  147. $this->assertTrue($grade_category->qualifies_for_regrading());
  148. $grade_category = new grade_category($this->grade_categories[0]);
  149. $grade_category->droplow = 99;
  150. $this->assertTrue($grade_category->qualifies_for_regrading());
  151. $grade_category = new grade_category($this->grade_categories[0]);
  152. $grade_category->keephigh = 99;
  153. $this->assertTrue($grade_category->qualifies_for_regrading());
  154. }
  155. function test_grade_category_force_regrading() {
  156. $grade_category = new grade_category($this->grade_categories[1]);
  157. $this->assertTrue(method_exists($grade_category, 'force_regrading'));
  158. $grade_category->load_grade_item();
  159. $this->assertEqual(0, $grade_category->grade_item->needsupdate);
  160. $grade_category->force_regrading();
  161. $grade_category->grade_item = null;
  162. $grade_category->load_grade_item();
  163. $this->assertEqual(1, $grade_category->grade_item->needsupdate);
  164. }
  165. /*
  166. * I am disabling this test until we implement proper mock objects. This is meant
  167. * to be a private method called from within a grade_item method.
  168. function test_grade_category_generate_grades() {
  169. $category = new grade_category($this->grade_categories[3]);
  170. $this->assertTrue(method_exists($category, 'generate_grades'));
  171. $category->load_grade_item();
  172. $grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
  173. $this->assertFalse($grades);
  174. $category->generate_grades();
  175. $grades = get_records('grade_grades', 'itemid', $category->grade_item->id);
  176. $this->assertEqual(3, count($grades));
  177. $rawvalues = array();
  178. foreach ($grades as $grade) {
  179. $this->assertWithinMargin($grade->rawgrade, $grade->rawgrademin, $grade->rawgrademax);
  180. $rawvalues[] = (int)$grade->rawgrade;
  181. }
  182. sort($rawvalues);
  183. // calculated mean results
  184. $this->assertEqual($rawvalues, array(20,50,100));
  185. }
  186. */
  187. function test_grade_category_aggregate_grades() {
  188. $category = new grade_category($this->grade_categories[0]);
  189. $this->assertTrue(method_exists($category, 'aggregate_grades'));
  190. // tested above in test_grade_category_generate_grades()
  191. }
  192. function test_grade_category_apply_limit_rules() {
  193. $items[$this->grade_items[0]->id] = new grade_item($this->grade_items[0], false);
  194. $items[$this->grade_items[1]->id] = new grade_item($this->grade_items[1], false);
  195. $items[$this->grade_items[2]->id] = new grade_item($this->grade_items[2], false);
  196. $items[$this->grade_items[4]->id] = new grade_item($this->grade_items[4], false);
  197. $category = new grade_category();
  198. $category->droplow = 2;
  199. $grades = array($this->grade_items[0]->id=>5.374,
  200. $this->grade_items[1]->id=>9.4743,
  201. $this->grade_items[2]->id=>2.5474,
  202. $this->grade_items[4]->id=>7.3754);
  203. $category->apply_limit_rules($grades, $items);
  204. $this->assertEqual(count($grades), 2);
  205. $this->assertEqual($grades[$this->grade_items[1]->id], 9.4743);
  206. $this->assertEqual($grades[$this->grade_items[4]->id], 7.3754);
  207. $category = new grade_category();
  208. $category->keephigh = 1;
  209. $category->droplow = 0;
  210. $grades = array($this->grade_items[0]->id=>5.374,
  211. $this->grade_items[1]->id=>9.4743,
  212. $this->grade_items[2]->id=>2.5474,
  213. $this->grade_items[4]->id=>7.3754);
  214. $category->apply_limit_rules($grades, $items);
  215. $this->assertEqual(count($grades), 1);
  216. $grade = reset($grades);
  217. $this->assertEqual(9.4743, $grade);
  218. $category = new grade_category();
  219. $category->droplow = 2;
  220. $category->aggregation = GRADE_AGGREGATE_SUM;
  221. $items[$this->grade_items[2]->id]->aggregationcoef = 1;
  222. $grades = array($this->grade_items[0]->id=>5.374,
  223. $this->grade_items[1]->id=>9.4743,
  224. $this->grade_items[2]->id=>2.5474,
  225. $this->grade_items[4]->id=>7.3754);
  226. $category->apply_limit_rules($grades, $items);
  227. $this->assertEqual(count($grades), 2);
  228. $this->assertEqual($grades[$this->grade_items[1]->id], 9.4743);
  229. $this->assertEqual($grades[$this->grade_items[2]->id], 2.5474);
  230. $category = new grade_category();
  231. $category->keephigh = 1;
  232. $category->droplow = 0;
  233. $category->aggregation = GRADE_AGGREGATE_SUM;
  234. $items[$this->grade_items[2]->id]->aggregationcoef = 1;
  235. $grades = array($this->grade_items[0]->id=>5.374,
  236. $this->grade_items[1]->id=>9.4743,
  237. $this->grade_items[2]->id=>2.5474,
  238. $this->grade_items[4]->id=>7.3754);
  239. $category->apply_limit_rules($grades, $items);
  240. $this->assertEqual(count($grades), 2);
  241. $this->assertEqual($grades[$this->grade_items[1]->id], 9.4743);
  242. $this->assertEqual($grades[$this->grade_items[2]->id], 2.5474);
  243. }
  244. /**
  245. * TODO implement
  246. */
  247. function test_grade_category_is_aggregationcoef_used() {
  248. }
  249. function test_grade_category_fetch_course_tree() {
  250. $category = new grade_category();
  251. $this->assertTrue(method_exists($category, 'fetch_course_tree'));
  252. //TODO: add some tests
  253. }
  254. function test_grade_category_get_children() {
  255. $course_category = grade_category::fetch_course_category($this->courseid);
  256. $category = new grade_category($this->grade_categories[0]);
  257. $this->assertTrue(method_exists($category, 'get_children'));
  258. $children_array = $category->get_children(0);
  259. $this->assertTrue(is_array($children_array));
  260. $this->assertFalse(empty($children_array[2]));
  261. $this->assertFalse(empty($children_array[2]['object']));
  262. $this->assertFalse(empty($children_array[2]['children']));
  263. $this->assertEqual($this->grade_categories[1]->id, $children_array[2]['object']->id);
  264. $this->assertEqual($this->grade_categories[2]->id, $children_array[5]['object']->id);
  265. $this->assertEqual($this->grade_items[0]->id, $children_array[2]['children'][3]['object']->id);
  266. $this->assertEqual($this->grade_items[1]->id, $children_array[2]['children'][4]['object']->id);
  267. $this->assertEqual($this->grade_items[2]->id, $children_array[5]['children'][6]['object']->id);
  268. }
  269. function test_grade_category_load_grade_item() {
  270. $category = new grade_category($this->grade_categories[0]);
  271. $this->assertTrue(method_exists($category, 'load_grade_item'));
  272. $this->assertEqual(null, $category->grade_item);
  273. $category->load_grade_item();
  274. $this->assertEqual($this->grade_items[3]->id, $category->grade_item->id);
  275. }
  276. function test_grade_category_get_grade_item() {
  277. $category = new grade_category($this->grade_categories[0]);
  278. $this->assertTrue(method_exists($category, 'get_grade_item'));
  279. $grade_item = $category->get_grade_item();
  280. $this->assertEqual($this->grade_items[3]->id, $grade_item->id);
  281. }
  282. function test_grade_category_load_parent_category() {
  283. $category = new grade_category($this->grade_categories[1]);
  284. $this->assertTrue(method_exists($category, 'load_parent_category'));
  285. $this->assertEqual(null, $category->parent_category);
  286. $category->load_parent_category();
  287. $this->assertEqual($this->grade_categories[0]->id, $category->parent_category->id);
  288. }
  289. function test_grade_category_get_parent_category() {
  290. $category = new grade_category($this->grade_categories[1]);
  291. $this->assertTrue(method_exists($category, 'get_parent_category'));
  292. $parent_category = $category->get_parent_category();
  293. $this->assertEqual($this->grade_categories[0]->id, $parent_category->id);
  294. }
  295. function test_grade_category_get_name() {
  296. $category = new grade_category($this->grade_categories[0]);
  297. $this->assertTrue(method_exists($category, 'get_name'));
  298. $this->assertEqual($this->grade_categories[0]->fullname, $category->get_name());
  299. }
  300. function test_grade_category_set_parent() {
  301. $category = new grade_category($this->grade_categories[1]);
  302. $this->assertTrue(method_exists($category, 'set_parent'));
  303. // TODO: implement detailed tests
  304. $course_category = grade_category::fetch_course_category($this->courseid);
  305. $this->assertTrue($category->set_parent($course_category->id));
  306. $this->assertEqual($course_category->id, $category->parent);
  307. }
  308. function test_grade_category_get_final() {
  309. $category = new grade_category($this->grade_categories[0]);
  310. $this->assertTrue(method_exists($category, 'get_final'));
  311. $category->load_grade_item();
  312. $this->assertEqual($category->get_final(), $category->grade_item->get_final());
  313. }
  314. function test_grade_category_get_sortorder() {
  315. $category = new grade_category($this->grade_categories[0]);
  316. $this->assertTrue(method_exists($category, 'get_sortorder'));
  317. $category->load_grade_item();
  318. $this->assertEqual($category->get_sortorder(), $category->grade_item->get_sortorder());
  319. }
  320. function test_grade_category_set_sortorder() {
  321. $category = new grade_category($this->grade_categories[0]);
  322. $this->assertTrue(method_exists($category, 'set_sortorder'));
  323. $category->load_grade_item();
  324. $this->assertEqual($category->set_sortorder(10), $category->grade_item->set_sortorder(10));
  325. }
  326. function test_grade_category_move_after_sortorder() {
  327. $category = new grade_category($this->grade_categories[0]);
  328. $this->assertTrue(method_exists($category, 'move_after_sortorder'));
  329. $category->load_grade_item();
  330. $this->assertEqual($category->move_after_sortorder(10), $category->grade_item->move_after_sortorder(10));
  331. }
  332. function test_grade_category_is_course_category() {
  333. $category = grade_category::fetch_course_category($this->courseid);
  334. $this->assertTrue(method_exists($category, 'is_course_category'));
  335. $this->assertTrue($category->is_course_category());
  336. }
  337. function test_grade_category_fetch_course_category() {
  338. $category = new grade_category();
  339. $this->assertTrue(method_exists($category, 'fetch_course_category'));
  340. $category = grade_category::fetch_course_category($this->courseid);
  341. $this->assertTrue(empty($category->parent));
  342. }
  343. /**
  344. * TODO implement
  345. */
  346. function test_grade_category_is_editable() {
  347. }
  348. function test_grade_category_is_locked() {
  349. $category = new grade_category($this->grade_categories[0]);
  350. $this->assertTrue(method_exists($category, 'is_locked'));
  351. $category->load_grade_item();
  352. $this->assertEqual($category->is_locked(), $category->grade_item->is_locked());
  353. }
  354. function test_grade_category_set_locked() {
  355. $category = new grade_category($this->grade_categories[0]);
  356. $this->assertTrue(method_exists($category, 'set_locked'));
  357. $this->assertTrue($category->set_locked(1));
  358. }
  359. function test_grade_category_is_hidden() {
  360. $category = new grade_category($this->grade_categories[0]);
  361. $this->assertTrue(method_exists($category, 'is_hidden'));
  362. $category->load_grade_item();
  363. $this->assertEqual($category->is_hidden(), $category->grade_item->is_hidden());
  364. }
  365. function test_grade_category_set_hidden() {
  366. $category = new grade_category($this->grade_categories[0]);
  367. $this->assertTrue(method_exists($category, 'set_hidden'));
  368. $category->set_hidden(1);
  369. $category->load_grade_item();
  370. $this->assertEqual(true, $category->grade_item->is_hidden());
  371. }
  372. function generate_random_raw_grade($item, $userid) {
  373. $grade = new grade_grade();
  374. $grade->itemid = $item->id;
  375. $grade->userid = $userid;
  376. $grade->grademin = 0;
  377. $grade->grademax = 1;
  378. $valuetype = "grade$item->gradetype";
  379. $grade->rawgrade = rand(0, 1000) / 1000;
  380. $grade->insert();
  381. return $grade->rawgrade;
  382. }
  383. }
  384. ?>