mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-03-14 04:30:15 +01:00
Code Issues Projects Releases Wiki Activity

MDL-53452 competencies: Update unit tests now we have removed suggest feature.

Browse Source
This commit is contained in:
Damyon Wiese 2016-03-21 12:23:47 +08:00 committed by Frederic Massart
parent d22a1d3bbf
commit fdd85edef9
6 changed files with 82 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
admin/tool/lp/classes/api.php
View File

@ -4168,6 +4168,16 @@ class api {
// Completing a competency.
case evidence::ACTION_COMPLETE:
// The logic here goes like this:
// if rating outside a course
// set the default grade and proficiency ONLY if there is no current grade
// else we are in a course
// set the defautl grade and proficiency in the course ONLY if there is no current grade in the course
// then check the course settings to see if we should push the rating outside the course
// if we should push it
// push it only if the user_competency (outside the course) has no grade
// Done.
if ($grade !== null) {
throw new coding_exception("The grade MUST NOT be set with a 'completing' evidence.");
}
@ -4178,12 +4188,51 @@ class api {
}
list($grade, $proficiency) = $competency->get_default_grade();
// When completing the competency we fetch the default grade from the competency. But we only mark
// the user competency when a grade has not been set yet. Complete is an action to use with automated systems.
if ($usercompetency->get_grade() === null) {
$setucgrade = true;
$ucgrade = $grade;
$ucproficiency = $proficiency;
// Add user_competency_course record when in a course or module.
if (in_array($context->contextlevel, array(CONTEXT_COURSE, CONTEXT_MODULE))) {
$coursecontext = $context->get_course_context();
$courseid = $coursecontext->instanceid;
$filterparams = array(
'userid' => $userid,
'competencyid' => $competencyid,
'courseid' => $courseid
);
// Fetch or create user competency course.
$usercompetencycourse = user_competency_course::get_record($filterparams);
if (!$usercompetencycourse) {
$usercompetencycourse = user_competency_course::create_relation($userid, $competencyid, $courseid);
$usercompetencycourse->create();
}
// Only update the grade and proficiency if there is not already a grade.
if ($usercompetencycourse->get_grade() === null) {
// Set grade.
$usercompetencycourse->set_grade($grade);
// Set proficiency.
$usercompetencycourse->set_proficiency($proficiency);
}
// Check the course settings to see if we should push to user plans.
$coursesettings = course_competency_settings::get_course_settings($courseid);
$setucgrade = $coursesettings->get_pushratingstouserplans();
if ($setucgrade) {
// Only push to user plans if there is not already a grade.
if ($usercompetency->get_grade() !== null) {
$setucgrade = false;
} else {
$ucgrade = $grade;
$ucproficiency = $proficiency;
}
}
} else {
// When completing the competency we fetch the default grade from the competency. But we only mark
// the user competency when a grade has not been set yet. Complete is an action to use with automated systems.
if ($usercompetency->get_grade() === null) {
$setucgrade = true;
$ucgrade = $grade;
$ucproficiency = $proficiency;
}
}
break;
@ -4205,7 +4254,7 @@ class api {
$courseid = $coursecontext->instanceid;
$filterparams = array(
'userid' => $userid,
'competencyid' => $competencyid,
'competencyid' => $competencyid,
'courseid' => $courseid
);
// Fetch or create user competency course.
@ -4839,7 +4888,7 @@ class api {
// First we do a permissions check.
if (!course_competency_settings::can_update($courseid)) {
$context = context_course::instance($courseid);
throw new required_capability_exception($context, 'tool/lp:coursecompetencyread', 'nopermissions', '');
throw new required_capability_exception($context, 'tool/lp:coursecompetencyconfigure', 'nopermissions', '');
}
$exists = course_competency_settings::get_record(array('courseid' => $courseid));

1
admin/tool/lp/db/access.php
View File

@ -49,6 +49,7 @@ $capabilities = array(
'contextlevel' => CONTEXT_COURSE, // And CONTEXT_USER.
'archetypes' => array(
'editingteacher' => CAP_ALLOW,
'teacher' => CAP_ALLOW,
'manager' => CAP_ALLOW
),
),

2
admin/tool/lp/lang/en/tool_lp.php
View File

@ -203,7 +203,7 @@ $string['lp:competencymanage'] = 'Manage competency frameworks';
$string['lp:competencygrade'] = 'Set competency grade';
$string['lp:competencyview'] = 'View competency frameworks';
$string['lp:coursecompetencygradable'] = 'Receive competency marks';
$string['lp:coursecompetencyconfigure'] = 'Configure a course competency settings';
$string['lp:coursecompetencyconfigure'] = 'Configure course competency settings';
$string['lp:coursecompetencymanage'] = 'Manage course competencies';
$string['lp:coursecompetencyview'] = 'View course competencies';
$string['lp:plancomment'] = 'Comment on a learning plan';

198
admin/tool/lp/tests/api_test.php
View File

@ -28,6 +28,7 @@ global $CFG;
use tool_lp\api;
use tool_lp\competency;
use tool_lp\competency_framework;
use tool_lp\course_competency_settings;
use tool_lp\evidence;
use tool_lp\user_competency;
use tool_lp\plan;
@ -2003,52 +2004,6 @@ class tool_lp_api_testcase extends advanced_testcase {
}
}
public function test_add_evidence_suggest() {
$this->resetAfterTest(true);
$dg = $this->getDataGenerator();
$lpg = $dg->get_plugin_generator('tool_lp');
$u1 = $dg->create_user();
$u1ctx = context_user::instance($u1->id);
$f1 = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Creating an evidence with minimal information.
$evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_SUGGEST, 'invaliddata',
'error', null, false, null, 1, 2);
$evidence->read();
$uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
$this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertSame(null, $uc->get_grade()); // We don't grade, we just suggest.
$this->assertSame(null, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
$this->assertEquals(\tool_lp\evidence::ACTION_SUGGEST, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_url());
$this->assertEquals(1, $evidence->get_grade());
$this->assertEquals(2, $evidence->get_actionuserid());
// Creating a standard evidence and send for review.
$evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_SUGGEST, 'invaliddata',
'error', null, true, null, 1, 2);
$evidence->read();
$uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
$this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
// Trying not to pass a grade should fail.
try {
$evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_SUGGEST, 'invaliddata',
'error', false, null);
$this->fail('A grade must be set');
} catch (coding_exception $e) {
$this->assertRegExp('/grade MUST be set/', $e->getMessage());
}
}
public function test_add_evidence_complete() {
$this->resetAfterTest(true);
$dg = $this->getDataGenerator();
@ -2380,11 +2335,6 @@ class tool_lp_api_testcase extends advanced_testcase {
$this->assertSame(null, $uc1a->get_proficiency());
$this->assertFalse(user_competency::record_exists_select('userid = ? AND competencyid = ?', array($u1->id, $c1->get_id())));
api::add_evidence($u1->id, $c2a, $ctxid, evidence::ACTION_SUGGEST, 'commentincontext', 'core', null, false, null, 1);
$uc2a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2a->get_id()));
$this->assertSame(null, $uc2a->get_proficiency());
$this->assertFalse(user_competency::record_exists_select('userid = ? AND competencyid = ?', array($u1->id, $c2->get_id())));
// Now let's try complete a competency but the rule won't match (not all children are complete).
// The parent (the thing with the rule) will be created but won't have any evidence attached, and not
// not be marked as completed.
@ -2432,37 +2382,6 @@ class tool_lp_api_testcase extends advanced_testcase {
api::add_evidence($u1->id, $c5, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
}
/**
* Tests for the user_competency_course data when api::add_evidence() is invoked when
* suggesting a grade for a user competency in the system context.
*/
public function test_add_evidence_for_user_competency_course_suggest_outside_course() {
$this->resetAfterTest(true);
$dg = $this->getDataGenerator();
$syscontext = context_system::instance();
// Create a student.
$student = $dg->create_user();
// Create a competency for the course.
$lpg = $dg->get_plugin_generator('tool_lp');
$framework = $lpg->create_framework();
$comp = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
// Add evidence.
api::add_evidence($student->id, $comp, $syscontext, evidence::ACTION_SUGGEST,
'commentincontext', 'core', null, false, null, 1);
// Query for user_competency_course data.
$filterparams = array(
'userid' => $student->id,
'competencyid' => $comp->get_id(),
);
$usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
// There should be no user_competency_course object when suggesting a grade outside the course context.
$this->assertFalse($usercompcourse);
}
/**
* Tests for the user_competency_course data when api::add_evidence() is invoked when
* grading a user competency in the system context.
@ -2494,67 +2413,6 @@ class tool_lp_api_testcase extends advanced_testcase {
$this->assertFalse($usercompcourse);
}
/**
* Tests for the user_competency_course data when api::add_evidence() is invoked when
* suggesting a grade for a user competency in a course.
*/
public function test_add_evidence_for_user_competency_course_suggest_in_course() {
global $USER;
$this->resetAfterTest(true);
$dg = $this->getDataGenerator();
// Create a course.
$course = $dg->create_course();
$coursecontext = context_course::instance($course->id);
// Create a student and enrol into the course.
$student = $dg->create_user();
$studentarch = get_archetype_roles('student');
$studentrole = array_shift($studentarch);
$dg->role_assign($studentrole->id, $student->id, $coursecontext->id);
$dg->enrol_user($student->id, $course->id, $studentrole->id);
// Create a competency for the course.
$lpg = $dg->get_plugin_generator('tool_lp');
$framework = $lpg->create_framework();
$comp = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$lpg->create_course_competency(array('courseid' => $course->id, 'competencyid' => $comp->get_id()));
// Add evidence.
$suggestedgrade = 3;
$evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_SUGGEST,
'commentincontext', 'core', null, false, null, $suggestedgrade, $USER->id);
// Query for user_competency_course data.
$filterparams = array(
'userid' => $student->id,
'competencyid' => $comp->get_id(),
'courseid' => $course->id
);
$usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
// There should be a user_competency_course object when suggesting a grade.
$this->assertNotEmpty($usercompcourse);
$grade = $evidence->get_grade();
$this->assertEquals($grade, $usercompcourse->get_grade());
$this->assertEquals($suggestedgrade, $usercompcourse->get_grade());
$proficiency = $comp->get_proficiency_of_grade($grade);
$this->assertEquals($proficiency, $usercompcourse->get_proficiency());
// Add evidence again with a new suggested grade.
$suggestedgrade = 1;
$evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_SUGGEST,
'commentincontext', 'core', null, false, null, $suggestedgrade, $USER->id);
// Get user competency course record.
$usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
// The grade/proficiency should have been updated.
$this->assertNotEmpty($usercompcourse);
$grade = $evidence->get_grade();
$this->assertEquals($grade, $usercompcourse->get_grade());
$this->assertEquals($suggestedgrade, $usercompcourse->get_grade());
$proficiency = $comp->get_proficiency_of_grade($grade);
$this->assertEquals($proficiency, $usercompcourse->get_proficiency());
}
/**
* Tests for the user_competency_course data when api::add_evidence() is invoked when
* grading a user competency in a course.
@ -2567,6 +2425,9 @@ class tool_lp_api_testcase extends advanced_testcase {
// Create a course.
$course = $dg->create_course();
$record = array('courseid' => $course->id, 'pushratingstouserplans' => false);
$settings = new course_competency_settings(0, (object) $record);
$settings->create();
$coursecontext = context_course::instance($course->id);
// Create a student and enrol into the course.
@ -2579,29 +2440,23 @@ class tool_lp_api_testcase extends advanced_testcase {
// Create a competency for the course.
$lpg = $dg->get_plugin_generator('tool_lp');
$framework = $lpg->create_framework();
// Do not push ratings from course to user plans.
$comp = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$lpg->create_course_competency(array('courseid' => $course->id, 'competencyid' => $comp->get_id()));
// Add evidence.
api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, false, null, 1, $USER->id);
// Query for user_competency_course data.
$filterparams = array(
'userid' => $student->id,
'competencyid' => $comp->get_id(),
'courseid' => $course->id
);
$usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
// There should be no user_competency_course object created when grading.
$this->assertFalse($usercompcourse);
// Add evidence that suggests a grade to the course.
$evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_SUGGEST,
// Add evidence that sets a grade to the course.
$evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, false, null, 3, $USER->id);
// Get user competency course record.
$usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
// There should be a user_competency_course object when suggesting a grade.
// There should be a user_competency_course object when adding a grade.
$this->assertNotEmpty($usercompcourse);
$grade = $evidence->get_grade();
$this->assertEquals($grade, $usercompcourse->get_grade());
@ -2609,7 +2464,7 @@ class tool_lp_api_testcase extends advanced_testcase {
$proficiency = $comp->get_proficiency_of_grade($grade);
$this->assertEquals($proficiency, $usercompcourse->get_proficiency());
// Confirm that the user competency's grade/proficiency has not been affected by the grade suggestion.
// Confirm that the user competency's grade/proficiency has not been affected by the grade.
$usercompetencyparams = [
'userid' => $student->id,
'competencyid' => $comp->get_id(),
@ -3981,9 +3836,6 @@ class tool_lp_api_testcase extends advanced_testcase {
$cangraderole = $dg->create_role();
assign_capability('tool/lp:competencygrade', CAP_ALLOW, $cangraderole, $sysctx->id);
$cansuggestrole = $dg->create_role();
assign_capability('tool/lp:competencysuggestgrade', CAP_ALLOW, $cansuggestrole, $sysctx->id);
// Enrol s1 and s2 as students in course 1.
$dg->enrol_user($student1->id, $c1->id, $studentrole->id);
$dg->enrol_user($student2->id, $c1->id, $studentrole->id);
@ -4006,15 +3858,6 @@ class tool_lp_api_testcase extends advanced_testcase {
accesslib_clear_all_caches_for_unit_testing();
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'Set competency grade',
$c1->id, $student1->id, $comp1->get_id());
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'Suggest competency grade',
$c1->id, $student1->id, $comp1->get_id(), 1, false);
// Give permission to suggest.
$dg->role_assign($cansuggestrole, $teacher1->id, $c1ctx->id);
accesslib_clear_all_caches_for_unit_testing();
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'Set competency grade',
$c1->id, $student1->id, $comp1->get_id());
$this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get_id(), 1, false);
// Give permission to rate.
$dg->role_assign($cangraderole, $teacher1->id, $c1ctx->id);
@ -4026,14 +3869,11 @@ class tool_lp_api_testcase extends advanced_testcase {
accesslib_clear_all_caches_for_unit_testing();
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'View competency frameworks',
$c1->id, $student1->id, $comp1->get_id());
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'View competency frameworks',
$c1->id, $student1->id, $comp1->get_id(), 1, false);
// Give permssion to manage course competencies, this leads to success.
$dg->role_assign($canmanagecomp, $teacher1->id, $sysctx->id);
accesslib_clear_all_caches_for_unit_testing();
$this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get_id());
$this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get_id(), 1, false);
// Try to grade a user that is not gradable, lead to errors.
$this->assertExceptionWithGradeCompetencyInCourse('coding_exception', 'The competency may not be rated at this time.',
@ -4047,15 +3887,13 @@ class tool_lp_api_testcase extends advanced_testcase {
$this->assertExceptionWithGradeCompetencyInCourse('coding_exception', 'The competency may not be rated at this time.',
$c1->id, $notstudent1->id, $comp1->get_id());
// Non-Editing teacher can suggest grade in user competency.
// Give permission for non-editing teacher to grade.
$dg->role_assign($canviewucrole, $noneditingteacher->id, $c1ctx->id);
$dg->role_assign($cangraderole, $noneditingteacher->id, $c1ctx->id);
$this->setUser($noneditingteacher);
accesslib_clear_all_caches_for_unit_testing();
$this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'Set competency grade',
$c1->id, $student1->id, $comp1->get_id());
// Give permission for non-editing teacher to suggest.
$dg->role_assign($cansuggestrole, $noneditingteacher->id, $c1ctx->id);
$this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get_id(), 1, false);
$this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get_id());
}
/**
@ -4065,11 +3903,10 @@ class tool_lp_api_testcase extends advanced_testcase {
* @param int $userid The user ID.
* @param int $compid The competency ID.
* @param int $grade The grade.
* @param boolean $override Overridden flag.
*/
protected function assertSuccessWithGradeCompetencyInCourse($courseid, $userid, $compid, $grade = 1, $override = true) {
protected function assertSuccessWithGradeCompetencyInCourse($courseid, $userid, $compid, $grade = 1) {
$beforecount = evidence::count_records();
api::grade_competency_in_course($courseid, $userid, $compid, $grade, $override);
api::grade_competency_in_course($courseid, $userid, $compid, $grade);
$this->assertEquals($beforecount + 1, evidence::count_records());
$uc = user_competency::get_record(array('userid' => $userid, 'competencyid' => $compid));
$records = evidence::get_records(array(), 'id', 'DESC', 0, 1);
@ -4086,14 +3923,13 @@ class tool_lp_api_testcase extends advanced_testcase {
* @param int $userid The user ID.
* @param int $compid The competency ID.
* @param int $grade The grade.
* @param boolean $override Overridden flag.
*/
protected function assertExceptionWithGradeCompetencyInCourse($exceptiontype, $exceptiontext, $courseid, $userid, $compid,
$grade = 1, $override = true) {
$grade = 1) {
$raised = false;
try {
api::grade_competency_in_course($courseid, $userid, $compid, $grade, $override);
api::grade_competency_in_course($courseid, $userid, $compid, $grade);
} catch (moodle_exception $e) {
$raised = true;
$this->assertInstanceOf($exceptiontype, $e);

162
admin/tool/lp/tests/event_test.php
View File

@ -1320,7 +1320,7 @@ class tool_lp_event_testcase extends advanced_testcase {
// Add evidence.
$recommend = false;
$evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_SUGGEST,
$evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, $recommend, null, 1);
// Get event.
@ -1379,7 +1379,7 @@ class tool_lp_event_testcase extends advanced_testcase {
// Add evidence.
$recommend = false;
$evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_SUGGEST,
$evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, $recommend, null, 1);
// We expect this to fail and throw a coding exception.
@ -1502,55 +1502,6 @@ class tool_lp_event_testcase extends advanced_testcase {
$this->assertDebuggingNotCalled();
}
/**
* Test the user competency grade suggested event.
*
*/
public function test_user_competency_grade_suggested() {
$this->resetAfterTest(true);
$this->setAdminUser();
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
$scaleconfig = array(array('scaleid' => $scale->id));
$scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
$scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
$scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
$scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
$fr = $lpg->create_framework();
$c = $lpg->create_competency(array(
'competencyframeworkid' => $fr->get_id(),
'scaleid' => $scale->id,
'scaleconfiguration' => $scaleconfig
));
$user = $dg->create_user();
$uc = $lpg->create_user_competency(array(
'userid' => $user->id,
'competencyid' => $c->get_id()));
// Trigger and capture the event.
$sink = $this->redirectEvents();
api::grade_competency($user->id, $c->get_id(), 4, false);
// Get our event event.
$events = $sink->get_events();
// Evidence created.
$this->assertCount(2, $events);
$evidencecreatedevent = $events[0];
$event = $events[1];
// Check that the event data is valid.
$this->assertInstanceOf('\tool_lp\event\evidence_created', $evidencecreatedevent);
$this->assertInstanceOf('\tool_lp\event\user_competency_grade_suggested', $event);
$this->assertEquals($uc->get_id(), $event->objectid);
$this->assertEquals($uc->get_context()->id, $event->contextid);
$this->assertEquals($uc->get_userid(), $event->relateduserid);
$this->assertEquals(4, $event->other['grade']);
$this->assertEventContextNotUsed($event);
$this->assertDebuggingNotCalled();
}
/**
* Test the user competency grade rated in course event.
*
@ -1609,64 +1560,6 @@ class tool_lp_event_testcase extends advanced_testcase {
$this->assertDebuggingNotCalled();
}
/**
* Test the user competency grade suggested in course event.
*
*/
public function test_user_competency_grade_suggested_in_course() {
$this->resetAfterTest(true);
$this->setAdminUser();
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
$course = $dg->create_course();
$user = $dg->create_user();
$studentarch = get_archetype_roles('student');
$studentrole = array_shift($studentarch);
$scaleconfig = array(array('scaleid' => $scale->id));
$scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
$scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
$scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
$scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
$fr = $lpg->create_framework();
$c = $lpg->create_competency(array(
'competencyframeworkid' => $fr->get_id(),
'scaleid' => $scale->id,
'scaleconfiguration' => $scaleconfig
));
// Enrol the user as students in course.
$dg->enrol_user($user->id, $course->id, $studentrole->id);
$lpg->create_course_competency(array(
'courseid' => $course->id,
'competencyid' => $c->get_id()));
$uc = $lpg->create_user_competency(array(
'userid' => $user->id,
'competencyid' => $c->get_id()));
// Trigger and capture the event.
$sink = $this->redirectEvents();
api::grade_competency_in_course($course->id, $user->id, $c->get_id(), 3, false);
// Get our event event.
$events = $sink->get_events();
// Evidence created.
$this->assertCount(2, $events);
$evidencecreatedevent = $events[0];
$event = $events[1];
// Check that the event data is valid.
$this->assertInstanceOf('\tool_lp\event\evidence_created', $evidencecreatedevent);
$this->assertInstanceOf('\tool_lp\event\user_competency_grade_suggested_in_course', $event);
$this->assertEquals($uc->get_id(), $event->objectid);
$this->assertEquals(context_course::instance($course->id)->id, $event->contextid);
$this->assertEquals($course->id, $event->courseid);
$this->assertEquals($uc->get_userid(), $event->relateduserid);
$this->assertEquals($uc->get_competencyid(), $event->other['competencyid']);
$this->assertEquals(3, $event->other['grade']);
$this->assertEventContextNotUsed($event);
$this->assertDebuggingNotCalled();
}
/**
* Test the user competency grade rated in plan event.
*
@ -1718,57 +1611,6 @@ class tool_lp_event_testcase extends advanced_testcase {
$this->assertDebuggingNotCalled();
}
/**
* Test the user competency grade suggested in plan event.
*
*/
public function test_user_competency_grade_suggested_in_plan() {
$this->resetAfterTest(true);
$this->setAdminUser();
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
$user = $dg->create_user();
$scaleconfig = array(array('scaleid' => $scale->id));
$scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
$scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
$scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
$scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
$plan = $lpg->create_plan(array('userid' => $user->id));
$fr = $lpg->create_framework();
$c = $lpg->create_competency(array(
'competencyframeworkid' => $fr->get_id(),
'scaleid' => $scale->id,
'scaleconfiguration' => $scaleconfig
));
$pc = $lpg->create_plan_competency(array('planid' => $plan->get_id(), 'competencyid' => $c->get_id()));
$uc = $lpg->create_user_competency(array(
'userid' => $user->id,
'competencyid' => $c->get_id()));
// Trigger and capture the event.
$sink = $this->redirectEvents();
api::grade_competency_in_plan($plan->get_id(), $c->get_id(), 4, false);
// Get our event event.
$events = $sink->get_events();
// Evidence created.
$this->assertCount(2, $events);
$evidencecreatedevent = $events[0];
$event = $events[1];
// Check that the event data is valid.
$this->assertInstanceOf('\tool_lp\event\evidence_created', $evidencecreatedevent);
$this->assertInstanceOf('\tool_lp\event\user_competency_grade_suggested_in_plan', $event);
$this->assertEquals($uc->get_id(), $event->objectid);
$this->assertEquals($uc->get_context()->id, $event->contextid);
$this->assertEquals($uc->get_userid(), $event->relateduserid);
$this->assertEquals($uc->get_competencyid(), $event->other['competencyid']);
$this->assertEquals(4, $event->other['grade']);
$this->assertEventContextNotUsed($event);
$this->assertDebuggingNotCalled();
}
/**
* Test user competency comment created event.
*/

19
admin/tool/lp/tests/externallib_test.php
View File

@ -106,7 +106,6 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
// Reset all default authenticated users permissions.
unassign_capability('tool/lp:competencygrade', $authrole->id);
unassign_capability('tool/lp:competencysuggestgrade', $authrole->id);
unassign_capability('tool/lp:competencymanage', $authrole->id);
unassign_capability('tool/lp:competencyview', $authrole->id);
unassign_capability('tool/lp:planmanage', $authrole->id);
@ -135,10 +134,8 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
assign_capability('tool/lp:planviewdraft', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:templatemanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:competencygrade', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:competencysuggestgrade', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('moodle/cohort:manage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:templateview', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:competencysuggestgrade', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:planviewown', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:planviewowndraft', CAP_ALLOW, $this->userrole, $syscontext->id);
@ -2940,23 +2937,16 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
$uc = $lpg->create_user_competency(array('userid' => $this->user->id, 'competencyid' => $c1->get_id()));
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, false, 'Evil note');
$this->assertEquals('The competency grade was manually suggested in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$this->assertEquals('Evil note', $evidence->note);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, true);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, 'Evil note');
$this->assertEquals('The competency grade was manually set in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$this->assertEquals('Evil note', $evidence->note);
$this->setUser($this->user);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, false);
$this->assertEquals('The competency grade was manually suggested in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$this->setExpectedException('required_capability_exception');
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, true);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1);
}
public function test_data_for_user_competency_summary_in_plan() {
@ -2978,12 +2968,11 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
$uc = $lpg->create_user_competency(array('userid' => $this->user->id, 'competencyid' => $c1->get_id()));
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, false);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, true);
$evidence = external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 2, true);
$summary = external::data_for_user_competency_summary_in_plan($c1->get_id(), $plan->get_id());
$this->assertTrue($summary->usercompetencysummary->cangrade);
$this->assertTrue($summary->usercompetencysummary->cansuggest);
$this->assertEquals('Evil', $summary->plan->name);
$this->assertEquals('B', $summary->usercompetencysummary->usercompetency->gradename);
$this->assertEquals('B', $summary->usercompetencysummary->evidence[0]->gradename);