competency/tests/api_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * API tests.
  19  *
  20  * @package    core_competency
  21  * @copyright  2015 Frédéric Massart - FMCorz.net
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26 global $CFG;
  27
  28 use core_competency\api;
  29 use core_competency\competency;
  30 use core_competency\competency_framework;
  31 use core_competency\course_competency_settings;
  32 use core_competency\evidence;
  33 use core_competency\user_competency;
  34 use core_competency\plan;
  35
  36 /**
  37  * API tests.
  38  *
  39  * @package    core_competency
  40  * @copyright  2015 Frédéric Massart - FMCorz.net
  41  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  42  */
  43 class core_competency_api_testcase extends advanced_testcase {
  44
  45     public function test_get_framework_related_contexts() {
  46         $this->resetAfterTest(true);
  47         $dg = $this->getDataGenerator();
  48         $cat1 = $dg->create_category();
  49         $cat2 = $dg->create_category(array('parent' => $cat1->id));
  50         $cat3 = $dg->create_category(array('parent' => $cat2->id));
  51         $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.
  52
  53         $cat1ctx = context_coursecat::instance($cat1->id);
  54         $cat2ctx = context_coursecat::instance($cat2->id);
  55         $cat3ctx = context_coursecat::instance($cat3->id);
  56         $sysctx = context_system::instance();
  57
  58         $expected = array($cat1ctx->id => $cat1ctx);
  59         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'self'));
  60
  61         $expected = array($cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx, $cat3ctx->id => $cat3ctx);
  62         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children'));
  63
  64         $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx);
  65         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents'));
  66     }
  67
  68     public function test_get_framework_related_contexts_with_capabilities() {
  69         $this->resetAfterTest(true);
  70         $dg = $this->getDataGenerator();
  71         $user = $dg->create_user();
  72         $cat1 = $dg->create_category();
  73         $cat2 = $dg->create_category(array('parent' => $cat1->id));
  74         $cat3 = $dg->create_category(array('parent' => $cat2->id));
  75         $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.
  76
  77         $cat1ctx = context_coursecat::instance($cat1->id);
  78         $cat2ctx = context_coursecat::instance($cat2->id);
  79         $cat3ctx = context_coursecat::instance($cat3->id);
  80         $sysctx = context_system::instance();
  81
  82         $roleallow = create_role('Allow', 'allow', 'Allow read');
  83         assign_capability('moodle/competency:competencyview', CAP_ALLOW, $roleallow, $sysctx->id);
  84         role_assign($roleallow, $user->id, $sysctx->id);
  85
  86         $roleprevent = create_role('Prevent', 'prevent', 'Prevent read');
  87         assign_capability('moodle/competency:competencyview', CAP_PROHIBIT, $roleprevent, $sysctx->id);
  88         role_assign($roleprevent, $user->id, $cat2ctx->id);
  89
  90         accesslib_clear_all_caches_for_unit_testing();
  91         $this->setUser($user);
  92         $this->assertFalse(has_capability('moodle/competency:competencyview', $cat2ctx));
  93
  94         $requiredcap = array('moodle/competency:competencyview');
  95
  96         $expected = array();
  97         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'self', $requiredcap));
  98
  99         $expected = array($cat1ctx->id => $cat1ctx);
 100         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children', $requiredcap));
 101
 102         $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx);
 103         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents', $requiredcap));
 104     }
 105
 106     public function test_get_template_related_contexts() {
 107         $this->resetAfterTest(true);
 108         $dg = $this->getDataGenerator();
 109         $cat1 = $dg->create_category();
 110         $cat2 = $dg->create_category(array('parent' => $cat1->id));
 111         $cat3 = $dg->create_category(array('parent' => $cat2->id));
 112         $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.
 113
 114         $cat1ctx = context_coursecat::instance($cat1->id);
 115         $cat2ctx = context_coursecat::instance($cat2->id);
 116         $cat3ctx = context_coursecat::instance($cat3->id);
 117         $sysctx = context_system::instance();
 118
 119         $expected = array($cat1ctx->id => $cat1ctx);
 120         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'self'));
 121
 122         $expected = array($cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx, $cat3ctx->id => $cat3ctx);
 123         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children'));
 124
 125         $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx);
 126         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents'));
 127     }
 128
 129     public function test_get_template_related_contexts_with_capabilities() {
 130         $this->resetAfterTest(true);
 131         $dg = $this->getDataGenerator();
 132         $user = $dg->create_user();
 133         $cat1 = $dg->create_category();
 134         $cat2 = $dg->create_category(array('parent' => $cat1->id));
 135         $cat3 = $dg->create_category(array('parent' => $cat2->id));
 136         $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.
 137
 138         $cat1ctx = context_coursecat::instance($cat1->id);
 139         $cat2ctx = context_coursecat::instance($cat2->id);
 140         $cat3ctx = context_coursecat::instance($cat3->id);
 141         $sysctx = context_system::instance();
 142
 143         $roleallow = create_role('Allow', 'allow', 'Allow read');
 144         assign_capability('moodle/competency:templateview', CAP_ALLOW, $roleallow, $sysctx->id);
 145         role_assign($roleallow, $user->id, $sysctx->id);
 146
 147         $roleprevent = create_role('Prevent', 'prevent', 'Prevent read');
 148         assign_capability('moodle/competency:templateview', CAP_PROHIBIT, $roleprevent, $sysctx->id);
 149         role_assign($roleprevent, $user->id, $cat2ctx->id);
 150
 151         accesslib_clear_all_caches_for_unit_testing();
 152         $this->setUser($user);
 153         $this->assertFalse(has_capability('moodle/competency:templateview', $cat2ctx));
 154
 155         $requiredcap = array('moodle/competency:templateview');
 156
 157         $expected = array();
 158         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'self', $requiredcap));
 159
 160         $expected = array($cat1ctx->id => $cat1ctx);
 161         $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children', $requiredcap));
 162
 163         $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx);
 164         $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents', $requiredcap));
 165     }
 166
 167     /**
 168      * Test updating a template.
 169      *
 170      * @expectedException coding_exception
 171      */
 172     public function test_update_template() {
 173         $cat = $this->getDataGenerator()->create_category();
 174         $this->resetAfterTest(true);
 175         $this->setAdminUser();
 176
 177         $syscontext = context_system::instance();
 178         $template = api::create_template((object) array('shortname' => 'testing', 'contextid' => $syscontext->id));
 179
 180         $this->assertEquals('testing', $template->get('shortname'));
 181         $this->assertEquals($syscontext->id, $template->get('contextid'));
 182
 183         // Simple update.
 184         api::update_template((object) array('id' => $template->get('id'), 'shortname' => 'success'));
 185         $template = api::read_template($template->get('id'));
 186         $this->assertEquals('success', $template->get('shortname'));
 187
 188         // Trying to change the context.
 189         api::update_template((object) array('id' => $template->get('id'), 'contextid' => context_coursecat::instance($cat->id)));
 190     }
 191
 192     /**
 193      * Test listing framework with order param.
 194      */
 195     public function test_list_frameworks() {
 196         $this->resetAfterTest(true);
 197         $this->setAdminUser();
 198         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
 199
 200         // Create a list of frameworks.
 201         $framework1 = $lpg->create_framework(array(
 202             'shortname' => 'shortname_alpha',
 203             'idnumber' => 'idnumber_cinnamon',
 204             'description' => 'description',
 205             'descriptionformat' => FORMAT_HTML,
 206             'visible' => true,
 207             'contextid' => context_system::instance()->id
 208         ));
 209
 210         $framework2 = $lpg->create_framework(array(
 211             'shortname' => 'shortname_beetroot',
 212             'idnumber' => 'idnumber_apple',
 213             'description' => 'description',
 214             'descriptionformat' => FORMAT_HTML,
 215             'visible' => true,
 216             'contextid' => context_system::instance()->id
 217         ));
 218
 219         $framework3 = $lpg->create_framework(array(
 220             'shortname' => 'shortname_crisps',
 221             'idnumber' => 'idnumber_beer',
 222             'description' => 'description',
 223             'descriptionformat' => FORMAT_HTML,
 224             'visible' => false,
 225             'contextid' => context_system::instance()->id
 226         ));
 227
 228         // Get frameworks list order by shortname desc.
 229         $result = api::list_frameworks('shortname', 'DESC', null, 3, context_system::instance());
 230
 231         $f = (object) array_shift($result);
 232         $this->assertEquals($framework3->get('id'), $f->get('id'));
 233         $f = (object) array_shift($result);
 234         $this->assertEquals($framework2->get('id'), $f->get('id'));
 235         $f = (object) array_shift($result);
 236         $this->assertEquals($framework1->get('id'), $f->get('id'));
 237
 238         // Get frameworks list order by idnumber asc.
 239         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance());
 240
 241         $f = (object) array_shift($result);
 242         $this->assertEquals($framework2->get('id'), $f->get('id'));
 243         $f = (object) array_shift($result);
 244         $this->assertEquals($framework3->get('id'), $f->get('id'));
 245         $f = (object) array_shift($result);
 246         $this->assertEquals($framework1->get('id'), $f->get('id'));
 247
 248         // Repeat excluding the non-visible ones.
 249         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance(), 'self', true);
 250         $this->assertCount(2, $result);
 251         $f = (object) array_shift($result);
 252         $this->assertEquals($framework2->get('id'), $f->get('id'));
 253         $f = (object) array_shift($result);
 254         $this->assertEquals($framework1->get('id'), $f->get('id'));
 255
 256         // Search by query string, trying match on shortname.
 257         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance(), 'self', false, 'crisp');
 258         $this->assertCount(1, $result);
 259         $f = (object) array_shift($result);
 260         $this->assertEquals($framework3->get('id'), $f->get('id'));
 261
 262         // Search by query string, trying match on shortname, but hidden.
 263         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance(), 'self', true, 'crisp');
 264         $this->assertCount(0, $result);
 265
 266         // Search by query string, trying match on ID number.
 267         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance(), 'self', false, 'apple');
 268         $this->assertCount(1, $result);
 269         $f = (object) array_shift($result);
 270         $this->assertEquals($framework2->get('id'), $f->get('id'));
 271
 272         // Search by query string, trying match on both.
 273         $result = api::list_frameworks('idnumber', 'ASC', null, 3, context_system::instance(), 'self', false, 'bee');
 274         $this->assertCount(2, $result);
 275         $f = (object) array_shift($result);
 276         $this->assertEquals($framework2->get('id'), $f->get('id'));
 277         $f = (object) array_shift($result);
 278         $this->assertEquals($framework3->get('id'), $f->get('id'));
 279     }
 280
 281     /**
 282      * Test duplicate a framework.
 283      */
 284     public function test_duplicate_framework() {
 285         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
 286         $this->resetAfterTest(true);
 287         $this->setAdminUser();
 288
 289         $syscontext = context_system::instance();
 290         $params = array(
 291                 'shortname' => 'shortname_a',
 292                 'idnumber' => 'idnumber_c',
 293                 'description' => 'description',
 294                 'descriptionformat' => FORMAT_HTML,
 295                 'visible' => true,
 296                 'contextid' => $syscontext->id
 297         );
 298         $framework = $lpg->create_framework($params);
 299         $competency1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 300         $competency2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 301         $competency3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 302         $competency4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 303         $competency41 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id'),
 304                                                         'parentid' => $competency4->get('id'))
 305                                                     );
 306         $competency42 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id'),
 307                                                         'parentid' => $competency4->get('id'))
 308                                                     );
 309         $competencyidnumbers = array($competency1->get('idnumber'),
 310                                         $competency2->get('idnumber'),
 311                                         $competency3->get('idnumber'),
 312                                         $competency4->get('idnumber'),
 313                                         $competency41->get('idnumber'),
 314                                         $competency42->get('idnumber')
 315                                     );
 316
 317         $config = json_encode(array(
 318             'base' => array('points' => 4),
 319             'competencies' => array(
 320                 array('id' => $competency41->get('id'), 'points' => 3, 'required' => 0),
 321                 array('id' => $competency42->get('id'), 'points' => 2, 'required' => 1),
 322             )
 323         ));
 324         $competency4->set('ruletype', 'core_competency\competency_rule_points');
 325         $competency4->set('ruleoutcome', \core_competency\competency::OUTCOME_EVIDENCE);
 326         $competency4->set('ruleconfig', $config);
 327         $competency4->update();
 328
 329         api::add_related_competency($competency1->get('id'), $competency2->get('id'));
 330         api::add_related_competency($competency3->get('id'), $competency4->get('id'));
 331
 332         $frameworkduplicated1 = api::duplicate_framework($framework->get('id'));
 333         $frameworkduplicated2 = api::duplicate_framework($framework->get('id'));
 334
 335         $this->assertEquals($framework->get('idnumber').'_1', $frameworkduplicated1->get('idnumber'));
 336         $this->assertEquals($framework->get('idnumber').'_2', $frameworkduplicated2->get('idnumber'));
 337
 338         $competenciesfr1 = api::list_competencies(array('competencyframeworkid' => $frameworkduplicated1->get('id')));
 339         $competenciesfr2 = api::list_competencies(array('competencyframeworkid' => $frameworkduplicated2->get('id')));
 340
 341         $competencyidsfr1 = array();
 342         $competencyidsfr2 = array();
 343
 344         foreach ($competenciesfr1 as $cmp) {
 345             $competencyidsfr1[] = $cmp->get('idnumber');
 346         }
 347         foreach ($competenciesfr2 as $cmp) {
 348             $competencyidsfr2[] = $cmp->get('idnumber');
 349         }
 350
 351         $this->assertEmpty(array_diff($competencyidsfr1, $competencyidnumbers));
 352         $this->assertEmpty(array_diff($competencyidsfr2, $competencyidnumbers));
 353         $this->assertCount(6, $competenciesfr1);
 354         $this->assertCount(6, $competenciesfr2);
 355
 356         // Test the related competencies.
 357         reset($competenciesfr1);
 358         $compduplicated1 = current($competenciesfr1);
 359         $relatedcompetencies = $compduplicated1->get_related_competencies();
 360         $comprelated = current($relatedcompetencies);
 361         $this->assertEquals($comprelated->get('idnumber'), $competency2->get('idnumber'));
 362
 363         // Check if config rule have been ported correctly.
 364         $competency4duplicated = competency::get_record(array(
 365                                                             'idnumber' => $competency4->get('idnumber'),
 366                                                             'competencyframeworkid' => $frameworkduplicated2->get('id')
 367                                                         ));
 368         $configduplicated = json_decode($competency4duplicated->get('ruleconfig'), true);
 369         $configorigin = json_decode($config, true);
 370         // Check that the 2 config have the same base.
 371         $this->assertEquals($configorigin['base'], $configduplicated['base']);
 372         $this->assertEquals(count($configorigin['competencies']), count($configduplicated['competencies']));
 373         $competencyidsrules = array();
 374         foreach ($configduplicated['competencies'] as $key => $value) {
 375             // Check that the only difference between the 2 config is id competency.
 376             $this->assertEquals(1, count(array_diff($value, $configorigin['competencies'][$key])));
 377             $competencyidsrules[] = $value['id'];
 378         }
 379         $this->assertTrue($competency4duplicated->is_parent_of($competencyidsrules));
 380
 381         // Test duplicate an empty framework.
 382         $emptyfrm = $lpg->create_framework();
 383         $emptyfrmduplicated = api::duplicate_framework($emptyfrm->get('id'));
 384         $this->assertEquals($emptyfrm->get('idnumber').'_1', $emptyfrmduplicated->get('idnumber'));
 385         $nbcomp = api::count_competencies(array('competencyframeworkid' => $emptyfrmduplicated->get('id')));
 386         $this->assertEquals(0, $nbcomp);
 387
 388     }
 389
 390     /**
 391      * Test update plan.
 392      */
 393     public function test_update_plan() {
 394         $this->resetAfterTest(true);
 395         $dg = $this->getDataGenerator();
 396         $usermanageowndraft = $dg->create_user();
 397         $usermanageown = $dg->create_user();
 398         $usermanagedraft = $dg->create_user();
 399         $usermanage = $dg->create_user();
 400
 401         $syscontext = context_system::instance();
 402
 403         // Creating specific roles.
 404         $manageowndraftrole = $dg->create_role(array(
 405             'name' => 'User manage own draft',
 406             'shortname' => 'manage-own-draft'
 407         ));
 408         $manageownrole = $dg->create_role(array(
 409             'name' => 'User manage own',
 410             'shortname' => 'manage-own'
 411         ));
 412         $managedraftrole = $dg->create_role(array(
 413             'name' => 'User manage draft',
 414             'shortname' => 'manage-draft'
 415         ));
 416         $managerole = $dg->create_role(array(
 417             'name' => 'User manage',
 418             'shortname' => 'manage'
 419         ));
 420
 421         assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $manageowndraftrole, $syscontext->id);
 422         assign_capability('moodle/competency:planviewowndraft', CAP_ALLOW, $manageowndraftrole, $syscontext->id);
 423
 424         assign_capability('moodle/competency:planmanageown', CAP_ALLOW, $manageownrole, $syscontext->id);
 425         assign_capability('moodle/competency:planviewown', CAP_ALLOW, $manageownrole, $syscontext->id);
 426
 427         assign_capability('moodle/competency:planmanagedraft', CAP_ALLOW, $managedraftrole, $syscontext->id);
 428         assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $managedraftrole, $syscontext->id);
 429
 430         assign_capability('moodle/competency:planmanage', CAP_ALLOW, $managerole, $syscontext->id);
 431         assign_capability('moodle/competency:planview', CAP_ALLOW, $managerole, $syscontext->id);
 432
 433         $dg->role_assign($manageowndraftrole, $usermanageowndraft->id, $syscontext->id);
 434         $dg->role_assign($manageownrole, $usermanageown->id, $syscontext->id);
 435         $dg->role_assign($managedraftrole, $usermanagedraft->id, $syscontext->id);
 436         $dg->role_assign($managerole, $usermanage->id, $syscontext->id);
 437
 438         // Create first learning plan with user create draft.
 439         $this->setUser($usermanageowndraft);
 440         $plan = array (
 441             'name' => 'plan own draft',
 442             'description' => 'plan own draft',
 443             'userid' => $usermanageowndraft->id
 444         );
 445         $plan = api::create_plan((object)$plan);
 446         $record = $plan->to_record();
 447         $record->name = 'plan own draft modified';
 448
 449         // Check if user create draft can edit the plan name.
 450         $plan = api::update_plan($record);
 451         $this->assertInstanceOf('\core_competency\plan', $plan);
 452
 453         // The status cannot be changed in this method.
 454         $record->status = \core_competency\plan::STATUS_ACTIVE;
 455         try {
 456             $plan = api::update_plan($record);
 457             $this->fail('Updating the status is not allowed.');
 458         } catch (coding_exception $e) {
 459             $this->assertRegExp('/To change the status of a plan use the appropriate methods./', $e->getMessage());
 460         }
 461
 462         // Test when user with manage own plan capability try to edit other user plan.
 463         $record->status = \core_competency\plan::STATUS_DRAFT;
 464         $record->name = 'plan create draft modified 2';
 465         $this->setUser($usermanageown);
 466         try {
 467             $plan = api::update_plan($record);
 468             $this->fail('User with manage own plan capability can only edit his own plan.');
 469         } catch (required_capability_exception $e) {
 470             $this->assertTrue(true);
 471         }
 472
 473         // User with manage plan capability cannot edit the other user plans with status draft.
 474         $this->setUser($usermanage);
 475         $record->name = 'plan create draft modified 3';
 476         try {
 477             $plan = api::update_plan($record);
 478             $this->fail('User with manage plan capability cannot edit the other user plans with status draft');
 479         } catch (required_capability_exception $e) {
 480             $this->assertTrue(true);
 481         }
 482
 483         // User with manage draft capability can edit other user's learning plan if the status is draft.
 484         $this->setUser($usermanagedraft);
 485         $record->status = \core_competency\plan::STATUS_DRAFT;
 486         $record->name = 'plan manage draft modified 3';
 487         $plan = api::update_plan($record);
 488         $this->assertInstanceOf('\core_competency\plan', $plan);
 489
 490         // User with manage  plan capability can create/edit learning plan if status is active/complete.
 491         $this->setUser($usermanage);
 492         $plan = array (
 493             'name' => 'plan create',
 494             'description' => 'plan create',
 495             'userid' => $usermanage->id,
 496             'status' => \core_competency\plan::STATUS_ACTIVE
 497         );
 498         $plan = api::create_plan((object)$plan);
 499
 500         // Silently transition to complete status to avoid errors about transitioning to complete.
 501         $plan->set('status', \core_competency\plan::STATUS_COMPLETE);
 502         $plan->update();
 503
 504         $record = $plan->to_record();
 505         $record->name = 'plan create own modified';
 506         try {
 507             api::update_plan($record);
 508             $this->fail('Completed plan can not be edited');
 509         } catch (coding_exception $e) {
 510             $this->assertTrue(true);
 511         }
 512     }
 513
 514     /**
 515      * @expectedException coding_exception
 516      */
 517     public function test_create_plan_from_template() {
 518         $this->resetAfterTest(true);
 519         $this->setAdminUser();
 520
 521         $u1 = $this->getDataGenerator()->create_user();
 522         $tpl = $this->getDataGenerator()->get_plugin_generator('core_competency')->create_template();
 523
 524         // Creating a new plan.
 525         $plan = api::create_plan_from_template($tpl, $u1->id);
 526         $record = $plan->to_record();
 527         $this->assertInstanceOf('\core_competency\plan', $plan);
 528         $this->assertTrue(\core_competency\plan::record_exists($plan->get('id')));
 529         $this->assertEquals($tpl->get('id'), $plan->get('templateid'));
 530         $this->assertEquals($u1->id, $plan->get('userid'));
 531         $this->assertTrue($plan->is_based_on_template());
 532
 533         // Creating a plan that already exists.
 534         $plan = api::create_plan_from_template($tpl, $u1->id);
 535         $this->assertFalse($plan);
 536
 537         // Check that api::create_plan cannot be used.
 538         unset($record->id);
 539         $plan = api::create_plan($record);
 540     }
 541
 542     public function test_update_plan_based_on_template() {
 543         $this->resetAfterTest(true);
 544         $dg = $this->getDataGenerator();
 545         $lpg = $dg->get_plugin_generator('core_competency');
 546         $u1 = $dg->create_user();
 547         $u2 = $dg->create_user();
 548
 549         $this->setAdminUser();
 550         $tpl1 = $lpg->create_template();
 551         $tpl2 = $lpg->create_template();
 552         $up1 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id')));
 553         $up2 = $lpg->create_plan(array('userid' => $u2->id, 'templateid' => null));
 554
 555         try {
 556             // Trying to remove the template dependency.
 557             $record = $up1->to_record();
 558             $record->templateid = null;
 559             api::update_plan($record);
 560             $this->fail('A plan cannot be unlinked using api::update_plan()');
 561         } catch (coding_exception $e) {
 562             // All good.
 563         }
 564
 565         try {
 566             // Trying to switch to another template.
 567             $record = $up1->to_record();
 568             $record->templateid = $tpl2->get('id');
 569             api::update_plan($record);
 570             $this->fail('A plan cannot be moved to another template.');
 571         } catch (coding_exception $e) {
 572             // All good.
 573         }
 574
 575         try {
 576             // Trying to switch to using a template.
 577             $record = $up2->to_record();
 578             $record->templateid = $tpl1->get('id');
 579             api::update_plan($record);
 580             $this->fail('A plan cannot be update to use a template.');
 581         } catch (coding_exception $e) {
 582             // All good.
 583         }
 584     }
 585
 586     public function test_unlink_plan_from_template() {
 587         $this->resetAfterTest(true);
 588         $dg = $this->getDataGenerator();
 589         $lpg = $dg->get_plugin_generator('core_competency');
 590         $u1 = $dg->create_user();
 591         $u2 = $dg->create_user();
 592
 593         $this->setAdminUser();
 594         $f1 = $lpg->create_framework();
 595         $f2 = $lpg->create_framework();
 596         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
 597         $c2a = $lpg->create_competency(array('competencyframeworkid' => $f2->get('id')));
 598         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
 599
 600         $tpl1 = $lpg->create_template();
 601         $tpl2 = $lpg->create_template();
 602
 603         $tplc1a = $lpg->create_template_competency(array('templateid' => $tpl1->get('id'), 'competencyid' => $c1a->get('id'),
 604             'sortorder' => 9));
 605         $tplc1b = $lpg->create_template_competency(array('templateid' => $tpl1->get('id'), 'competencyid' => $c1b->get('id'),
 606             'sortorder' => 8));
 607         $tplc2a = $lpg->create_template_competency(array('templateid' => $tpl2->get('id'), 'competencyid' => $c2a->get('id')));
 608
 609         $plan1 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id'), 'status' => plan::STATUS_ACTIVE));
 610         $plan2 = $lpg->create_plan(array('userid' => $u2->id, 'templateid' => $tpl2->get('id')));
 611         $plan3 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id'), 'status' => plan::STATUS_COMPLETE));
 612
 613         // Check that we have what we expect at this stage.
 614         $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get('id'))));
 615         $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get('id'))));
 616         $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan1->get('id'))));
 617         $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get('id'))));
 618         $this->assertTrue($plan1->is_based_on_template());
 619         $this->assertTrue($plan2->is_based_on_template());
 620
 621         // Let's do this!
 622         $tpl1comps = \core_competency\template_competency::list_competencies($tpl1->get('id'), true);
 623         $tpl2comps = \core_competency\template_competency::list_competencies($tpl2->get('id'), true);
 624
 625         api::unlink_plan_from_template($plan1);
 626
 627         $plan1->read();
 628         $plan2->read();
 629         $this->assertCount(2, $tpl1comps);
 630         $this->assertCount(1, $tpl2comps);
 631         $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get('id'))));
 632         $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get('id'))));
 633         $this->assertEquals(2, \core_competency\plan_competency::count_records(array('planid' => $plan1->get('id'))));
 634         $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get('id'))));
 635         $this->assertFalse($plan1->is_based_on_template());
 636         $this->assertEquals($tpl1->get('id'), $plan1->get('origtemplateid'));
 637         $this->assertTrue($plan2->is_based_on_template());
 638         $this->assertEquals(null, $plan2->get('origtemplateid'));
 639
 640         // Check we can unlink draft plan.
 641         try {
 642             api::unlink_plan_from_template($plan2);
 643         } catch (coding_exception $e) {
 644             $this->fail('Fail to unlink draft plan.');
 645         }
 646
 647         // Check we can not unlink completed plan.
 648         try {
 649             api::unlink_plan_from_template($plan3);
 650             $this->fail('We can not unlink completed plan.');
 651         } catch (coding_exception $e) {
 652             // All good.
 653         }
 654
 655         // Even the order remains.
 656         $plan1comps = \core_competency\plan_competency::list_competencies($plan1->get('id'));
 657         $before = reset($tpl1comps);
 658         $after = reset($plan1comps);
 659         $this->assertEquals($before->get('id'), $after->get('id'));
 660         $this->assertEquals($before->get('sortorder'), $after->get('sortorder'));
 661         $before = next($tpl1comps);
 662         $after = next($plan1comps);
 663         $this->assertEquals($before->get('id'), $after->get('id'));
 664         $this->assertEquals($before->get('sortorder'), $after->get('sortorder'));
 665     }
 666
 667     public function test_update_template_updates_plans() {
 668         $this->resetAfterTest(true);
 669         $this->setAdminUser();
 670
 671         $dg = $this->getDataGenerator();
 672         $u1 = $dg->create_user();
 673         $u2 = $dg->create_user();
 674         $lpg = $dg->get_plugin_generator('core_competency');
 675         $tpl1 = $lpg->create_template();
 676         $tpl2 = $lpg->create_template();
 677
 678         // Create plans with data not matching templates.
 679         $time = time();
 680         $plan1 = $lpg->create_plan(array('templateid' => $tpl1->get('id'), 'userid' => $u1->id,
 681             'name' => 'Not good name', 'duedate' => $time + 3600, 'description' => 'Ahah', 'descriptionformat' => FORMAT_MARKDOWN));
 682         $plan2 = $lpg->create_plan(array('templateid' => $tpl1->get('id'), 'userid' => $u2->id,
 683             'name' => 'Not right name', 'duedate' => $time + 3601, 'description' => 'Ahah', 'descriptionformat' => FORMAT_PLAIN));
 684         $plan3 = $lpg->create_plan(array('templateid' => $tpl2->get('id'), 'userid' => $u1->id,
 685             'name' => 'Not sweet name', 'duedate' => $time + 3602, 'description' => 'Ahah', 'descriptionformat' => FORMAT_PLAIN));
 686
 687         // Prepare our expectations.
 688         $plan1->read();
 689         $plan2->read();
 690         $plan3->read();
 691
 692         $this->assertEquals($tpl1->get('id'), $plan1->get('templateid'));
 693         $this->assertEquals($tpl1->get('id'), $plan2->get('templateid'));
 694         $this->assertEquals($tpl2->get('id'), $plan3->get('templateid'));
 695         $this->assertNotEquals($tpl1->get('shortname'), $plan1->get('name'));
 696         $this->assertNotEquals($tpl1->get('shortname'), $plan2->get('name'));
 697         $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));
 698         $this->assertNotEquals($tpl1->get('description'), $plan1->get('description'));
 699         $this->assertNotEquals($tpl1->get('description'), $plan2->get('description'));
 700         $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));
 701         $this->assertNotEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));
 702         $this->assertNotEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));
 703         $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));
 704         $this->assertNotEquals($tpl1->get('duedate'), $plan1->get('duedate'));
 705         $this->assertNotEquals($tpl1->get('duedate'), $plan2->get('duedate'));
 706         $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));
 707
 708         // Update the template without changing critical fields does not update the plans.
 709         $data = $tpl1->to_record();
 710         $data->visible = 0;
 711         api::update_template($data);
 712         $this->assertNotEquals($tpl1->get('shortname'), $plan1->get('name'));
 713         $this->assertNotEquals($tpl1->get('shortname'), $plan2->get('name'));
 714         $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));
 715         $this->assertNotEquals($tpl1->get('description'), $plan1->get('description'));
 716         $this->assertNotEquals($tpl1->get('description'), $plan2->get('description'));
 717         $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));
 718         $this->assertNotEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));
 719         $this->assertNotEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));
 720         $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));
 721         $this->assertNotEquals($tpl1->get('duedate'), $plan1->get('duedate'));
 722         $this->assertNotEquals($tpl1->get('duedate'), $plan2->get('duedate'));
 723         $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));
 724
 725         // Now really update the template.
 726         $data = $tpl1->to_record();
 727         $data->shortname = 'Awesome!';
 728         $data->description = 'This is too awesome!';
 729         $data->descriptionformat = FORMAT_HTML;
 730         $data->duedate = $time + 200;
 731         api::update_template($data);
 732         $tpl1->read();
 733
 734         // Now confirm that the right plans were updated.
 735         $plan1->read();
 736         $plan2->read();
 737         $plan3->read();
 738
 739         $this->assertEquals($tpl1->get('id'), $plan1->get('templateid'));
 740         $this->assertEquals($tpl1->get('id'), $plan2->get('templateid'));
 741         $this->assertEquals($tpl2->get('id'), $plan3->get('templateid'));
 742
 743         $this->assertEquals($tpl1->get('shortname'), $plan1->get('name'));
 744         $this->assertEquals($tpl1->get('shortname'), $plan2->get('name'));
 745         $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));
 746         $this->assertEquals($tpl1->get('description'), $plan1->get('description'));
 747         $this->assertEquals($tpl1->get('description'), $plan2->get('description'));
 748         $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));
 749         $this->assertEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));
 750         $this->assertEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));
 751         $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));
 752         $this->assertEquals($tpl1->get('duedate'), $plan1->get('duedate'));
 753         $this->assertEquals($tpl1->get('duedate'), $plan2->get('duedate'));
 754         $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));
 755     }
 756
 757     /**
 758      * Test that the method to complete a plan.
 759      *
 760      * @expectedException coding_exception
 761      */
 762     public function test_complete_plan() {
 763         global $DB;
 764
 765         $this->resetAfterTest(true);
 766         $this->setAdminUser();
 767         $dg = $this->getDataGenerator();
 768         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
 769         $user = $dg->create_user();
 770
 771         // Create a framework and assign competencies.
 772         $framework = $lpg->create_framework();
 773         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 774         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 775         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 776         $c4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
 777
 778         // Create two plans and assign competencies.
 779         $plan = $lpg->create_plan(array('userid' => $user->id));
 780         $otherplan = $lpg->create_plan(array('userid' => $user->id));
 781
 782         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c1->get('id')));
 783         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c2->get('id')));
 784         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c3->get('id')));
 785         $lpg->create_plan_competency(array('planid' => $otherplan->get('id'), 'competencyid' => $c1->get('id')));
 786
 787         $uclist = array(
 788             $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id'),
 789                 'proficiency' => true, 'grade' => 1 )),
 790             $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c2->get('id'),
 791                 'proficiency' => false, 'grade' => 2 ))
 792         );
 793
 794         $this->assertEquals(2, \core_competency\user_competency::count_records());
 795         $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
 796
 797         // Change status of the plan to complete.
 798         api::complete_plan($plan);
 799
 800         // Check that user competencies are now in user_competency_plan objects and still in user_competency.
 801         $this->assertEquals(2, \core_competency\user_competency::count_records());
 802         $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
 803
 804         $usercompetenciesplan = \core_competency\user_competency_plan::get_records();
 805
 806         $this->assertEquals($uclist[0]->get('userid'), $usercompetenciesplan[0]->get('userid'));
 807         $this->assertEquals($uclist[0]->get('competencyid'), $usercompetenciesplan[0]->get('competencyid'));
 808         $this->assertEquals($uclist[0]->get('proficiency'), (bool) $usercompetenciesplan[0]->get('proficiency'));
 809         $this->assertEquals($uclist[0]->get('grade'), $usercompetenciesplan[0]->get('grade'));
 810         $this->assertEquals($plan->get('id'), $usercompetenciesplan[0]->get('planid'));
 811
 812         $this->assertEquals($uclist[1]->get('userid'), $usercompetenciesplan[1]->get('userid'));
 813         $this->assertEquals($uclist[1]->get('competencyid'), $usercompetenciesplan[1]->get('competencyid'));
 814         $this->assertEquals($uclist[1]->get('proficiency'), (bool) $usercompetenciesplan[1]->get('proficiency'));
 815         $this->assertEquals($uclist[1]->get('grade'), $usercompetenciesplan[1]->get('grade'));
 816         $this->assertEquals($plan->get('id'), $usercompetenciesplan[1]->get('planid'));
 817
 818         $this->assertEquals($user->id, $usercompetenciesplan[2]->get('userid'));
 819         $this->assertEquals($c3->get('id'), $usercompetenciesplan[2]->get('competencyid'));
 820         $this->assertNull($usercompetenciesplan[2]->get('proficiency'));
 821         $this->assertNull($usercompetenciesplan[2]->get('grade'));
 822         $this->assertEquals($plan->get('id'), $usercompetenciesplan[2]->get('planid'));
 823
 824         // Check we can not add competency to completed plan.
 825         try {
 826             api::add_competency_to_plan($plan->get('id'), $c4->get('id'));
 827             $this->fail('We can not add competency to completed plan.');
 828         } catch (coding_exception $e) {
 829             // All good.
 830         }
 831
 832         // Check we can not remove competency to completed plan.
 833         try {
 834             api::remove_competency_from_plan($plan->get('id'), $c3->get('id'));
 835             $this->fail('We can not remove competency to completed plan.');
 836         } catch (coding_exception $e) {
 837             // All good.
 838         }
 839
 840         // Completing a plan that is completed throws an exception.
 841         api::complete_plan($plan);
 842     }
 843
 844     /**
 845      * Set-up the workflow data (review, active, ...).
 846      *
 847      * @return array
 848      */
 849     protected function setup_workflow_data() {
 850         $this->resetAfterTest();
 851
 852         $dg = $this->getDataGenerator();
 853         $user = $dg->create_user();
 854         $reviewer = $dg->create_user();
 855         $otheruser = $dg->create_user();
 856
 857         $syscontext = context_system::instance();
 858         $userrole = $dg->create_role();
 859         $reviewerrole = $dg->create_role();
 860         $otheruserrole = $dg->create_role();
 861
 862         assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $userrole, $syscontext->id);
 863         assign_capability('moodle/competency:planmanage', CAP_ALLOW, $reviewerrole, $syscontext->id);
 864         assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $reviewerrole, $syscontext->id);
 865         $dg->role_assign($userrole, $user->id, $syscontext->id);
 866         $dg->role_assign($reviewerrole, $reviewer->id, $syscontext->id);
 867         accesslib_clear_all_caches_for_unit_testing();
 868
 869         $lpg = $dg->get_plugin_generator('core_competency');
 870         $tpl = $lpg->create_template();
 871         $plan = $lpg->create_plan(array('userid' => $user->id));
 872         $tplplan = $lpg->create_plan(array('userid' => $user->id, 'templateid' => $tpl->get('id')));
 873
 874         return array(
 875             'dg' => $dg,
 876             'lpg' => $lpg,
 877             'user' => $user,
 878             'reviewer' => $reviewer,
 879             'otheruser' => $otheruser,
 880             'plan' => $plan,
 881             'tplplan' => $tplplan,
 882         );
 883     }
 884
 885     /**
 886      * Testing requesting the review of a plan.
 887      */
 888     public function test_plan_request_review() {
 889         $data = $this->setup_workflow_data();
 890         $dg = $data['dg'];
 891         $lpg = $data['lpg'];
 892         $user = $data['user'];
 893         $reviewer = $data['reviewer'];
 894         $otheruser = $data['otheruser'];
 895         $plan = $data['plan'];
 896         $tplplan = $data['tplplan'];
 897
 898         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
 899         $this->assertEquals(plan::STATUS_DRAFT, $tplplan->get('status'));
 900
 901         // Foreign user cannot do anything.
 902         $this->setUser($otheruser);
 903         try {
 904             api::plan_request_review($plan);
 905             $this->fail('The user can not read the plan.');
 906         } catch (required_capability_exception $e) {
 907             $this->assertEquals('nopermissions', $e->errorcode);
 908         }
 909
 910         // Can not change a plan based on a template.
 911         $this->setUser($user);
 912         try {
 913             api::plan_request_review($tplplan);
 914             $this->fail('The plan is based on a template.');
 915         } catch (coding_exception $e) {
 916             $this->assertRegExp('/Template plans cannot be reviewed./', $e->getMessage());
 917         }
 918
 919         // Can not send for review when not draft.
 920         $this->setUser($user);
 921         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
 922         try {
 923             api::plan_request_review($plan);
 924             $this->fail('The plan cannot be sent for review at this stage.');
 925         } catch (coding_exception $e) {
 926             $this->assertRegExp('/The plan cannot be sent for review at this stage./', $e->getMessage());
 927         }
 928
 929         // Can not send for review when not draft.
 930         $this->setUser($user);
 931         $plan->set('status', plan::STATUS_ACTIVE);
 932         try {
 933             api::plan_request_review($plan);
 934             $this->fail('The plan cannot be sent for review at this stage.');
 935         } catch (coding_exception $e) {
 936             $this->assertRegExp('/The plan cannot be sent for review at this stage./', $e->getMessage());
 937         }
 938
 939         // Can not send for review when not draft.
 940         $this->setUser($user);
 941         $plan->set('status', plan::STATUS_IN_REVIEW);
 942         try {
 943             api::plan_request_review($plan);
 944             $this->fail('The plan cannot be sent for review at this stage.');
 945         } catch (coding_exception $e) {
 946             $this->assertRegExp('/The plan cannot be sent for review at this stage./', $e->getMessage());
 947         }
 948
 949         // Can not send for review when not draft.
 950         $this->setUser($user);
 951         $plan->set('status', plan::STATUS_COMPLETE);
 952         try {
 953             api::plan_request_review($plan);
 954             $this->fail('The plan cannot be sent for review at this stage.');
 955         } catch (coding_exception $e) {
 956             $this->assertRegExp('/The plan cannot be sent for review at this stage./', $e->getMessage());
 957         }
 958
 959         // Sending for review as a reviewer.
 960         $this->setUser($reviewer);
 961         $plan->set('status', plan::STATUS_DRAFT);
 962         try {
 963             api::plan_request_review($plan);
 964             $this->fail('The user can not request a review.');
 965         } catch (required_capability_exception $e) {
 966             $this->assertEquals('nopermissions', $e->errorcode);
 967         }
 968
 969         // Sending for review.
 970         $this->setUser($user);
 971         api::plan_request_review($plan);
 972         $plan->read();
 973         $this->assertEquals(plan::STATUS_WAITING_FOR_REVIEW, $plan->get('status'));
 974
 975         // Sending for review by ID.
 976         $plan->set('status', plan::STATUS_DRAFT);
 977         $plan->update();
 978         api::plan_request_review($plan->get('id'));
 979         $plan->read();
 980         $this->assertEquals(plan::STATUS_WAITING_FOR_REVIEW, $plan->get('status'));
 981     }
 982
 983     /**
 984      * Testing cancelling the review request.
 985      */
 986     public function test_plan_cancel_review_request() {
 987         $data = $this->setup_workflow_data();
 988         $dg = $data['dg'];
 989         $lpg = $data['lpg'];
 990         $user = $data['user'];
 991         $reviewer = $data['reviewer'];
 992         $otheruser = $data['otheruser'];
 993         $plan = $data['plan'];
 994         $tplplan = $data['tplplan'];
 995
 996         // Set waiting for review.
 997         $tplplan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
 998         $tplplan->update();
 999         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1000         $plan->update();
1001
1002         // Foreign user cannot do anything.
1003         $this->setUser($otheruser);
1004         try {
1005             api::plan_cancel_review_request($plan);
1006             $this->fail('The user can not read the plan.');
1007         } catch (required_capability_exception $e) {
1008             $this->assertEquals('nopermissions', $e->errorcode);
1009         }
1010
1011         // Can not change a plan based on a template.
1012         $this->setUser($user);
1013         try {
1014             api::plan_cancel_review_request($tplplan);
1015             $this->fail('The plan is based on a template.');
1016         } catch (coding_exception $e) {
1017             $this->assertRegExp('/Template plans cannot be reviewed./', $e->getMessage());
1018         }
1019
1020         // Can not cancel review request when not waiting for review.
1021         $this->setUser($user);
1022         $plan->set('status', plan::STATUS_DRAFT);
1023         try {
1024             api::plan_cancel_review_request($plan);
1025             $this->fail('The plan cannot be sent for review at this stage.');
1026         } catch (coding_exception $e) {
1027             $this->assertRegExp('/The plan review cannot be cancelled at this stage./', $e->getMessage());
1028         }
1029
1030         // Can not cancel review request when not waiting for review.
1031         $this->setUser($user);
1032         $plan->set('status', plan::STATUS_IN_REVIEW);
1033         try {
1034             api::plan_cancel_review_request($plan);
1035             $this->fail('The plan review cannot be cancelled at this stage.');
1036         } catch (coding_exception $e) {
1037             $this->assertRegExp('/The plan review cannot be cancelled at this stage./', $e->getMessage());
1038         }
1039
1040         // Can not cancel review request when not waiting for review.
1041         $this->setUser($user);
1042         $plan->set('status', plan::STATUS_ACTIVE);
1043         try {
1044             api::plan_cancel_review_request($plan);
1045             $this->fail('The plan review cannot be cancelled at this stage.');
1046         } catch (coding_exception $e) {
1047             $this->assertRegExp('/The plan review cannot be cancelled at this stage./', $e->getMessage());
1048         }
1049
1050         // Can not cancel review request when not waiting for review.
1051         $this->setUser($user);
1052         $plan->set('status', plan::STATUS_COMPLETE);
1053         try {
1054             api::plan_cancel_review_request($plan);
1055             $this->fail('The plan review cannot be cancelled at this stage.');
1056         } catch (coding_exception $e) {
1057             $this->assertRegExp('/The plan review cannot be cancelled at this stage./', $e->getMessage());
1058         }
1059
1060         // Cancelling as a reviewer.
1061         $this->setUser($reviewer);
1062         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1063         try {
1064             api::plan_cancel_review_request($plan);
1065             $this->fail('The user can not cancel a review request.');
1066         } catch (required_capability_exception $e) {
1067             $this->assertEquals('nopermissions', $e->errorcode);
1068         }
1069
1070         // Cancelling review request.
1071         $this->setUser($user);
1072         api::plan_cancel_review_request($plan);
1073         $plan->read();
1074         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1075
1076         // Cancelling review request by ID.
1077         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1078         $plan->update();
1079         api::plan_cancel_review_request($plan->get('id'));
1080         $plan->read();
1081         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1082     }
1083
1084     /**
1085      * Testing starting the review.
1086      */
1087     public function test_plan_start_review() {
1088         $data = $this->setup_workflow_data();
1089         $dg = $data['dg'];
1090         $lpg = $data['lpg'];
1091         $user = $data['user'];
1092         $reviewer = $data['reviewer'];
1093         $otheruser = $data['otheruser'];
1094         $plan = $data['plan'];
1095         $tplplan = $data['tplplan'];
1096
1097         // Set waiting for review.
1098         $tplplan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1099         $tplplan->update();
1100         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1101         $plan->update();
1102
1103         // Foreign user cannot do anything.
1104         $this->setUser($otheruser);
1105         try {
1106             api::plan_start_review($plan);
1107             $this->fail('The user can not read the plan.');
1108         } catch (required_capability_exception $e) {
1109             $this->assertEquals('nopermissions', $e->errorcode);
1110         }
1111
1112         // Can not change a plan based on a template.
1113         $this->setUser($reviewer);
1114         try {
1115             api::plan_start_review($tplplan);
1116             $this->fail('The plan is based on a template.');
1117         } catch (coding_exception $e) {
1118             $this->assertRegExp('/Template plans cannot be reviewed./', $e->getMessage());
1119         }
1120
1121         // Can not start a review when not waiting for review.
1122         $this->setUser($reviewer);
1123         $plan->set('status', plan::STATUS_DRAFT);
1124         try {
1125             api::plan_start_review($plan);
1126             $this->fail('The plan review cannot be started at this stage.');
1127         } catch (coding_exception $e) {
1128             $this->assertRegExp('/The plan review cannot be started at this stage./', $e->getMessage());
1129         }
1130
1131         // Can not start a review when not waiting for review.
1132         $this->setUser($reviewer);
1133         $plan->set('status', plan::STATUS_IN_REVIEW);
1134         try {
1135             api::plan_start_review($plan);
1136             $this->fail('The plan review cannot be started at this stage.');
1137         } catch (coding_exception $e) {
1138             $this->assertRegExp('/The plan review cannot be started at this stage./', $e->getMessage());
1139         }
1140
1141         // Can not start a review when not waiting for review.
1142         $this->setUser($reviewer);
1143         $plan->set('status', plan::STATUS_ACTIVE);
1144         try {
1145             api::plan_start_review($plan);
1146             $this->fail('The plan review cannot be started at this stage.');
1147         } catch (coding_exception $e) {
1148             $this->assertRegExp('/The plan review cannot be started at this stage./', $e->getMessage());
1149         }
1150
1151         // Can not start a review when not waiting for review.
1152         $this->setUser($reviewer);
1153         $plan->set('status', plan::STATUS_COMPLETE);
1154         try {
1155             api::plan_start_review($plan);
1156             $this->fail('The plan review cannot be started at this stage.');
1157         } catch (coding_exception $e) {
1158             $this->assertRegExp('/The plan review cannot be started at this stage./', $e->getMessage());
1159         }
1160
1161         // Starting as the owner.
1162         $this->setUser($user);
1163         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1164         try {
1165             api::plan_start_review($plan);
1166             $this->fail('The user can not start a review.');
1167         } catch (required_capability_exception $e) {
1168             $this->assertEquals('nopermissions', $e->errorcode);
1169         }
1170
1171         // Starting review.
1172         $this->setUser($reviewer);
1173         api::plan_start_review($plan);
1174         $plan->read();
1175         $this->assertEquals(plan::STATUS_IN_REVIEW, $plan->get('status'));
1176         $this->assertEquals($reviewer->id, $plan->get('reviewerid'));
1177
1178         // Starting review by ID.
1179         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1180         $plan->set('reviewerid', null);
1181         $plan->update();
1182         api::plan_start_review($plan->get('id'));
1183         $plan->read();
1184         $this->assertEquals(plan::STATUS_IN_REVIEW, $plan->get('status'));
1185         $this->assertEquals($reviewer->id, $plan->get('reviewerid'));
1186     }
1187
1188     /**
1189      * Testing stopping the review.
1190      */
1191     public function test_plan_stop_review() {
1192         $data = $this->setup_workflow_data();
1193         $dg = $data['dg'];
1194         $lpg = $data['lpg'];
1195         $user = $data['user'];
1196         $reviewer = $data['reviewer'];
1197         $otheruser = $data['otheruser'];
1198         $plan = $data['plan'];
1199         $tplplan = $data['tplplan'];
1200
1201         // Set waiting for review.
1202         $tplplan->set('status', plan::STATUS_IN_REVIEW);
1203         $tplplan->update();
1204         $plan->set('status', plan::STATUS_IN_REVIEW);
1205         $plan->update();
1206
1207         // Foreign user cannot do anything.
1208         $this->setUser($otheruser);
1209         try {
1210             api::plan_stop_review($plan);
1211             $this->fail('The user can not read the plan.');
1212         } catch (required_capability_exception $e) {
1213             $this->assertEquals('nopermissions', $e->errorcode);
1214         }
1215
1216         // Can not change a plan based on a template.
1217         $this->setUser($reviewer);
1218         try {
1219             api::plan_stop_review($tplplan);
1220             $this->fail('The plan is based on a template.');
1221         } catch (coding_exception $e) {
1222             $this->assertRegExp('/Template plans cannot be reviewed./', $e->getMessage());
1223         }
1224
1225         // Can not stop a review whe not in review.
1226         $this->setUser($reviewer);
1227         $plan->set('status', plan::STATUS_DRAFT);
1228         try {
1229             api::plan_stop_review($plan);
1230             $this->fail('The plan review cannot be stopped at this stage.');
1231         } catch (coding_exception $e) {
1232             $this->assertRegExp('/The plan review cannot be stopped at this stage./', $e->getMessage());
1233         }
1234
1235         // Can not stop a review whe not in review.
1236         $this->setUser($reviewer);
1237         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1238         try {
1239             api::plan_stop_review($plan);
1240             $this->fail('The plan review cannot be stopped at this stage.');
1241         } catch (coding_exception $e) {
1242             $this->assertRegExp('/The plan review cannot be stopped at this stage./', $e->getMessage());
1243         }
1244
1245         // Can not stop a review whe not in review.
1246         $this->setUser($reviewer);
1247         $plan->set('status', plan::STATUS_ACTIVE);
1248         try {
1249             api::plan_stop_review($plan);
1250             $this->fail('The plan review cannot be stopped at this stage.');
1251         } catch (coding_exception $e) {
1252             $this->assertRegExp('/The plan review cannot be stopped at this stage./', $e->getMessage());
1253         }
1254
1255         // Can not stop a review whe not in review.
1256         $this->setUser($reviewer);
1257         $plan->set('status', plan::STATUS_COMPLETE);
1258         try {
1259             api::plan_stop_review($plan);
1260             $this->fail('The plan review cannot be stopped at this stage.');
1261         } catch (coding_exception $e) {
1262             $this->assertRegExp('/The plan review cannot be stopped at this stage./', $e->getMessage());
1263         }
1264
1265         // Stopping as the owner.
1266         $this->setUser($user);
1267         $plan->set('status', plan::STATUS_IN_REVIEW);
1268         try {
1269             api::plan_stop_review($plan);
1270             $this->fail('The user can not stop a review.');
1271         } catch (required_capability_exception $e) {
1272             $this->assertEquals('nopermissions', $e->errorcode);
1273         }
1274
1275         // Stopping review.
1276         $this->setUser($reviewer);
1277         api::plan_stop_review($plan);
1278         $plan->read();
1279         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1280
1281         // Stopping review by ID.
1282         $plan->set('status', plan::STATUS_IN_REVIEW);
1283         $plan->update();
1284         api::plan_stop_review($plan->get('id'));
1285         $plan->read();
1286         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1287     }
1288
1289     /**
1290      * Testing approving the plan.
1291      */
1292     public function test_approve_plan() {
1293         $data = $this->setup_workflow_data();
1294         $dg = $data['dg'];
1295         $lpg = $data['lpg'];
1296         $user = $data['user'];
1297         $reviewer = $data['reviewer'];
1298         $otheruser = $data['otheruser'];
1299         $plan = $data['plan'];
1300         $tplplan = $data['tplplan'];
1301
1302         // Set waiting for review.
1303         $tplplan->set('status', plan::STATUS_IN_REVIEW);
1304         $tplplan->update();
1305         $plan->set('status', plan::STATUS_IN_REVIEW);
1306         $plan->update();
1307
1308         // Foreign user cannot do anything.
1309         $this->setUser($otheruser);
1310         try {
1311             api::approve_plan($plan);
1312             $this->fail('The user can not read the plan.');
1313         } catch (required_capability_exception $e) {
1314             $this->assertEquals('nopermissions', $e->errorcode);
1315         }
1316
1317         // Can not change a plan based on a template.
1318         $this->setUser($reviewer);
1319         try {
1320             api::approve_plan($tplplan);
1321             $this->fail('The plan is based on a template.');
1322         } catch (coding_exception $e) {
1323             $this->assertRegExp('/Template plans are already approved./', $e->getMessage());
1324         }
1325
1326         // Can not approve a plan already approved.
1327         $this->setUser($reviewer);
1328         $plan->set('status', plan::STATUS_ACTIVE);
1329         try {
1330             api::approve_plan($plan);
1331             $this->fail('The plan cannot be approved at this stage.');
1332         } catch (coding_exception $e) {
1333             $this->assertRegExp('/The plan cannot be approved at this stage./', $e->getMessage());
1334         }
1335
1336         // Can not approve a plan already approved.
1337         $this->setUser($reviewer);
1338         $plan->set('status', plan::STATUS_COMPLETE);
1339         try {
1340             api::approve_plan($plan);
1341             $this->fail('The plan cannot be approved at this stage.');
1342         } catch (coding_exception $e) {
1343             $this->assertRegExp('/The plan cannot be approved at this stage./', $e->getMessage());
1344         }
1345
1346         // Approve as the owner.
1347         $this->setUser($user);
1348         $plan->set('status', plan::STATUS_IN_REVIEW);
1349         try {
1350             api::approve_plan($plan);
1351             $this->fail('The user can not approve the plan.');
1352         } catch (required_capability_exception $e) {
1353             $this->assertEquals('nopermissions', $e->errorcode);
1354         }
1355
1356         // Approve plan from in review.
1357         $this->setUser($reviewer);
1358         api::approve_plan($plan);
1359         $plan->read();
1360         $this->assertEquals(plan::STATUS_ACTIVE, $plan->get('status'));
1361
1362         // Approve plan by ID.
1363         $plan->set('status', plan::STATUS_IN_REVIEW);
1364         $plan->update();
1365         api::approve_plan($plan->get('id'));
1366         $plan->read();
1367         $this->assertEquals(plan::STATUS_ACTIVE, $plan->get('status'));
1368
1369         // Approve plan from draft.
1370         $plan->set('status', plan::STATUS_DRAFT);
1371         $plan->update();
1372         api::approve_plan($plan);
1373         $plan->read();
1374         $this->assertEquals(plan::STATUS_ACTIVE, $plan->get('status'));
1375
1376         // Approve plan from waiting for review.
1377         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1378         $plan->update();
1379         api::approve_plan($plan);
1380         $plan->read();
1381         $this->assertEquals(plan::STATUS_ACTIVE, $plan->get('status'));
1382     }
1383
1384     /**
1385      * Testing stopping the review.
1386      */
1387     public function test_unapprove_plan() {
1388         $data = $this->setup_workflow_data();
1389         $dg = $data['dg'];
1390         $lpg = $data['lpg'];
1391         $user = $data['user'];
1392         $reviewer = $data['reviewer'];
1393         $otheruser = $data['otheruser'];
1394         $plan = $data['plan'];
1395         $tplplan = $data['tplplan'];
1396
1397         // Set waiting for review.
1398         $tplplan->set('status', plan::STATUS_ACTIVE);
1399         $tplplan->update();
1400         $plan->set('status', plan::STATUS_ACTIVE);
1401         $plan->update();
1402
1403         // Foreign user cannot do anything.
1404         $this->setUser($otheruser);
1405         try {
1406             api::unapprove_plan($plan);
1407             $this->fail('The user can not read the plan.');
1408         } catch (required_capability_exception $e) {
1409             $this->assertEquals('nopermissions', $e->errorcode);
1410         }
1411
1412         // Can not change a plan based on a template.
1413         $this->setUser($reviewer);
1414         try {
1415             api::unapprove_plan($tplplan);
1416             $this->fail('The plan is based on a template.');
1417         } catch (coding_exception $e) {
1418             $this->assertRegExp('/Template plans are always approved./', $e->getMessage());
1419         }
1420
1421         // Can not unapprove a non-draft plan.
1422         $this->setUser($reviewer);
1423         $plan->set('status', plan::STATUS_DRAFT);
1424         try {
1425             api::unapprove_plan($plan);
1426             $this->fail('The plan cannot be sent back to draft at this stage.');
1427         } catch (coding_exception $e) {
1428             $this->assertRegExp('/The plan cannot be sent back to draft at this stage./', $e->getMessage());
1429         }
1430
1431         // Can not unapprove a non-draft plan.
1432         $this->setUser($reviewer);
1433         $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);
1434         try {
1435             api::unapprove_plan($plan);
1436             $this->fail('The plan cannot be sent back to draft at this stage.');
1437         } catch (coding_exception $e) {
1438             $this->assertRegExp('/The plan cannot be sent back to draft at this stage./', $e->getMessage());
1439         }
1440
1441         // Can not unapprove a non-draft plan.
1442         $this->setUser($reviewer);
1443         $plan->set('status', plan::STATUS_IN_REVIEW);
1444         try {
1445             api::unapprove_plan($plan);
1446             $this->fail('The plan cannot be sent back to draft at this stage.');
1447         } catch (coding_exception $e) {
1448             $this->assertRegExp('/The plan cannot be sent back to draft at this stage./', $e->getMessage());
1449         }
1450
1451         // Can not unapprove a non-draft plan.
1452         $this->setUser($reviewer);
1453         $plan->set('status', plan::STATUS_COMPLETE);
1454         try {
1455             api::unapprove_plan($plan);
1456             $this->fail('The plan cannot be sent back to draft at this stage.');
1457         } catch (coding_exception $e) {
1458             $this->assertRegExp('/The plan cannot be sent back to draft at this stage./', $e->getMessage());
1459         }
1460
1461         // Unapprove as the owner.
1462         $this->setUser($user);
1463         $plan->set('status', plan::STATUS_ACTIVE);
1464         try {
1465             api::unapprove_plan($plan);
1466             $this->fail('The user can not unapprove the plan.');
1467         } catch (required_capability_exception $e) {
1468             $this->assertEquals('nopermissions', $e->errorcode);
1469         }
1470
1471         // Unapprove plan.
1472         $this->setUser($reviewer);
1473         api::unapprove_plan($plan);
1474         $plan->read();
1475         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1476
1477         // Unapprove plan by ID.
1478         $plan->set('status', plan::STATUS_ACTIVE);
1479         $plan->update();
1480         api::unapprove_plan($plan->get('id'));
1481         $plan->read();
1482         $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));
1483     }
1484
1485     /**
1486      * Test update plan and the managing of archived user competencies.
1487      */
1488     public function test_update_plan_manage_archived_competencies() {
1489         global $DB;
1490
1491         $this->resetAfterTest(true);
1492         $dg = $this->getDataGenerator();
1493         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1494
1495         $syscontext = context_system::instance();
1496
1497         // Create users and roles for the test.
1498         $user = $dg->create_user();
1499         $manageownrole = $dg->create_role(array(
1500             'name' => 'User manage own',
1501             'shortname' => 'manageown'
1502         ));
1503         assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $manageownrole, $syscontext->id);
1504         assign_capability('moodle/competency:planviewowndraft', CAP_ALLOW, $manageownrole, $syscontext->id);
1505         assign_capability('moodle/competency:planmanageown', CAP_ALLOW, $manageownrole, $syscontext->id);
1506         assign_capability('moodle/competency:planviewown', CAP_ALLOW, $manageownrole, $syscontext->id);
1507         $dg->role_assign($manageownrole, $user->id, $syscontext->id);
1508         $this->setUser($user);
1509
1510         // Create a framework and assign competencies.
1511         $framework = $lpg->create_framework();
1512         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1513         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1514         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1515
1516         // Create two plans and assign competencies.
1517         $plan = $lpg->create_plan(array('userid' => $user->id));
1518         $otherplan = $lpg->create_plan(array('userid' => $user->id));
1519
1520         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c1->get('id')));
1521         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c2->get('id')));
1522         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c3->get('id')));
1523         $lpg->create_plan_competency(array('planid' => $otherplan->get('id'), 'competencyid' => $c1->get('id')));
1524
1525         $uclist = array(
1526             $lpg->create_user_competency(array(
1527                                             'userid' => $user->id,
1528                                             'competencyid' => $c1->get('id'),
1529                                             'proficiency' => true,
1530                                             'grade' => 1
1531                                         )),
1532             $lpg->create_user_competency(array(
1533                                             'userid' => $user->id,
1534                                             'competencyid' => $c2->get('id'),
1535                                             'proficiency' => false,
1536                                             'grade' => 2
1537                                         ))
1538         );
1539
1540         // Change status of the plan to complete.
1541         $record = $plan->to_record();
1542         $record->status = \core_competency\plan::STATUS_COMPLETE;
1543
1544         try {
1545             $plan = api::update_plan($record);
1546             $this->fail('We cannot complete a plan using api::update_plan().');
1547         } catch (coding_exception $e) {
1548             // All good.
1549         }
1550         api::complete_plan($plan);
1551
1552         // Check that user compretencies are now in user_competency_plan objects and still in user_competency.
1553         $this->assertEquals(2, \core_competency\user_competency::count_records());
1554         $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
1555
1556         $usercompetenciesplan = \core_competency\user_competency_plan::get_records();
1557
1558         $this->assertEquals($uclist[0]->get('userid'), $usercompetenciesplan[0]->get('userid'));
1559         $this->assertEquals($uclist[0]->get('competencyid'), $usercompetenciesplan[0]->get('competencyid'));
1560         $this->assertEquals($uclist[0]->get('proficiency'), (bool) $usercompetenciesplan[0]->get('proficiency'));
1561         $this->assertEquals($uclist[0]->get('grade'), $usercompetenciesplan[0]->get('grade'));
1562         $this->assertEquals($plan->get('id'), $usercompetenciesplan[0]->get('planid'));
1563
1564         $this->assertEquals($uclist[1]->get('userid'), $usercompetenciesplan[1]->get('userid'));
1565         $this->assertEquals($uclist[1]->get('competencyid'), $usercompetenciesplan[1]->get('competencyid'));
1566         $this->assertEquals($uclist[1]->get('proficiency'), (bool) $usercompetenciesplan[1]->get('proficiency'));
1567         $this->assertEquals($uclist[1]->get('grade'), $usercompetenciesplan[1]->get('grade'));
1568         $this->assertEquals($plan->get('id'), $usercompetenciesplan[1]->get('planid'));
1569
1570         $this->assertEquals($user->id, $usercompetenciesplan[2]->get('userid'));
1571         $this->assertEquals($c3->get('id'), $usercompetenciesplan[2]->get('competencyid'));
1572         $this->assertNull($usercompetenciesplan[2]->get('proficiency'));
1573         $this->assertNull($usercompetenciesplan[2]->get('grade'));
1574         $this->assertEquals($plan->get('id'), $usercompetenciesplan[2]->get('planid'));
1575
1576         // Change status of the plan to active.
1577         $record = $plan->to_record();
1578         $record->status = \core_competency\plan::STATUS_ACTIVE;
1579
1580         try {
1581             api::update_plan($record);
1582             $this->fail('Completed plan can not be edited');
1583         } catch (coding_exception $e) {
1584             // All good.
1585         }
1586
1587         api::reopen_plan($record->id);
1588         // Check that user_competency_plan objects are deleted if the plan status is changed to another status.
1589         $this->assertEquals(2, \core_competency\user_competency::count_records());
1590         $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
1591     }
1592
1593     /**
1594      * Test completing plan does not change the order of competencies.
1595      */
1596     public function test_complete_plan_doesnot_change_order() {
1597         global $DB;
1598
1599         $this->resetAfterTest(true);
1600         $this->setAdminUser();
1601         $dg = $this->getDataGenerator();
1602         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1603
1604         $syscontext = context_system::instance();
1605
1606         // Create users and roles for the test.
1607         $user = $dg->create_user();
1608
1609         // Create a framework and assign competencies.
1610         $framework = $lpg->create_framework();
1611         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1612         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1613         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1614
1615         // Create two plans and assign competencies.
1616         $plan = $lpg->create_plan(array('userid' => $user->id));
1617
1618         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c1->get('id')));
1619         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c2->get('id')));
1620         $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c3->get('id')));
1621
1622         // Changing competencies order in plan competency.
1623         api::reorder_plan_competency($plan->get('id'), $c1->get('id'), $c3->get('id'));
1624
1625         $competencies = api::list_plan_competencies($plan);
1626         $this->assertEquals($c2->get('id'), $competencies[0]->competency->get('id'));
1627         $this->assertEquals($c3->get('id'), $competencies[1]->competency->get('id'));
1628         $this->assertEquals($c1->get('id'), $competencies[2]->competency->get('id'));
1629
1630         // Completing plan.
1631         api::complete_plan($plan);
1632
1633         $competencies = api::list_plan_competencies($plan);
1634
1635         // Completing plan does not change order.
1636         $this->assertEquals($c2->get('id'), $competencies[0]->competency->get('id'));
1637         $this->assertEquals($c3->get('id'), $competencies[1]->competency->get('id'));
1638         $this->assertEquals($c1->get('id'), $competencies[2]->competency->get('id'));
1639
1640         // Testing plan based on template.
1641         $template = $lpg->create_template();
1642         $framework = $lpg->create_framework();
1643         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1644         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1645         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1646
1647         $lpg->create_template_competency(array(
1648             'templateid' => $template->get('id'),
1649             'competencyid' => $c1->get('id')
1650         ));
1651         $lpg->create_template_competency(array(
1652             'templateid' => $template->get('id'),
1653             'competencyid' => $c2->get('id')
1654         ));
1655         $lpg->create_template_competency(array(
1656             'templateid' => $template->get('id'),
1657             'competencyid' => $c3->get('id')
1658         ));
1659         // Reorder competencies in template.
1660         api::reorder_template_competency($template->get('id'), $c1->get('id'), $c3->get('id'));
1661
1662         // Create plan from template.
1663         $plan = api::create_plan_from_template($template->get('id'), $user->id);
1664
1665         $competencies = api::list_plan_competencies($plan);
1666
1667         // Completing plan does not change order.
1668         $this->assertEquals($c2->get('id'), $competencies[0]->competency->get('id'));
1669         $this->assertEquals($c3->get('id'), $competencies[1]->competency->get('id'));
1670         $this->assertEquals($c1->get('id'), $competencies[2]->competency->get('id'));
1671
1672         // Completing plan.
1673         api::complete_plan($plan);
1674
1675         $competencies = api::list_plan_competencies($plan);
1676
1677         // Completing plan does not change order.
1678         $this->assertEquals($c2->get('id'), $competencies[0]->competency->get('id'));
1679         $this->assertEquals($c3->get('id'), $competencies[1]->competency->get('id'));
1680         $this->assertEquals($c1->get('id'), $competencies[2]->competency->get('id'));
1681     }
1682
1683     /**
1684      * Test remove plan and the managing of archived user competencies.
1685      */
1686     public function test_delete_plan_manage_archived_competencies() {
1687         $this->resetAfterTest(true);
1688         $dg = $this->getDataGenerator();
1689         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1690
1691         $syscontext = context_system::instance();
1692
1693         // Create user and role for the test.
1694         $user = $dg->create_user();
1695         $managerole = $dg->create_role(array(
1696             'name' => 'User manage own',
1697             'shortname' => 'manageown'
1698         ));
1699         assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $managerole, $syscontext->id);
1700         assign_capability('moodle/competency:planmanageown', CAP_ALLOW, $managerole, $syscontext->id);
1701         $dg->role_assign($managerole, $user->id, $syscontext->id);
1702         $this->setUser($user);
1703
1704         // Create a framework and assign competencies.
1705         $framework = $lpg->create_framework();
1706         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1707         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1708         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1709
1710         // Create completed plan with records in user_competency.
1711         $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
1712
1713         $lpg->create_plan_competency(array('planid' => $completedplan->get('id'), 'competencyid' => $c1->get('id')));
1714         $lpg->create_plan_competency(array('planid' => $completedplan->get('id'), 'competencyid' => $c2->get('id')));
1715
1716         $uc1 = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id')));
1717         $uc2 = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c2->get('id')));
1718
1719         $ucp1 = $lpg->create_user_competency_plan(array('userid' => $user->id, 'competencyid' => $c1->get('id'),
1720                 'planid' => $completedplan->get('id')));
1721         $ucp2 = $lpg->create_user_competency_plan(array('userid' => $user->id, 'competencyid' => $c2->get('id'),
1722                 'planid' => $completedplan->get('id')));
1723
1724         api::delete_plan($completedplan->get('id'));
1725
1726         // Check that achived user competencies are deleted.
1727         $this->assertEquals(0, \core_competency\plan::count_records());
1728         $this->assertEquals(2, \core_competency\user_competency::count_records());
1729         $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
1730     }
1731
1732     /**
1733      * Test listing of plan competencies.
1734      */
1735     public function test_list_plan_competencies_manage_archived_competencies() {
1736         $this->resetAfterTest(true);
1737         $dg = $this->getDataGenerator();
1738         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1739
1740         $syscontext = context_system::instance();
1741
1742         // Create user and role for the test.
1743         $user = $dg->create_user();
1744         $viewrole = $dg->create_role(array(
1745             'name' => 'User view',
1746             'shortname' => 'view'
1747         ));
1748         assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $viewrole, $syscontext->id);
1749         assign_capability('moodle/competency:planview', CAP_ALLOW, $viewrole, $syscontext->id);
1750         $dg->role_assign($viewrole, $user->id, $syscontext->id);
1751         $this->setUser($user);
1752
1753         // Create a framework and assign competencies.
1754         $framework = $lpg->create_framework();
1755         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1756         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1757         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1758
1759         // Create draft plan with records in user_competency.
1760         $draftplan = $lpg->create_plan(array('userid' => $user->id));
1761
1762         $lpg->create_plan_competency(array('planid' => $draftplan->get('id'), 'competencyid' => $c1->get('id')));
1763         $lpg->create_plan_competency(array('planid' => $draftplan->get('id'), 'competencyid' => $c2->get('id')));
1764         $lpg->create_plan_competency(array('planid' => $draftplan->get('id'), 'competencyid' => $c3->get('id')));
1765
1766         $uc1 = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id')));
1767         $uc2 = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c2->get('id')));
1768
1769         // Check that user_competency objects are returned when plan status is not complete.
1770         $plancompetencies = api::list_plan_competencies($draftplan);
1771
1772         $this->assertCount(3, $plancompetencies);
1773         $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[0]->usercompetency);
1774         $this->assertEquals($uc1->get('id'), $plancompetencies[0]->usercompetency->get('id'));
1775         $this->assertNull($plancompetencies[0]->usercompetencyplan);
1776
1777         $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[1]->usercompetency);
1778         $this->assertEquals($uc2->get('id'), $plancompetencies[1]->usercompetency->get('id'));
1779         $this->assertNull($plancompetencies[1]->usercompetencyplan);
1780
1781         $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[2]->usercompetency);
1782         $this->assertEquals(0, $plancompetencies[2]->usercompetency->get('id'));
1783         $this->assertNull($plancompetencies[2]->usercompetencyplan);
1784
1785         // Create completed plan with records in user_competency_plan.
1786         $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
1787
1788         $pc1 = $lpg->create_plan_competency(array('planid' => $completedplan->get('id'), 'competencyid' => $c1->get('id')));
1789         $pc2 = $lpg->create_plan_competency(array('planid' => $completedplan->get('id'), 'competencyid' => $c2->get('id')));
1790         $pc3 = $lpg->create_plan_competency(array('planid' => $completedplan->get('id'), 'competencyid' => $c3->get('id')));
1791
1792         $ucp1 = $lpg->create_user_competency_plan(array('userid' => $user->id, 'competencyid' => $c1->get('id'),
1793                 'planid' => $completedplan->get('id')));
1794         $ucp2 = $lpg->create_user_competency_plan(array('userid' => $user->id, 'competencyid' => $c2->get('id'),
1795                 'planid' => $completedplan->get('id')));
1796         $ucp3 = $lpg->create_user_competency_plan(array('userid' => $user->id, 'competencyid' => $c3->get('id'),
1797                 'planid' => $completedplan->get('id')));
1798
1799         // Check that user_competency_plan objects are returned when plan status is complete.
1800         $plancompetencies = api::list_plan_competencies($completedplan);
1801
1802         $this->assertCount(3, $plancompetencies);
1803         $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[0]->usercompetencyplan);
1804         $this->assertEquals($ucp1->get('id'), $plancompetencies[0]->usercompetencyplan->get('id'));
1805         $this->assertNull($plancompetencies[0]->usercompetency);
1806         $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[1]->usercompetencyplan);
1807         $this->assertEquals($ucp2->get('id'), $plancompetencies[1]->usercompetencyplan->get('id'));
1808         $this->assertNull($plancompetencies[1]->usercompetency);
1809         $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[2]->usercompetencyplan);
1810         $this->assertEquals($ucp3->get('id'), $plancompetencies[2]->usercompetencyplan->get('id'));
1811         $this->assertNull($plancompetencies[2]->usercompetency);
1812     }
1813
1814     public function test_create_template_cohort() {
1815         $this->resetAfterTest(true);
1816         $this->setAdminUser();
1817
1818         $dg = $this->getDataGenerator();
1819         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1820
1821         $c1 = $dg->create_cohort();
1822         $c2 = $dg->create_cohort();
1823         $t1 = $lpg->create_template();
1824         $t2 = $lpg->create_template();
1825
1826         $this->assertEquals(0, \core_competency\template_cohort::count_records());
1827
1828         // Create two relations with mixed parameters.
1829         $result = api::create_template_cohort($t1->get('id'), $c1->id);
1830         $result = api::create_template_cohort($t1, $c2);
1831
1832         $this->assertEquals(2, \core_competency\template_cohort::count_records());
1833         $this->assertInstanceOf('core_competency\template_cohort', $result);
1834         $this->assertEquals($c2->id, $result->get('cohortid'));
1835         $this->assertEquals($t1->get('id'), $result->get('templateid'));
1836         $this->assertEquals(2, \core_competency\template_cohort::count_records_select('templateid = :id',
1837             array('id' => $t1->get('id'))));
1838         $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id',
1839             array('id' => $t2->get('id'))));
1840     }
1841
1842     public function test_create_template_cohort_permissions() {
1843         $this->resetAfterTest(true);
1844
1845         $dg = $this->getDataGenerator();
1846         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1847         $cat = $dg->create_category();
1848         $catcontext = context_coursecat::instance($cat->id);
1849         $syscontext = context_system::instance();
1850
1851         $user = $dg->create_user();
1852         $role = $dg->create_role();
1853         assign_capability('moodle/competency:templatemanage', CAP_ALLOW, $role, $syscontext->id, true);
1854         $dg->role_assign($role, $user->id, $syscontext->id);
1855
1856         $cohortrole = $dg->create_role();
1857         assign_capability('moodle/cohort:view', CAP_ALLOW, $cohortrole, $syscontext->id, true);
1858
1859         accesslib_clear_all_caches_for_unit_testing();
1860
1861         $c1 = $dg->create_cohort();
1862         $c2 = $dg->create_cohort(array('visible' => 0, 'contextid' => $catcontext->id));
1863         $t1 = $lpg->create_template();
1864
1865         $this->assertEquals(0, \core_competency\template_cohort::count_records());
1866
1867         $this->setUser($user);
1868         $result = api::create_template_cohort($t1, $c1);
1869         $this->assertInstanceOf('core_competency\\template_cohort', $result);
1870
1871         try {
1872             $result = api::create_template_cohort($t1, $c2);
1873             $this->fail('Permission required.');
1874         } catch (required_capability_exception $e) {
1875             // That's what should happen.
1876         }
1877
1878         // Try again with the right permissions.
1879         $dg->role_assign($cohortrole, $user->id, $catcontext->id);
1880         accesslib_clear_all_caches_for_unit_testing();
1881
1882         $result = api::create_template_cohort($t1, $c2);
1883         $this->assertInstanceOf('core_competency\\template_cohort', $result);
1884     }
1885
1886     public function test_reorder_template_competencies_permissions() {
1887         $this->resetAfterTest(true);
1888
1889         $dg = $this->getDataGenerator();
1890         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1891         $cat = $dg->create_category();
1892         $catcontext = context_coursecat::instance($cat->id);
1893         $syscontext = context_system::instance();
1894
1895         $user = $dg->create_user();
1896         $role = $dg->create_role();
1897         assign_capability('moodle/competency:templatemanage', CAP_ALLOW, $role, $syscontext->id, true);
1898         $dg->role_assign($role, $user->id, $syscontext->id);
1899
1900         // Create a template.
1901         $template = $lpg->create_template(array('contextid' => $catcontext->id));
1902
1903         // Create a competency framework.
1904         $framework = $lpg->create_framework(array('contextid' => $catcontext->id));
1905
1906         // Create competencies.
1907         $competency1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1908         $competency2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
1909
1910         // Add the competencies.
1911         $lpg->create_template_competency(array(
1912             'templateid' => $template->get('id'),
1913             'competencyid' => $competency1->get('id')
1914         ));
1915         $lpg->create_template_competency(array(
1916             'templateid' => $template->get('id'),
1917             'competencyid' => $competency2->get('id')
1918         ));
1919         $this->setUser($user);
1920         // Can reorder competencies with system context permissions in category context.
1921         $result = api::reorder_template_competency($template->get('id'), $competency2->get('id'), $competency1->get('id'));
1922         $this->assertTrue($result);
1923         unassign_capability('moodle/competency:templatemanage', $role, $syscontext->id);
1924         accesslib_clear_all_caches_for_unit_testing();
1925
1926         try {
1927             api::reorder_template_competency($template->get('id'), $competency2->get('id'), $competency1->get('id'));
1928             $this->fail('Exception expected due to not permissions to manage template competencies');
1929         } catch (required_capability_exception $e) {
1930             $this->assertEquals('nopermissions', $e->errorcode);
1931         }
1932
1933         // Giving permissions in category context.
1934         assign_capability('moodle/competency:templatemanage', CAP_ALLOW, $role, $catcontext->id, true);
1935         $dg->role_assign($role, $user->id, $catcontext->id);
1936         // User with templatemanage capability in category context can reorder competencies in temple.
1937         $result = api::reorder_template_competency($template->get('id'), $competency1->get('id'), $competency2->get('id'));
1938         $this->assertTrue($result);
1939         // Removing templatemanage capability in category context.
1940         unassign_capability('moodle/competency:templatemanage', $role, $catcontext->id);
1941         accesslib_clear_all_caches_for_unit_testing();
1942
1943         try {
1944             api::reorder_template_competency($template->get('id'), $competency2->get('id'), $competency1->get('id'));
1945             $this->fail('Exception expected due to not permissions to manage template competencies');
1946         } catch (required_capability_exception $e) {
1947             $this->assertEquals('nopermissions', $e->errorcode);
1948         }
1949     }
1950
1951     public function test_delete_template() {
1952         $this->resetAfterTest(true);
1953         $this->setAdminUser();
1954
1955         $dg = $this->getDataGenerator();
1956         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1957
1958         $c1 = $dg->create_cohort();
1959         $c2 = $dg->create_cohort();
1960         $template = $lpg->create_template();
1961         $id = $template->get('id');
1962
1963         // Create 2 template cohorts.
1964         $tc1 = $lpg->create_template_cohort(array('templateid' => $template->get('id'), 'cohortid' => $c1->id));
1965         $tc1 = $lpg->create_template_cohort(array('templateid' => $template->get('id'), 'cohortid' => $c2->id));
1966
1967         // Check pre-test.
1968         $this->assertTrue(\core_competency\template::record_exists($id));
1969         $this->assertEquals(2, \core_competency\template_cohort::count_records(array('templateid' => $id)));
1970
1971         $result = api::delete_template($template->get('id'));
1972         $this->assertTrue($result);
1973
1974         // Check that the template deos not exist anymore.
1975         $this->assertFalse(\core_competency\template::record_exists($id));
1976
1977         // Test if associated cohorts are also deleted.
1978         $this->assertEquals(0, \core_competency\template_cohort::count_records(array('templateid' => $id)));
1979     }
1980
1981     public function test_delete_template_cohort() {
1982         $this->resetAfterTest(true);
1983         $this->setAdminUser();
1984
1985         $dg = $this->getDataGenerator();
1986         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
1987
1988         $c1 = $dg->create_cohort();
1989         $c2 = $dg->create_cohort();
1990         $t1 = $lpg->create_template();
1991         $t2 = $lpg->create_template();
1992         $tc1 = $lpg->create_template_cohort(array('templateid' => $t1->get('id'), 'cohortid' => $c1->id));
1993         $tc1 = $lpg->create_template_cohort(array('templateid' => $t2->get('id'), 'cohortid' => $c2->id));
1994
1995         $this->assertEquals(2, \core_competency\template_cohort::count_records());
1996         $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id',
1997             array('id' => $t1->get('id'))));
1998         $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id',
1999             array('id' => $t2->get('id'))));
2000
2001         // Delete existing.
2002         $result = api::delete_template_cohort($t1->get('id'), $c1->id);
2003         $this->assertTrue($result);
2004         $this->assertEquals(1, \core_competency\template_cohort::count_records());
2005         $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id',
2006             array('id' => $t1->get('id'))));
2007         $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id',
2008             array('id' => $t2->get('id'))));
2009
2010         // Delete non-existant.
2011         $result = api::delete_template_cohort($t1->get('id'), $c1->id);
2012         $this->assertTrue($result);
2013         $this->assertEquals(1, \core_competency\template_cohort::count_records());
2014         $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id',
2015             array('id' => $t1->get('id'))));
2016         $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id',
2017             array('id' => $t2->get('id'))));
2018     }
2019
2020     public function test_add_evidence_log() {
2021         $this->resetAfterTest(true);
2022         $dg = $this->getDataGenerator();
2023         $lpg = $dg->get_plugin_generator('core_competency');
2024
2025         $u1 = $dg->create_user();
2026         $u1ctx = context_user::instance($u1->id);
2027         $f1 = $lpg->create_framework();
2028         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2029         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2030
2031         // Creating a standard evidence with minimal information.
2032         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG,
2033             'invaliddata', 'error');
2034         $evidence->read();
2035         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2036         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2037         $this->assertSame(null, $uc->get('grade'));
2038         $this->assertSame(null, $uc->get('proficiency'));
2039         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2040         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2041         $this->assertEquals(\core_competency\evidence::ACTION_LOG, $evidence->get('action'));
2042         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2043         $this->assertEquals('error', $evidence->get('desccomponent'));
2044         $this->assertSame(null, $evidence->get('desca'));
2045         $this->assertSame(null, $evidence->get('url'));
2046         $this->assertSame(null, $evidence->get('grade'));
2047         $this->assertSame(null, $evidence->get('actionuserid'));
2048
2049         // Creating a standard evidence with more information.
2050         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2051             'error', '$a', false, 'http://moodle.org', null, 2, 'The evidence of prior learning were reviewed.');
2052         $evidence->read();
2053         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2054         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2055         $this->assertSame(null, $uc->get('grade'));
2056         $this->assertSame(null, $uc->get('proficiency'));
2057         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2058         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2059         $this->assertEquals(\core_competency\evidence::ACTION_LOG, $evidence->get('action'));
2060         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2061         $this->assertEquals('error', $evidence->get('desccomponent'));
2062         $this->assertEquals('$a', $evidence->get('desca'));
2063         $this->assertEquals('http://moodle.org', $evidence->get('url'));
2064         $this->assertSame(null, $evidence->get('grade'));
2065         $this->assertEquals(2, $evidence->get('actionuserid'));
2066         $this->assertSame('The evidence of prior learning were reviewed.', $evidence->get('note'));
2067
2068         // Creating a standard evidence and send for review.
2069         $evidence = api::add_evidence($u1->id, $c2->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2070             'error', null, true);
2071         $evidence->read();
2072         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get('id')));
2073         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get('status'));
2074
2075         // Trying to pass a grade should fail.
2076         try {
2077             $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2078                 'error', null, false, null, 1);
2079             $this->fail('A grade can not be set');
2080         } catch (coding_exception $e) {
2081             $this->assertRegExp('/grade MUST NOT be set/', $e->getMessage());
2082         }
2083     }
2084
2085     public function test_add_evidence_complete() {
2086         $this->resetAfterTest(true);
2087         $dg = $this->getDataGenerator();
2088         $lpg = $dg->get_plugin_generator('core_competency');
2089
2090         $u1 = $dg->create_user();
2091         $u1ctx = context_user::instance($u1->id);
2092         $scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
2093         $scaleconfig = array(array('scaleid' => $scale->id));
2094         $scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
2095         $scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
2096         $scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
2097         $c2scaleconfig = array(array('scaleid' => $scale->id));
2098         $c2scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 0, 'proficient' => 1);
2099         $c2scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 0);
2100         $c2scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 1, 'proficient' => 1);
2101         $f1 = $lpg->create_framework(array('scaleid' => $scale->id, 'scaleconfiguration' => $scaleconfig));
2102         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2103         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'scaleid' => $scale->id,
2104             'scaleconfiguration' => $c2scaleconfig));
2105         $c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2106
2107         // Creating an evidence with minimal information.
2108         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
2109             'error');
2110         $evidence->read();
2111         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2112         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2113         $this->assertEquals(2, $uc->get('grade'));    // The grade has been set automatically to the framework default.
2114         $this->assertEquals(0, $uc->get('proficiency'));
2115         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2116         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2117         $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get('action'));
2118         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2119         $this->assertEquals('error', $evidence->get('desccomponent'));
2120         $this->assertSame(null, $evidence->get('desca'));
2121         $this->assertSame(null, $evidence->get('url'));
2122         $this->assertEquals(2, $evidence->get('grade'));
2123         $this->assertSame(null, $evidence->get('actionuserid'));
2124
2125         // Creating an evidence complete on competency with custom scale.
2126         $evidence = api::add_evidence($u1->id, $c2->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
2127             'error');
2128         $evidence->read();
2129         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get('id')));
2130         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2131         $this->assertEquals(4, $uc->get('grade'));    // The grade has been set automatically to the competency default.
2132         $this->assertEquals(true, $uc->get('proficiency'));
2133         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2134         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2135         $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get('action'));
2136         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2137         $this->assertEquals('error', $evidence->get('desccomponent'));
2138         $this->assertSame(null, $evidence->get('desca'));
2139         $this->assertSame(null, $evidence->get('url'));
2140         $this->assertEquals(4, $evidence->get('grade'));
2141         $this->assertSame(null, $evidence->get('actionuserid'));
2142
2143         // Creating an evidence complete on a user competency with an existing grade.
2144         $uc = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c3->get('id'), 'grade' => 1,
2145             'proficiency' => 0));
2146         $this->assertEquals(1, $uc->get('grade'));
2147         $this->assertEquals(0, $uc->get('proficiency'));
2148         $evidence = api::add_evidence($u1->id, $c3->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
2149             'error');
2150         $evidence->read();
2151         $uc->read();
2152         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2153         $this->assertEquals(1, $uc->get('grade'));    // The grade has not been changed.
2154         $this->assertEquals(0, $uc->get('proficiency'));
2155         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2156         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2157         $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get('action'));
2158         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2159         $this->assertEquals('error', $evidence->get('desccomponent'));
2160         $this->assertSame(null, $evidence->get('desca'));
2161         $this->assertSame(null, $evidence->get('url'));
2162         $this->assertEquals(2, $evidence->get('grade'));     // The complete grade has been set.
2163         $this->assertSame(null, $evidence->get('actionuserid'));
2164
2165         // Creating a standard evidence and send for review.
2166         $evidence = api::add_evidence($u1->id, $c2->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
2167             'error', null, true);
2168         $evidence->read();
2169         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get('id')));
2170         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get('status'));
2171
2172         // Trying to pass a grade should throw an exception.
2173         try {
2174             api::add_evidence($u1->id, $c2->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
2175                 'error', null, false, null, 1);
2176         } catch (coding_exception $e) {
2177             $this->assertRegExp('/grade MUST NOT be set/', $e->getMessage());
2178         }
2179     }
2180
2181     public function test_add_evidence_override() {
2182         $this->resetAfterTest(true);
2183         $dg = $this->getDataGenerator();
2184         $lpg = $dg->get_plugin_generator('core_competency');
2185
2186         $u1 = $dg->create_user();
2187         $u1ctx = context_user::instance($u1->id);
2188         $f1 = $lpg->create_framework();
2189         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2190
2191         // Creating an evidence with minimal information.
2192         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
2193             'error');
2194         $evidence->read();
2195         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2196         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2197         $this->assertSame(null, $uc->get('grade'));      // We overrode with 'null'.
2198         $this->assertSame(null, $uc->get('proficiency'));
2199         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2200         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2201         $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get('action'));
2202         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2203         $this->assertEquals('error', $evidence->get('desccomponent'));
2204         $this->assertSame(null, $evidence->get('desca'));
2205         $this->assertSame(null, $evidence->get('url'));
2206         $this->assertSame(null, $evidence->get('grade')); // We overrode with 'null'.
2207         $this->assertSame(null, $evidence->get('actionuserid'));
2208
2209         // Creating an evidence with a grade information.
2210         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
2211             'error', null, false, null, 3);
2212         $evidence->read();
2213         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2214         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2215         $this->assertEquals(3, $uc->get('grade'));
2216         $this->assertEquals(true, $uc->get('proficiency'));
2217         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2218         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2219         $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get('action'));
2220         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2221         $this->assertEquals('error', $evidence->get('desccomponent'));
2222         $this->assertSame(null, $evidence->get('desca'));
2223         $this->assertSame(null, $evidence->get('url'));
2224         $this->assertEquals(3, $evidence->get('grade'));
2225         $this->assertSame(null, $evidence->get('actionuserid'));
2226
2227         // Creating an evidence with another grade information.
2228         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
2229             'error', null, false, null, 1);
2230         $evidence->read();
2231         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2232         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get('status'));
2233         $this->assertEquals(1, $uc->get('grade'));
2234         $this->assertEquals(0, $uc->get('proficiency'));
2235         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2236         $this->assertEquals($u1ctx->id, $evidence->get('contextid'));
2237         $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get('action'));
2238         $this->assertEquals('invaliddata', $evidence->get('descidentifier'));
2239         $this->assertEquals('error', $evidence->get('desccomponent'));
2240         $this->assertSame(null, $evidence->get('desca'));
2241         $this->assertSame(null, $evidence->get('url'));
2242         $this->assertEquals(1, $evidence->get('grade'));
2243         $this->assertSame(null, $evidence->get('actionuserid'));
2244
2245         // Creating reverting the grade and send for review.
2246         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
2247             'error', null, true);
2248         $evidence->read();
2249         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2250         $this->assertSame(null, $uc->get('grade'));
2251         $this->assertSame(null, $uc->get('proficiency'));
2252         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get('status'));
2253         $this->assertSame(null, $evidence->get('grade'));
2254     }
2255
2256     public function test_add_evidence_and_send_for_review() {
2257         $this->resetAfterTest(true);
2258         $dg = $this->getDataGenerator();
2259         $lpg = $dg->get_plugin_generator('core_competency');
2260
2261         $u1 = $dg->create_user();
2262         $u1ctx = context_user::instance($u1->id);
2263         $f1 = $lpg->create_framework();
2264         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2265
2266         // Non-existing user competencies are created up for review.
2267         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2268             'error', null, true);
2269         $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2270         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get('status'));
2271
2272         // Existing user competencies sent for review don't change.
2273         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2274             'error', null, true);
2275         $uc->read();
2276         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get('status'));
2277
2278         // A user competency with a status non-idle won't change.
2279         $uc->set('status', \core_competency\user_competency::STATUS_IN_REVIEW);
2280         $uc->update();
2281         $evidence = api::add_evidence($u1->id, $c1->get('id'), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
2282             'error', null, true);
2283         $uc->read();
2284         $this->assertEquals(\core_competency\user_competency::STATUS_IN_REVIEW, $uc->get('status'));
2285     }
2286
2287     /**
2288      * Test add evidence for existing user_competency.
2289      */
2290     public function test_add_evidence_existing_user_competency() {
2291         $this->resetAfterTest(true);
2292         $dg = $this->getDataGenerator();
2293         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2294
2295         $syscontext = context_system::instance();
2296
2297         // Create users.
2298         $user = $dg->create_user();
2299         $this->setUser($user);
2300
2301         // Create a framework and assign competencies.
2302         $framework = $lpg->create_framework();
2303         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2304         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2305         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2306         $uc = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id')));
2307         $this->assertSame(null, $uc->get('grade'));
2308         $this->assertSame(null, $uc->get('proficiency'));
2309
2310         // Create an evidence and check it was created with the right usercomptencyid and information.
2311         $evidence = api::add_evidence($user->id, $c1->get('id'), $syscontext->id, \core_competency\evidence::ACTION_OVERRIDE,
2312             'invalidevidencedesc', 'core_competency', array('a' => 'b'), false, 'http://moodle.org', 1, 2);
2313         $this->assertEquals(1, \core_competency\evidence::count_records());
2314
2315         $evidence->read();
2316         $uc->read();
2317         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2318         $this->assertEquals('invalidevidencedesc', $evidence->get('descidentifier'));
2319         $this->assertEquals('core_competency', $evidence->get('desccomponent'));
2320         $this->assertEquals((object) array('a' => 'b'), $evidence->get('desca'));
2321         $this->assertEquals('http://moodle.org', $evidence->get('url'));
2322         $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get('action'));
2323         $this->assertEquals(2, $evidence->get('actionuserid'));
2324         $this->assertEquals(1, $evidence->get('grade'));
2325         $this->assertEquals(1, $uc->get('grade'));
2326         $this->assertEquals(0, $uc->get('proficiency'));
2327     }
2328
2329     /**
2330      * Test add evidence for non-existing user_competency.
2331      */
2332     public function test_add_evidence_no_existing_user_competency() {
2333         $this->resetAfterTest(true);
2334         $dg = $this->getDataGenerator();
2335         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2336
2337         $syscontext = context_system::instance();
2338
2339         // Create users.
2340         $user = $dg->create_user();
2341         $this->setUser($user);
2342
2343         // Create a framework and assign competencies.
2344         $framework = $lpg->create_framework();
2345         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2346         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2347         $this->assertEquals(0, \core_competency\user_competency::count_records());
2348
2349         // Create an evidence without a user competency record.
2350         $evidence = api::add_evidence($user->id, $c1->get('id'), $syscontext->id, \core_competency\evidence::ACTION_OVERRIDE,
2351             'invalidevidencedesc', 'core_competency', 'Hello world!', false, 'http://moodle.org', 1, 2);
2352         $this->assertEquals(1, \core_competency\evidence::count_records());
2353         $this->assertEquals(1, \core_competency\user_competency::count_records());
2354
2355         $uc = \core_competency\user_competency::get_record(array('userid' => $user->id, 'competencyid' => $c1->get('id')));
2356         $evidence->read();
2357         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
2358         $this->assertEquals('invalidevidencedesc', $evidence->get('descidentifier'));
2359         $this->assertEquals('core_competency', $evidence->get('desccomponent'));
2360         $this->assertEquals('Hello world!', $evidence->get('desca'));
2361         $this->assertEquals('http://moodle.org', $evidence->get('url'));
2362         $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get('action'));
2363         $this->assertEquals(2, $evidence->get('actionuserid'));
2364         $this->assertEquals(1, $evidence->get('grade'));
2365         $this->assertEquals(1, $uc->get('grade'));
2366         $this->assertEquals(0, $uc->get('proficiency'));
2367     }
2368
2369     public function test_add_evidence_applies_competency_rules() {
2370         $this->resetAfterTest(true);
2371         $dg = $this->getDataGenerator();
2372         $lpg = $dg->get_plugin_generator('core_competency');
2373         $syscontext = context_system::instance();
2374         $ctxid = $syscontext->id;
2375
2376         $u1 = $dg->create_user();
2377
2378         // Setting up the framework.
2379         $f1 = $lpg->create_framework();
2380         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2381         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
2382         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
2383         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2384         $c2a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c2->get('id')));
2385         $c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2386         $c3a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c3->get('id')));
2387         $c4 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2388         $c4a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c4->get('id')));
2389         $c5 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2390
2391         // Setting up the rules.
2392         $c1->set('ruletype', 'core_competency\\competency_rule_all');
2393         $c1->set('ruleoutcome', \core_competency\competency::OUTCOME_COMPLETE);
2394         $c1->update();
2395         $c2->set('ruletype', 'core_competency\\competency_rule_all');
2396         $c2->set('ruleoutcome', \core_competency\competency::OUTCOME_RECOMMEND);
2397         $c2->update();
2398         $c3->set('ruletype', 'core_competency\\competency_rule_all');
2399         $c3->set('ruleoutcome', \core_competency\competency::OUTCOME_EVIDENCE);
2400         $c3->update();
2401         $c4->set('ruletype', 'core_competency\\competency_rule_all');
2402         $c4->set('ruleoutcome', \core_competency\competency::OUTCOME_NONE);
2403         $c4->update();
2404
2405         // Confirm the current data.
2406         $this->assertEquals(0, user_competency::count_records());
2407         $this->assertEquals(0, evidence::count_records());
2408
2409         // Let's do this!
2410         // First let's confirm that evidence not marking a completion have no impact.
2411         api::add_evidence($u1->id, $c1a, $ctxid, evidence::ACTION_LOG, 'commentincontext', 'core');
2412         $uc1a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1a->get('id')));
2413         $this->assertSame(null, $uc1a->get('proficiency'));
2414         $this->assertFalse(user_competency::record_exists_select('userid = ? AND competencyid = ?', array($u1->id, $c1->get('id'))));
2415
2416         // Now let's try complete a competency but the rule won't match (not all children are complete).
2417         // The parent (the thing with the rule) will be created but won't have any evidence attached, and not
2418         // not be marked as completed.
2419         api::add_evidence($u1->id, $c1a, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2420         $uc1a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1a->get('id')));
2421         $this->assertEquals(true, $uc1a->get('proficiency'));
2422         $uc1 = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2423         $this->assertSame(null, $uc1->get('proficiency'));
2424         $this->assertEquals(0, evidence::count_records(array('usercompetencyid' => $uc1->get('id'))));
2425
2426         // Now we complete the other child. That will mark the parent as complete with an evidence.
2427         api::add_evidence($u1->id, $c1b, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2428         $uc1b = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1b->get('id')));
2429         $this->assertEquals(true, $uc1a->get('proficiency'));
2430         $uc1 = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get('id')));
2431         $this->assertEquals(true, $uc1->get('proficiency'));
2432         $this->assertEquals(user_competency::STATUS_IDLE, $uc1->get('status'));
2433         $this->assertEquals(1, evidence::count_records(array('usercompetencyid' => $uc1->get('id'))));
2434
2435         // Check rule recommending.
2436         api::add_evidence($u1->id, $c2a, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2437         $uc2a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2a->get('id')));
2438         $this->assertEquals(true, $uc1a->get('proficiency'));
2439         $uc2 = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get('id')));
2440         $this->assertSame(null, $uc2->get('proficiency'));
2441         $this->assertEquals(user_competency::STATUS_WAITING_FOR_REVIEW, $uc2->get('status'));
2442         $this->assertEquals(1, evidence::count_records(array('usercompetencyid' => $uc2->get('id'))));
2443
2444         // Check rule evidence.
2445         api::add_evidence($u1->id, $c3a, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2446         $uc3a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c3a->get('id')));
2447         $this->assertEquals(true, $uc1a->get('proficiency'));
2448         $uc3 = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c3->get('id')));
2449         $this->assertSame(null, $uc3->get('proficiency'));
2450         $this->assertEquals(user_competency::STATUS_IDLE, $uc3->get('status'));
2451         $this->assertEquals(1, evidence::count_records(array('usercompetencyid' => $uc3->get('id'))));
2452
2453         // Check rule nothing.
2454         api::add_evidence($u1->id, $c4a, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2455         $uc4a = user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c4a->get('id')));
2456         $this->assertEquals(true, $uc1a->get('proficiency'));
2457         $this->assertFalse(user_competency::record_exists_select('userid = ? AND competencyid = ?', array($u1->id, $c4->get('id'))));
2458
2459         // Check marking on something that has no parent. This just checks that nothing breaks.
2460         api::add_evidence($u1->id, $c5, $ctxid, evidence::ACTION_COMPLETE, 'commentincontext', 'core');
2461     }
2462
2463     /**
2464      * Tests for the user_competency_course data when api::add_evidence() is invoked when
2465      * grading a user competency in the system context.
2466      */
2467     public function test_add_evidence_for_user_competency_course_grade_outside_course() {
2468         $this->resetAfterTest(true);
2469         $dg = $this->getDataGenerator();
2470         $syscontext = context_system::instance();
2471
2472         // Create a student.
2473         $student = $dg->create_user();
2474
2475         // Create a competency for the course.
2476         $lpg = $dg->get_plugin_generator('core_competency');
2477         $framework = $lpg->create_framework();
2478         $comp = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2479
2480         // Add evidence.
2481         api::add_evidence($student->id, $comp, $syscontext, evidence::ACTION_OVERRIDE,
2482             'commentincontext', 'core', null, false, null, 1);
2483
2484         // Query for user_competency_course data.
2485         $filterparams = array(
2486             'userid' => $student->id,
2487             'competencyid' => $comp->get('id'),
2488         );
2489         $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
2490         // There should be no user_competency_course object created when grading.
2491         $this->assertFalse($usercompcourse);
2492     }
2493
2494     /**
2495      * Tests for the user_competency_course data when api::add_evidence() is invoked when
2496      * grading a user competency in a course.
2497      */
2498     public function test_add_evidence_user_competency_course_grade_in_course() {
2499         global $USER;
2500
2501         $this->resetAfterTest(true);
2502         $dg = $this->getDataGenerator();
2503
2504         // Create a course.
2505         $course = $dg->create_course();
2506         $record = array('courseid' => $course->id, 'pushratingstouserplans' => false);
2507         $settings = new course_competency_settings(0, (object) $record);
2508         $settings->create();
2509         $coursecontext = context_course::instance($course->id);
2510
2511         // Create a student and enrol into the course.
2512         $student = $dg->create_user();
2513         $studentarch = get_archetype_roles('student');
2514         $studentrole = array_shift($studentarch);
2515         $dg->role_assign($studentrole->id, $student->id, $coursecontext->id);
2516         $dg->enrol_user($student->id, $course->id, $studentrole->id);
2517
2518         // Create a competency for the course.
2519         $lpg = $dg->get_plugin_generator('core_competency');
2520         $framework = $lpg->create_framework();
2521         // Do not push ratings from course to user plans.
2522         $comp = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2523         $lpg->create_course_competency(array('courseid' => $course->id, 'competencyid' => $comp->get('id')));
2524
2525         // Query for user_competency_course data.
2526         $filterparams = array(
2527             'userid' => $student->id,
2528             'competencyid' => $comp->get('id'),
2529             'courseid' => $course->id
2530         );
2531
2532         // Add evidence that sets a grade to the course.
2533         $evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_OVERRIDE,
2534             'commentincontext', 'core', null, false, null, 3, $USER->id);
2535         // Get user competency course record.
2536         $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
2537         // There should be a user_competency_course object when adding a grade.
2538         $this->assertNotEmpty($usercompcourse);
2539         $grade = $evidence->get('grade');
2540         $this->assertEquals($grade, $usercompcourse->get('grade'));
2541         $this->assertEquals(3, $usercompcourse->get('grade'));
2542         $proficiency = $comp->get_proficiency_of_grade($grade);
2543         $this->assertEquals($proficiency, $usercompcourse->get('proficiency'));
2544
2545         // Confirm that the user competency's grade/proficiency has not been affected by the grade.
2546         $usercompetencyparams = [
2547             'userid' => $student->id,
2548             'competencyid' => $comp->get('id'),
2549         ];
2550         $usercompetency = \core_competency\user_competency::get_record($usercompetencyparams);
2551         $this->assertNotEmpty($usercompetency);
2552         $this->assertNotEquals($usercompcourse->get('grade'), $usercompetency->get('grade'));
2553         $this->assertNotEquals($usercompcourse->get('proficiency'), $usercompetency->get('proficiency'));
2554     }
2555
2556     public function test_observe_course_completed() {
2557         $this->resetAfterTest(true);
2558         $dg = $this->getDataGenerator();
2559         $lpg = $dg->get_plugin_generator('core_competency');
2560
2561         // Set-up users, framework, competencies and course competencies.
2562         $course = $dg->create_course();
2563         $coursectx = context_course::instance($course->id);
2564         $u1 = $dg->create_user();
2565         $f1 = $lpg->create_framework();
2566         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2567         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2568         $c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2569         $c4 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2570         $cc1 = $lpg->create_course_competency(array('competencyid' => $c1->get('id'), 'courseid' => $course->id,
2571             'ruleoutcome' => \core_competency\course_competency::OUTCOME_NONE));
2572         $cc2 = $lpg->create_course_competency(array('competencyid' => $c2->get('id'), 'courseid' => $course->id,
2573             'ruleoutcome' => \core_competency\course_competency::OUTCOME_EVIDENCE));
2574         $cc3 = $lpg->create_course_competency(array('competencyid' => $c3->get('id'), 'courseid' => $course->id,
2575             'ruleoutcome' => \core_competency\course_competency::OUTCOME_RECOMMEND));
2576         $cc4 = $lpg->create_course_competency(array('competencyid' => $c4->get('id'), 'courseid' => $course->id,
2577             'ruleoutcome' => \core_competency\course_competency::OUTCOME_COMPLETE));
2578
2579         $event = \core\event\course_completed::create(array(
2580             'objectid' => 1,
2581             'relateduserid' => $u1->id,
2582             'context' => $coursectx,
2583             'courseid' => $course->id,
2584             'other' => array('relateduserid' => $u1->id)
2585         ));
2586         $this->assertEquals(0, \core_competency\user_competency::count_records());
2587         $this->assertEquals(0, \core_competency\evidence::count_records());
2588
2589         // Let's go!
2590         api::observe_course_completed($event);
2591         $this->assertEquals(3, \core_competency\user_competency::count_records());
2592         $this->assertEquals(3, \core_competency\evidence::count_records());
2593
2594         // Outcome NONE did nothing.
2595         $this->assertFalse(\core_competency\user_competency::record_exists_select('userid = :uid AND competencyid = :cid', array(
2596             'uid' => $u1->id, 'cid' => $c1->get('id')
2597         )));
2598
2599         // Outcome evidence.
2600         $uc2 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get('id')));
2601         $ev2 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc2->get('id')));
2602
2603         $this->assertEquals(null, $uc2->get('grade'));
2604         $this->assertEquals(null, $uc2->get('proficiency'));
2605         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc2->get('status'));
2606
2607         $this->assertEquals('evidence_coursecompleted', $ev2->get('descidentifier'));
2608         $this->assertEquals('core_competency', $ev2->get('desccomponent'));
2609         $this->assertEquals($course->shortname, $ev2->get('desca'));
2610         $this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev2->get('url'));
2611         $this->assertEquals(null, $ev2->get('grade'));
2612         $this->assertEquals($coursectx->id, $ev2->get('contextid'));
2613         $this->assertEquals(\core_competency\evidence::ACTION_LOG, $ev2->get('action'));
2614         $this->assertEquals(null, $ev2->get('actionuserid'));
2615
2616         // Outcome recommend.
2617         $uc3 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c3->get('id')));
2618         $ev3 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc3->get('id')));
2619
2620         $this->assertEquals(null, $uc3->get('grade'));
2621         $this->assertEquals(null, $uc3->get('proficiency'));
2622         $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc3->get('status'));
2623
2624         $this->assertEquals('evidence_coursecompleted', $ev3->get('descidentifier'));
2625         $this->assertEquals('core_competency', $ev3->get('desccomponent'));
2626         $this->assertEquals($course->shortname, $ev3->get('desca'));
2627         $this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev3->get('url'));
2628         $this->assertEquals(null, $ev3->get('grade'));
2629         $this->assertEquals($coursectx->id, $ev3->get('contextid'));
2630         $this->assertEquals(\core_competency\evidence::ACTION_LOG, $ev3->get('action'));
2631         $this->assertEquals(null, $ev3->get('actionuserid'));
2632
2633         // Outcome complete.
2634         $uc4 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c4->get('id')));
2635         $ev4 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc4->get('id')));
2636
2637         $this->assertEquals(3, $uc4->get('grade'));
2638         $this->assertEquals(1, $uc4->get('proficiency'));
2639         $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc4->get('status'));
2640
2641         $this->assertEquals('evidence_coursecompleted', $ev4->get('descidentifier'));
2642         $this->assertEquals('core_competency', $ev4->get('desccomponent'));
2643         $this->assertEquals($course->shortname, $ev4->get('desca'));
2644         $this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev4->get('url'));
2645         $this->assertEquals(3, $ev4->get('grade'));
2646         $this->assertEquals($coursectx->id, $ev4->get('contextid'));
2647         $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $ev4->get('action'));
2648         $this->assertEquals(null, $ev4->get('actionuserid'));
2649     }
2650
2651     public function test_list_evidence_in_course() {
2652         global $SITE;
2653
2654         $this->resetAfterTest(true);
2655         $dg = $this->getDataGenerator();
2656         $lpg = $dg->get_plugin_generator('core_competency');
2657         $u1 = $dg->create_user();
2658         $course = $dg->create_course();
2659         $coursecontext = context_course::instance($course->id);
2660
2661         $this->setAdminUser();
2662         $f = $lpg->create_framework();
2663         $c = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
2664         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
2665         $cc = api::add_competency_to_course($course->id, $c->get('id'));
2666         $cc2 = api::add_competency_to_course($course->id, $c2->get('id'));
2667
2668         $pagegenerator = $this->getDataGenerator()->get_plugin_generator('mod_page');
2669         $page = $pagegenerator->create_instance(array('course' => $course->id));
2670
2671         $cm = get_coursemodule_from_instance('page', $page->id);
2672         $cmcontext = context_module::instance($cm->id);
2673         // Add the competency to the course module.
2674         $ccm = api::add_competency_to_course_module($cm, $c->get('id'));
2675
2676         // Now add the evidence to the course.
2677         $evidence1 = api::add_evidence($u1->id, $c->get('id'), $coursecontext->id, \core_competency\evidence::ACTION_LOG,
2678             'invaliddata', 'error');
2679
2680         $result = api::list_evidence_in_course($u1->id, $course->id, $c->get('id'));
2681         $this->assertEquals($result[0]->get('id'), $evidence1->get('id'));
2682
2683         // Now add the evidence to the course module.
2684         $evidence2 = api::add_evidence($u1->id, $c->get('id'), $cmcontext->id, \core_competency\evidence::ACTION_LOG,
2685             'invaliddata', 'error');
2686
2687         $result = api::list_evidence_in_course($u1->id, $course->id, $c->get('id'), 'timecreated', 'ASC');
2688         $this->assertEquals($evidence1->get('id'), $result[0]->get('id'));
2689         $this->assertEquals($evidence2->get('id'), $result[1]->get('id'));
2690     }
2691
2692     public function test_list_course_modules_using_competency() {
2693         global $SITE;
2694
2695         $this->resetAfterTest(true);
2696         $dg = $this->getDataGenerator();
2697         $lpg = $dg->get_plugin_generator('core_competency');
2698         $u1 = $dg->create_user();
2699         $u2 = $dg->create_user();
2700         $course = $dg->create_course();
2701         $course2 = $dg->create_course();
2702
2703         $this->setAdminUser();
2704         $f = $lpg->create_framework();
2705         $c = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
2706         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
2707         $cc = api::add_competency_to_course($course->id, $c->get('id'));
2708         $cc2 = api::add_competency_to_course($course->id, $c2->get('id'));
2709
2710         // First check we get an empty list when there are no links.
2711         $expected = array();
2712         $result = api::list_course_modules_using_competency($c->get('id'), $course->id);
2713         $this->assertEquals($expected, $result);
2714
2715         $pagegenerator = $this->getDataGenerator()->get_plugin_generator('mod_page');
2716         $page = $pagegenerator->create_instance(array('course' => $course->id));
2717
2718         $cm = get_coursemodule_from_instance('page', $page->id);
2719         // Add a link and list again.
2720         $ccm = api::add_competency_to_course_module($cm, $c->get('id'));
2721         $expected = array($cm->id);
2722         $result = api::list_course_modules_using_competency($c->get('id'), $course->id);
2723         $this->assertEquals($expected, $result);
2724
2725         // Check a different course.
2726         $expected = array();
2727         $result = api::list_course_modules_using_competency($c->get('id'), $course2->id);
2728         $this->assertEquals($expected, $result);
2729
2730         // Remove the link and check again.
2731         $result = api::remove_competency_from_course_module($cm, $c->get('id'));
2732         $expected = true;
2733         $this->assertEquals($expected, $result);
2734         $expected = array();
2735         $result = api::list_course_modules_using_competency($c->get('id'), $course->id);
2736         $this->assertEquals($expected, $result);
2737
2738         // Now add 2 links.
2739         api::add_competency_to_course_module($cm, $c->get('id'));
2740         api::add_competency_to_course_module($cm, $c2->get('id'));
2741         $result = api::list_course_module_competencies_in_course_module($cm->id);
2742         $this->assertEquals($result[0]->get('competencyid'), $c->get('id'));
2743         $this->assertEquals($result[1]->get('competencyid'), $c2->get('id'));
2744
2745         // Now re-order.
2746         api::reorder_course_module_competency($cm, $c->get('id'), $c2->get('id'));
2747         $result = api::list_course_module_competencies_in_course_module($cm->id);
2748         $this->assertEquals($result[0]->get('competencyid'), $c2->get('id'));
2749         $this->assertEquals($result[1]->get('competencyid'), $c->get('id'));
2750
2751         // And re-order again.
2752         api::reorder_course_module_competency($cm, $c->get('id'), $c2->get('id'));
2753         $result = api::list_course_module_competencies_in_course_module($cm->id);
2754         $this->assertEquals($result[0]->get('competencyid'), $c->get('id'));
2755         $this->assertEquals($result[1]->get('competencyid'), $c2->get('id'));
2756     }
2757
2758     /**
2759      * Test update ruleoutcome for course_competency.
2760      */
2761     public function test_set_ruleoutcome_course_competency() {
2762         $this->resetAfterTest(true);
2763         $dg = $this->getDataGenerator();
2764         $lpg = $dg->get_plugin_generator('core_competency');
2765         $u1 = $dg->create_user();
2766         $u2 = $dg->create_user();
2767         $course = $dg->create_course();
2768
2769         $this->setAdminUser();
2770         $f = $lpg->create_framework();
2771         $c = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
2772         $cc = api::add_competency_to_course($course->id, $c->get('id'));
2773
2774         // Check record was created with default rule value Evidence.
2775         $this->assertEquals(1, \core_competency\course_competency::count_records());
2776         $recordscc = api::list_course_competencies($course->id);
2777         $this->assertEquals(\core_competency\course_competency::OUTCOME_EVIDENCE,
2778             $recordscc[0]['coursecompetency']->get('ruleoutcome'));
2779
2780         // Check ruleoutcome value is updated to None.
2781         $this->assertTrue(api::set_course_competency_ruleoutcome($recordscc[0]['coursecompetency']->get('id'),
2782             \core_competency\course_competency::OUTCOME_NONE));
2783         $recordscc = api::list_course_competencies($course->id);
2784         $this->assertEquals(\core_competency\course_competency::OUTCOME_NONE, $recordscc[0]['coursecompetency']->get('ruleoutcome'));
2785     }
2786
2787     /**
2788      * Test validation on grade on user_competency.
2789      */
2790     public function test_validate_grade_in_user_competency() {
2791         global $DB;
2792
2793         $this->resetAfterTest(true);
2794         $this->setAdminUser();
2795         $dg = $this->getDataGenerator();
2796         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2797         $user = $dg->create_user();
2798
2799         $s1 = $dg->create_scale(array("scale" => "value1, value2"));
2800         $s2 = $dg->create_scale(array("scale" => "value3, value4, value5, value6"));
2801
2802         $scaleconfiguration1 = '[{"scaleid":"'.$s1->id.'"},{"name":"value1","id":1,"scaledefault":1,"proficient":0},' .
2803                 '{"name":"value2","id":2,"scaledefault":0,"proficient":1}]';
2804         $scaleconfiguration2 = '[{"scaleid":"'.$s2->id.'"},{"name":"value3","id":1,"scaledefault":1,"proficient":0},'
2805                 . '{"name":"value4","id":2,"scaledefault":0,"proficient":1}]';
2806
2807         // Create a framework with scale configuration1.
2808         $frm = array(
2809             'scaleid' => $s1->id,
2810             'scaleconfiguration' => $scaleconfiguration1
2811         );
2812         $framework = $lpg->create_framework($frm);
2813         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2814
2815         // Create competency with its own scale configuration.
2816         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id'),
2817                                             'scaleid' => $s2->id,
2818                                             'scaleconfiguration' => $scaleconfiguration2
2819                                         ));
2820
2821         // Detecte invalid grade in competency using its framework competency scale.
2822         try {
2823             $usercompetency = new user_competency(0, (object) array('userid' => $user->id, 'competencyid' => $c1->get('id'),
2824                 'proficiency' => true, 'grade' => 3 ));
2825             $usercompetency->create();
2826             $this->fail('Invalid grade not detected in framework scale');
2827         } catch (\core\invalid_persistent_exception $e) {
2828             $this->assertTrue(true);
2829         }
2830
2831         // Detecte invalid grade in competency using its own scale.
2832         try {
2833             $usercompetency = new user_competency(0, (object) array('userid' => $user->id, 'competencyid' => $c2->get('id'),
2834                 'proficiency' => true, 'grade' => 5 ));
2835             $usercompetency->create();
2836             $this->fail('Invalid grade not detected in competency scale');
2837         } catch (\core\invalid_persistent_exception $e) {
2838             $this->assertTrue(true);
2839         }
2840
2841         // Accept valid grade in competency using its framework competency scale.
2842         try {
2843             $usercompetency = new user_competency(0, (object) array('userid' => $user->id, 'competencyid' => $c1->get('id'),
2844                 'proficiency' => true, 'grade' => 1 ));
2845             $usercompetency->create();
2846             $this->assertTrue(true);
2847         } catch (\core\invalid_persistent_exception $e) {
2848             $this->fail('Valide grade rejected in framework scale');
2849         }
2850
2851         // Accept valid grade in competency using its framework competency scale.
2852         try {
2853             $usercompetency = new user_competency(0, (object) array('userid' => $user->id, 'competencyid' => $c2->get('id'),
2854                 'proficiency' => true, 'grade' => 4 ));
2855             $usercompetency->create();
2856             $this->assertTrue(true);
2857         } catch (\core\invalid_persistent_exception $e) {
2858             $this->fail('Valide grade rejected in competency scale');
2859         }
2860     }
2861
2862     /**
2863      * Test when adding competency that belong to hidden framework to plan/template/course.
2864      */
2865     public function test_hidden_framework() {
2866         $this->resetAfterTest(true);
2867         $this->setAdminUser();
2868         $dg = $this->getDataGenerator();
2869         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2870         $user = $dg->create_user();
2871
2872         // Create a course.
2873         $cat1 = $dg->create_category();
2874         $course = $dg->create_course(array('category' => $cat1->id));
2875         // Create a template.
2876         $template = $lpg->create_template();
2877         // Create a plan.
2878         $plan = $lpg->create_plan(array('userid' => $user->id));
2879
2880         // Create a hidden framework.
2881         $frm = array(
2882             'visible' => false
2883         );
2884         $framework = $lpg->create_framework($frm);
2885         $competency = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2886
2887         // Linking competency that belong to hidden framework to course.
2888         try {
2889             api::add_competency_to_course($course->id, $competency->get('id'));
2890             $this->fail('A competency belonging to hidden framework can not be linked to course');
2891         } catch (coding_exception $e) {
2892             $this->assertTrue(true);
2893         }
2894
2895         // Adding competency that belong to hidden framework to template.
2896         try {
2897             api::add_competency_to_template($template->get('id'), $competency->get('id'));
2898             $this->fail('A competency belonging to hidden framework can not be added to template');
2899         } catch (coding_exception $e) {
2900             $this->assertTrue(true);
2901         }
2902
2903         // Adding competency that belong to hidden framework to plan.
2904         try {
2905             api::add_competency_to_plan($plan->get('id'), $competency->get('id'));
2906             $this->fail('A competency belonging to hidden framework can not be added to plan');
2907         } catch (coding_exception $e) {
2908             $this->assertTrue(true);
2909         }
2910     }
2911
2912     /**
2913      * Test when using hidden template in plan/cohort.
2914      */
2915     public function test_hidden_template() {
2916         $this->resetAfterTest(true);
2917         $this->setAdminUser();
2918         $dg = $this->getDataGenerator();
2919         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2920         $user = $dg->create_user();
2921
2922         // Create a cohort.
2923         $cohort = $dg->create_cohort();
2924         // Create a hidden template.
2925         $template = $lpg->create_template(array('visible' => false));
2926
2927         // Can not link hidden template to plan.
2928         try {
2929             api::create_plan_from_template($template->get('id'), $user->id);
2930             $this->fail('Can not link a hidden template to plan');
2931         } catch (coding_exception $e) {
2932             $this->assertTrue(true);
2933         }
2934
2935         // Can associate hidden template to cohort.
2936         $templatecohort = api::create_template_cohort($template->get('id'), $cohort->id);
2937         $this->assertInstanceOf('\core_competency\template_cohort', $templatecohort);
2938     }
2939
2940     /**
2941      * Test that completed plan created form a template does not change when template is modified.
2942      */
2943     public function test_completed_plan_doesnot_change() {
2944         global $DB;
2945
2946         $this->resetAfterTest(true);
2947         $this->setAdminUser();
2948         $dg = $this->getDataGenerator();
2949         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
2950         $user = $dg->create_user();
2951
2952         // Create a framework and assign competencies.
2953         $framework = $lpg->create_framework();
2954         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2955         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2956         $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2957         $c4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
2958
2959         // Create template and assign competencies.
2960         $tp = $lpg->create_template();
2961         $tpc1 = $lpg->create_template_competency(array('templateid' => $tp->get('id'), 'competencyid' => $c1->get('id')));
2962         $tpc2 = $lpg->create_template_competency(array('templateid' => $tp->get('id'), 'competencyid' => $c2->get('id')));
2963         $tpc3 = $lpg->create_template_competency(array('templateid' => $tp->get('id'), 'competencyid' => $c3->get('id')));
2964
2965         // Create a plan form template and change it status to complete.
2966         $plan = $lpg->create_plan(array('userid' => $user->id, 'templateid' => $tp->get('id')));
2967         api::complete_plan($plan);
2968
2969         // Check user competency plan created correctly.
2970         $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
2971         $ucp = \core_competency\user_competency_plan::get_records();
2972         $this->assertEquals($ucp[0]->get('competencyid'), $c1->get('id'));
2973         $this->assertEquals($ucp[1]->get('competencyid'), $c2->get('id'));
2974         $this->assertEquals($ucp[2]->get('competencyid'), $c3->get('id'));
2975
2976         // Add and remove a competency from the template.
2977         api::add_competency_to_template($tp->get('id'), $c4->get('id'));
2978         api::remove_competency_from_template($tp->get('id'), $c1->get('id'));
2979
2980         // Check that user competency plan did not change.
2981         $competencies = $plan->get_competencies();
2982         $this->assertEquals(3, count($competencies));
2983         $ucp1 = array($c1->get('id'), $c2->get('id'), $c3->get('id'));
2984         $ucp2 = array();
2985         foreach ($competencies as $id => $cmp) {
2986             $ucp2[] = $id;
2987         }
2988         $this->assertEquals(0, count(array_diff($ucp1, $ucp2)));
2989     }
2990
2991     protected function setup_framework_for_reset_rules_tests() {
2992         $this->resetAfterTest(true);
2993         $dg = $this->getDataGenerator();
2994         $lpg = $dg->get_plugin_generator('core_competency');
2995
2996         $this->setAdminUser();
2997         $f1 = $lpg->create_framework();
2998         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
2999         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3000         $c1a1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3001         $c1a1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a1->get('id')));
3002         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3003         $c1b1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3004         $c1b1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b1->get('id')));
3005         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3006         $c2a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3007
3008         $c1->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3009         $c1->set('ruletype', 'core_competency\\competency_rule_all');
3010         $c1->update();
3011         $c1a->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3012         $c1a->set('ruletype', 'core_competency\\competency_rule_all');
3013         $c1a->update();
3014         $c1a1->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3015         $c1a1->set('ruletype', 'core_competency\\competency_rule_all');
3016         $c1a1->update();
3017         $c1b->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3018         $c1b->set('ruletype', 'core_competency\\competency_rule_all');
3019         $c1b->update();
3020         $c2->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3021         $c2->set('ruletype', 'core_competency\\competency_rule_all');
3022         $c2->update();
3023
3024         return array(
3025             'f1' => $f1,
3026             'c1' => $c1,
3027             'c1a' => $c1a,
3028             'c1a1' => $c1a1,
3029             'c1a1a' => $c1a1a,
3030             'c1b' => $c1b,
3031             'c1b1' => $c1b1,
3032             'c1b1a' => $c1b1a,
3033             'c2' => $c2,
3034             'c2a' => $c2a,
3035         );
3036     }
3037
3038     public function test_moving_competency_reset_rules_updown() {
3039         $data = $this->setup_framework_for_reset_rules_tests();
3040         $f1 = $data['f1'];
3041         $c1 = $data['c1'];
3042         $c1a = $data['c1a'];
3043         $c1a1 = $data['c1a1'];
3044         $c1a1a = $data['c1a1a'];
3045         $c1b = $data['c1b'];
3046         $c1b1 = $data['c1b1'];
3047         $c1b1a = $data['c1b1a'];
3048         $c2 = $data['c2'];
3049         $c2a = $data['c2a'];
3050
3051         // Moving up and down doesn't change anything.
3052         api::move_down_competency($c1a->get('id'));
3053         $c1->read();
3054         $c1a->read();
3055         $c1a1->read();
3056         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1->get('ruleoutcome'));
3057         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a->get('ruleoutcome'));
3058         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a1->get('ruleoutcome'));
3059         api::move_up_competency($c1a->get('id'));
3060         $c1->read();
3061         $c1a->read();
3062         $c1a1->read();
3063         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1->get('ruleoutcome'));
3064         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a->get('ruleoutcome'));
3065         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a1->get('ruleoutcome'));
3066     }
3067
3068     public function test_moving_competency_reset_rules_parent() {
3069         $data = $this->setup_framework_for_reset_rules_tests();
3070         $f1 = $data['f1'];
3071         $c1 = $data['c1'];
3072         $c1a = $data['c1a'];
3073         $c1a1 = $data['c1a1'];
3074         $c1a1a = $data['c1a1a'];
3075         $c1b = $data['c1b'];
3076         $c1b1 = $data['c1b1'];
3077         $c1b1a = $data['c1b1a'];
3078         $c2 = $data['c2'];
3079         $c2a = $data['c2a'];
3080
3081         // Moving out of parent will reset the parent, and the destination.
3082         api::set_parent_competency($c1a->get('id'), $c1b->get('id'));
3083         $c1->read();
3084         $c1a->read();
3085         $c1a1->read();
3086         $c1b->read();
3087         $c2->read();
3088         $this->assertEquals(competency::OUTCOME_NONE, $c1->get('ruleoutcome'));
3089         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a->get('ruleoutcome'));
3090         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a1->get('ruleoutcome'));
3091         $this->assertEquals(competency::OUTCOME_NONE, $c1b->get('ruleoutcome'));
3092         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3093     }
3094
3095     public function test_moving_competency_reset_rules_totoplevel() {
3096         $data = $this->setup_framework_for_reset_rules_tests();
3097         $f1 = $data['f1'];
3098         $c1 = $data['c1'];
3099         $c1a = $data['c1a'];
3100         $c1a1 = $data['c1a1'];
3101         $c1a1a = $data['c1a1a'];
3102         $c1b = $data['c1b'];
3103         $c1b1 = $data['c1b1'];
3104         $c1b1a = $data['c1b1a'];
3105         $c2 = $data['c2'];
3106         $c2a = $data['c2a'];
3107
3108         // Moving to top level only affects the initial parent.
3109         api::set_parent_competency($c1a1->get('id'), 0);
3110         $c1->read();
3111         $c1a->read();
3112         $c1a1->read();
3113         $c1b->read();
3114         $c2->read();
3115         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1->get('ruleoutcome'));
3116         $this->assertEquals(competency::OUTCOME_NONE, $c1a->get('ruleoutcome'));
3117         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a1->get('ruleoutcome'));
3118         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1b->get('ruleoutcome'));
3119         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3120     }
3121
3122     public function test_moving_competency_reset_rules_fromtoplevel() {
3123         $data = $this->setup_framework_for_reset_rules_tests();
3124         $f1 = $data['f1'];
3125         $c1 = $data['c1'];
3126         $c1a = $data['c1a'];
3127         $c1a1 = $data['c1a1'];
3128         $c1a1a = $data['c1a1a'];
3129         $c1b = $data['c1b'];
3130         $c1b1 = $data['c1b1'];
3131         $c1b1a = $data['c1b1a'];
3132         $c2 = $data['c2'];
3133         $c2a = $data['c2a'];
3134
3135         // Moving from top level only affects the destination parent.
3136         api::set_parent_competency($c2->get('id'), $c1a1->get('id'));
3137         $c1->read();
3138         $c1a->read();
3139         $c1a1->read();
3140         $c1b->read();
3141         $c2->read();
3142         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1->get('ruleoutcome'));
3143         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a->get('ruleoutcome'));
3144         $this->assertEquals(competency::OUTCOME_NONE, $c1a1->get('ruleoutcome'));
3145         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1b->get('ruleoutcome'));
3146         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3147     }
3148
3149     public function test_moving_competency_reset_rules_child() {
3150         $data = $this->setup_framework_for_reset_rules_tests();
3151         $f1 = $data['f1'];
3152         $c1 = $data['c1'];
3153         $c1a = $data['c1a'];
3154         $c1a1 = $data['c1a1'];
3155         $c1a1a = $data['c1a1a'];
3156         $c1b = $data['c1b'];
3157         $c1b1 = $data['c1b1'];
3158         $c1b1a = $data['c1b1a'];
3159         $c2 = $data['c2'];
3160         $c2a = $data['c2a'];
3161
3162         // Moving to a child of self resets self, parent and destination.
3163         api::set_parent_competency($c1a->get('id'), $c1a1->get('id'));
3164         $c1->read();
3165         $c1a->read();
3166         $c1a1->read();
3167         $c1b->read();
3168         $c2->read();
3169         $this->assertEquals(competency::OUTCOME_NONE, $c1->get('ruleoutcome'));
3170         $this->assertEquals(competency::OUTCOME_NONE, $c1a->get('ruleoutcome'));
3171         $this->assertEquals(competency::OUTCOME_NONE, $c1a1->get('ruleoutcome'));
3172         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1b->get('ruleoutcome'));
3173         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3174     }
3175
3176     public function test_create_competency_reset_rules() {
3177         $data = $this->setup_framework_for_reset_rules_tests();
3178         $f1 = $data['f1'];
3179         $c1 = $data['c1'];
3180         $c1a = $data['c1a'];
3181         $c1a1 = $data['c1a1'];
3182         $c1a1a = $data['c1a1a'];
3183         $c1b = $data['c1b'];
3184         $c1b1 = $data['c1b1'];
3185         $c1b1a = $data['c1b1a'];
3186         $c2 = $data['c2'];
3187         $c2a = $data['c2a'];
3188
3189         // Adding a new competency resets the rule of its parent.
3190         api::create_competency((object) array('shortname' => 'A', 'parentid' => $c1->get('id'), 'idnumber' => 'A',
3191             'competencyframeworkid' => $f1->get('id')));
3192         $c1->read();
3193         $c1a->read();
3194         $c1a1->read();
3195         $c1b->read();
3196         $c2->read();
3197         $this->assertEquals(competency::OUTCOME_NONE, $c1->get('ruleoutcome'));
3198         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a->get('ruleoutcome'));
3199         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1a1->get('ruleoutcome'));
3200         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1b->get('ruleoutcome'));
3201         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3202     }
3203
3204     public function test_delete_competency_reset_rules() {
3205         $data = $this->setup_framework_for_reset_rules_tests();
3206         $f1 = $data['f1'];
3207         $c1 = $data['c1'];
3208         $c1a = $data['c1a'];
3209         $c1a1 = $data['c1a1'];
3210         $c1a1a = $data['c1a1a'];
3211         $c1b = $data['c1b'];
3212         $c1b1 = $data['c1b1'];
3213         $c1b1a = $data['c1b1a'];
3214         $c2 = $data['c2'];
3215         $c2a = $data['c2a'];
3216
3217         // Deleting a competency resets the rule of its parent.
3218         api::delete_competency($c1a->get('id'));
3219         $c1->read();
3220         $c1b->read();
3221         $c2->read();
3222         $this->assertEquals(competency::OUTCOME_NONE, $c1->get('ruleoutcome'));
3223         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c1b->get('ruleoutcome'));
3224         $this->assertEquals(competency::OUTCOME_EVIDENCE, $c2->get('ruleoutcome'));
3225     }
3226
3227     public function test_template_has_related_data() {
3228         $this->resetAfterTest(true);
3229         $this->setAdminUser();
3230
3231         $dg = $this->getDataGenerator();
3232         $user = $dg->create_user();
3233         $lpg = $dg->get_plugin_generator('core_competency');
3234         $tpl1 = $lpg->create_template();
3235         $tpl2 = $lpg->create_template();
3236
3237         // Create plans for first template.
3238         $time = time();
3239         $plan1 = $lpg->create_plan(array('templateid' => $tpl1->get('id'), 'userid' => $user->id,
3240             'name' => 'Not good name', 'duedate' => $time + 3600, 'description' => 'Ahah', 'descriptionformat' => FORMAT_PLAIN));
3241
3242         $this->assertTrue(api::template_has_related_data($tpl1->get('id')));
3243         $this->assertFalse(api::template_has_related_data($tpl2->get('id')));
3244
3245     }
3246
3247     public function test_delete_template_delete_plans() {
3248         $this->resetAfterTest(true);
3249         $this->setAdminUser();
3250
3251         $dg = $this->getDataGenerator();
3252         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
3253
3254         $u1 = $dg->create_user();
3255         $f = $lpg->create_framework();
3256         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
3257         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
3258
3259         $tpl = $lpg->create_template();
3260
3261         $tplc1 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $c1->get('id'),
3262             'sortorder' => 1));
3263         $tplc2 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $c2->get('id'),
3264             'sortorder' => 2));
3265
3266         $p1 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u1->id));
3267
3268         // Check pre-test.
3269         $this->assertTrue(\core_competency\template::record_exists($tpl->get('id')));
3270         $this->assertEquals(2, \core_competency\template_competency::count_competencies($tpl->get('id')));
3271         $this->assertEquals(1, count(\core_competency\plan::get_records(array('templateid' => $tpl->get('id')))));
3272
3273         $result = api::delete_template($tpl->get('id'), true);
3274         $this->assertTrue($result);
3275
3276         // Check that the template does not exist anymore.
3277         $this->assertFalse(\core_competency\template::record_exists($tpl->get('id')));
3278
3279         // Check that associated competencies are also deleted.
3280         $this->assertEquals(0, \core_competency\template_competency::count_competencies($tpl->get('id')));
3281
3282         // Check that associated plan are also deleted.
3283         $this->assertEquals(0, count(\core_competency\plan::get_records(array('templateid' => $tpl->get('id')))));
3284     }
3285
3286     public function test_delete_template_unlink_plans() {
3287         $this->resetAfterTest(true);
3288         $this->setAdminUser();
3289
3290         $dg = $this->getDataGenerator();
3291         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
3292
3293         $u1 = $dg->create_user();
3294         $f = $lpg->create_framework();
3295         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
3296         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f->get('id')));
3297
3298         $tpl = $lpg->create_template();
3299
3300         $tplc1 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $c1->get('id'),
3301             'sortorder' => 1));
3302         $tplc2 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $c2->get('id'),
3303             'sortorder' => 2));
3304
3305         $p1 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u1->id));
3306
3307         // Check pre-test.
3308         $this->assertTrue(\core_competency\template::record_exists($tpl->get('id')));
3309         $this->assertEquals(2, \core_competency\template_competency::count_competencies($tpl->get('id')));
3310         $this->assertEquals(1, count(\core_competency\plan::get_records(array('templateid' => $tpl->get('id')))));
3311
3312         $result = api::delete_template($tpl->get('id'), false);
3313         $this->assertTrue($result);
3314
3315         // Check that the template does not exist anymore.
3316         $this->assertFalse(\core_competency\template::record_exists($tpl->get('id')));
3317
3318         // Check that associated competencies are also deleted.
3319         $this->assertEquals(0, \core_competency\template_competency::count_competencies($tpl->get('id')));
3320
3321         // Check that associated plan still exist but unlink from template.
3322         $plans = \core_competency\plan::get_records(array('id' => $p1->get('id')));
3323         $this->assertEquals(1, count($plans));
3324         $this->assertEquals($plans[0]->get('origtemplateid'), $tpl->get('id'));
3325         $this->assertNull($plans[0]->get('templateid'));
3326     }
3327
3328     public function test_delete_competency() {
3329         $this->resetAfterTest(true);
3330         $dg = $this->getDataGenerator();
3331         $lpg = $dg->get_plugin_generator('core_competency');
3332         $this->setAdminUser();
3333
3334         $u1 = $dg->create_user();
3335
3336         $f1 = $lpg->create_framework();
3337         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3338         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3339         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3340         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3341         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3342         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3343
3344         // Set rules on parent competency.
3345         $c1->set('ruleoutcome', competency::OUTCOME_EVIDENCE);
3346         $c1->set('ruletype', 'core_competency\\competency_rule_all');
3347         $c1->update();
3348
3349         // If we delete competeny, the related competencies relations and evidences should be deleted.
3350         // Create related competencies using one of c1a competency descendants.
3351         $rc = $lpg->create_related_competency(array(
3352             'competencyid' => $c2->get('id'),
3353             'relatedcompetencyid' => $c11b->get('id')
3354         ));
3355         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3356
3357         // Creating a standard evidence with minimal information.
3358         $uc2 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3359         $evidence = $lpg->create_evidence(array('usercompetencyid' => $uc2->get('id')));
3360         $this->assertEquals($uc2->get('id'), $evidence->get('usercompetencyid'));
3361         $uc2->delete();
3362
3363         $this->assertTrue(api::delete_competency($c1a->get('id')));
3364         $this->assertFalse(competency::record_exists($c1a->get('id')));
3365
3366         // Check that on delete, we reset the rule on parent competency.
3367         $c1->read();
3368         $this->assertNull($c1->get('ruletype'));
3369         $this->assertNull($c1->get('ruletype'));
3370         $this->assertEquals(competency::OUTCOME_NONE, $c1->get('ruleoutcome'));
3371
3372         // Check that descendants were also deleted.
3373         $this->assertFalse(competency::record_exists($c1b->get('id')));
3374         $this->assertFalse(competency::record_exists($c11b->get('id')));
3375         $this->assertFalse(competency::record_exists($c12b->get('id')));
3376
3377         // Check if evidence are also deleted.
3378         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3379
3380         // Check if related conpetency relation is deleted.
3381         $this->assertEquals(0, count(api::list_related_competencies($c2->get('id'))));
3382
3383         // Delete a simple competency.
3384         $this->assertTrue(api::delete_competency($c2->get('id')));
3385         $this->assertFalse(competency::record_exists($c2->get('id')));
3386     }
3387
3388     public function test_delete_competency_used_in_plan() {
3389         $this->resetAfterTest(true);
3390         $dg = $this->getDataGenerator();
3391         $lpg = $dg->get_plugin_generator('core_competency');
3392         $this->setAdminUser();
3393
3394         $u1 = $dg->create_user();
3395
3396         $plan = $lpg->create_plan((object) array('userid' => $u1->id));
3397
3398         $f1 = $lpg->create_framework();
3399         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3400         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3401         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3402         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3403         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3404         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3405
3406         // Add competency to plan.
3407         $pc = $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c11b->get('id')));
3408         // We can not delete a competency , if competency or competency children is associated to plan.
3409         $this->assertFalse(api::delete_competency($c1a->get('id')));
3410
3411         // We can delete the competency if we remove the competency from the plan.
3412         $pc->delete();
3413
3414         $this->assertTrue(api::delete_competency($c1a->get('id')));
3415         $this->assertFalse(competency::record_exists($c1a->get('id')));
3416         $this->assertFalse(competency::record_exists($c1b->get('id')));
3417         $this->assertFalse(competency::record_exists($c11b->get('id')));
3418         $this->assertFalse(competency::record_exists($c12b->get('id')));
3419     }
3420
3421     public function test_delete_competency_used_in_usercompetency() {
3422         $this->resetAfterTest(true);
3423         $dg = $this->getDataGenerator();
3424         $lpg = $dg->get_plugin_generator('core_competency');
3425         $this->setAdminUser();
3426
3427         $u1 = $dg->create_user();
3428
3429         $f1 = $lpg->create_framework();
3430         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3431         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3432         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3433         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3434         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3435         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3436
3437         // Create user competency.
3438         $uc1 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3439
3440         // We can not delete a competency , if competency or competency children exist in user competency.
3441         $this->assertFalse(api::delete_competency($c1a->get('id')));
3442
3443         // We can delete the competency if we remove the competency from user competency.
3444         $uc1->delete();
3445
3446         $this->assertTrue(api::delete_competency($c1a->get('id')));
3447         $this->assertFalse(competency::record_exists($c1a->get('id')));
3448         $this->assertFalse(competency::record_exists($c1b->get('id')));
3449         $this->assertFalse(competency::record_exists($c11b->get('id')));
3450         $this->assertFalse(competency::record_exists($c12b->get('id')));
3451     }
3452
3453     public function test_delete_competency_used_in_usercompetencyplan() {
3454         $this->resetAfterTest(true);
3455         $dg = $this->getDataGenerator();
3456         $lpg = $dg->get_plugin_generator('core_competency');
3457         $this->setAdminUser();
3458
3459         $u1 = $dg->create_user();
3460
3461         $plan = $lpg->create_plan((object) array('userid' => $u1->id));
3462
3463         $f1 = $lpg->create_framework();
3464         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3465         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3466         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3467         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3468         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3469         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3470
3471         // Create user competency plan.
3472         $uc2 = $lpg->create_user_competency_plan(array(
3473             'userid' => $u1->id,
3474             'competencyid' => $c11b->get('id'),
3475             'planid' => $plan->get('id')
3476         ));
3477
3478         // We can not delete a competency , if competency or competency children exist in user competency plan.
3479         $this->assertFalse(api::delete_competency($c1a->get('id')));
3480
3481         // We can delete the competency if we remove the competency from user competency plan.
3482         $uc2->delete();
3483
3484         $this->assertTrue(api::delete_competency($c1a->get('id')));
3485         $this->assertFalse(competency::record_exists($c1a->get('id')));
3486         $this->assertFalse(competency::record_exists($c1b->get('id')));
3487         $this->assertFalse(competency::record_exists($c11b->get('id')));
3488         $this->assertFalse(competency::record_exists($c12b->get('id')));
3489     }
3490
3491     public function test_delete_competency_used_in_template() {
3492         $this->resetAfterTest(true);
3493         $dg = $this->getDataGenerator();
3494         $lpg = $dg->get_plugin_generator('core_competency');
3495         $this->setAdminUser();
3496
3497         $template = $lpg->create_template();
3498
3499         $f1 = $lpg->create_framework();
3500         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3501         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3502         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3503         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3504         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3505         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3506
3507         // Add competency to a template.
3508         $tc = $lpg->create_template_competency(array(
3509             'templateid' => $template->get('id'),
3510             'competencyid' => $c11b->get('id')
3511         ));
3512         // We can not delete a competency , if competency or competency children is linked to template.
3513         $this->assertFalse(api::delete_competency($c1a->get('id')));
3514
3515         // We can delete the competency if we remove the competency from template.
3516         $tc->delete();
3517
3518         $this->assertTrue(api::delete_competency($c1a->get('id')));
3519         $this->assertFalse(competency::record_exists($c1a->get('id')));
3520         $this->assertFalse(competency::record_exists($c1b->get('id')));
3521         $this->assertFalse(competency::record_exists($c11b->get('id')));
3522         $this->assertFalse(competency::record_exists($c12b->get('id')));
3523     }
3524
3525     public function test_delete_competency_used_in_course() {
3526         $this->resetAfterTest(true);
3527         $dg = $this->getDataGenerator();
3528         $lpg = $dg->get_plugin_generator('core_competency');
3529         $this->setAdminUser();
3530
3531         $cat1 = $dg->create_category();
3532
3533         $course = $dg->create_course(array('category' => $cat1->id));
3534
3535         $f1 = $lpg->create_framework();
3536         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3537         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3538         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3539         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3540         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3541         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3542
3543         // Add competency to course.
3544         $cc = $lpg->create_course_competency(array(
3545             'courseid' => $course->id,
3546             'competencyid' => $c11b->get('id')
3547         ));
3548
3549         // We can not delete a competency if the competency or competencies children is linked to a course.
3550         $this->assertFalse(api::delete_competency($c1a->get('id')));
3551
3552         // We can delete the competency if we remove the competency from course.
3553         $cc->delete();
3554
3555         $this->assertTrue(api::delete_competency($c1a->get('id')));
3556         $this->assertFalse(competency::record_exists($c1a->get('id')));
3557         $this->assertFalse(competency::record_exists($c1b->get('id')));
3558         $this->assertFalse(competency::record_exists($c11b->get('id')));
3559         $this->assertFalse(competency::record_exists($c12b->get('id')));
3560     }
3561
3562     public function test_delete_framework() {
3563         $this->resetAfterTest(true);
3564         $dg = $this->getDataGenerator();
3565         $lpg = $dg->get_plugin_generator('core_competency');
3566         $this->setAdminUser();
3567
3568         $u1 = $dg->create_user();
3569
3570         $f1 = $lpg->create_framework();
3571         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3572         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3573         $c2id = $c2->get('id');
3574         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3575         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3576         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3577         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3578
3579         // If we delete framework, the related competencies relations and evidences should be deleted.
3580         // Create related competencies using one of c1a competency descendants.
3581         $rc = $lpg->create_related_competency(array(
3582             'competencyid' => $c2->get('id'),
3583             'relatedcompetencyid' => $c11b->get('id')
3584         ));
3585         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3586
3587         // Creating a standard evidence with minimal information.
3588         $uc2 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3589         $evidence = $lpg->create_evidence(array('usercompetencyid' => $uc2->get('id')));
3590         $this->assertEquals($uc2->get('id'), $evidence->get('usercompetencyid'));
3591         $uc2->delete();
3592
3593         $this->assertTrue(api::delete_framework($f1->get('id')));
3594         $this->assertFalse(competency_framework::record_exists($f1->get('id')));
3595
3596         // Check that all competencies were also deleted.
3597         $this->assertFalse(competency::record_exists($c1->get('id')));
3598         $this->assertFalse(competency::record_exists($c2->get('id')));
3599         $this->assertFalse(competency::record_exists($c1a->get('id')));
3600         $this->assertFalse(competency::record_exists($c1b->get('id')));
3601         $this->assertFalse(competency::record_exists($c11b->get('id')));
3602         $this->assertFalse(competency::record_exists($c12b->get('id')));
3603
3604         // Check if evidence are also deleted.
3605         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3606
3607         // Check if related conpetency relation is deleted.
3608         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3609
3610         // Delete a simple framework.
3611         $f2 = $lpg->create_framework();
3612         $this->assertTrue(api::delete_framework($f2->get('id')));
3613         $this->assertFalse(competency_framework::record_exists($f2->get('id')));
3614     }
3615
3616     public function test_delete_framework_competency_used_in_plan() {
3617         $this->resetAfterTest(true);
3618         $dg = $this->getDataGenerator();
3619         $lpg = $dg->get_plugin_generator('core_competency');
3620         $this->setAdminUser();
3621
3622         $u1 = $dg->create_user();
3623
3624         $plan = $lpg->create_plan((object) array('userid' => $u1->id));
3625
3626         $f1 = $lpg->create_framework();
3627         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3628         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3629         $c2id = $c2->get('id');
3630         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3631         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3632         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3633         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3634
3635         // Create related competencies.
3636         $rc = $lpg->create_related_competency(array(
3637             'competencyid' => $c2->get('id'),
3638             'relatedcompetencyid' => $c11b->get('id')
3639         ));
3640         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3641
3642         // Creating a standard evidence with minimal information.
3643         $uc2 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3644         $usercompetencyid = $uc2->get('id');
3645         $evidence = $lpg->create_evidence(array('usercompetencyid' => $usercompetencyid));
3646         $this->assertEquals($uc2->get('id'), $evidence->get('usercompetencyid'));
3647         $uc2->delete();
3648
3649         // Add competency to plan.
3650         $pc = $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c11b->get('id')));
3651         // We can not delete a framework , if competency or competency children is associated to plan.
3652         $this->assertFalse(api::delete_framework($f1->get('id')));
3653         // Check that none of associated data are deleted.
3654         $this->assertEquals($usercompetencyid, $evidence->read()->get('usercompetencyid'));
3655         $this->assertEquals($c2->get('id'), $rc->read()->get('competencyid'));
3656
3657         // We can delete the competency if we remove the competency from the plan.
3658         $pc->delete();
3659
3660         $this->assertTrue(api::delete_framework($f1->get('id')));
3661         $this->assertFalse(competency::record_exists($c1->get('id')));
3662         $this->assertFalse(competency::record_exists($c2->get('id')));
3663         $this->assertFalse(competency::record_exists($c1a->get('id')));
3664         $this->assertFalse(competency::record_exists($c1b->get('id')));
3665         $this->assertFalse(competency::record_exists($c11b->get('id')));
3666         $this->assertFalse(competency::record_exists($c12b->get('id')));
3667         // Check if evidence are also deleted.
3668         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3669
3670         // Check if related conpetency relation is deleted.
3671         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3672     }
3673
3674     public function test_delete_framework_competency_used_in_usercompetency() {
3675         $this->resetAfterTest(true);
3676         $dg = $this->getDataGenerator();
3677         $lpg = $dg->get_plugin_generator('core_competency');
3678         $this->setAdminUser();
3679
3680         $u1 = $dg->create_user();
3681
3682         $f1 = $lpg->create_framework();
3683         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3684         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3685         $c2id = $c2->get('id');
3686         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3687         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3688         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3689         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3690
3691         // Create related competencies.
3692         $rc = $lpg->create_related_competency(array(
3693             'competencyid' => $c2->get('id'),
3694             'relatedcompetencyid' => $c11b->get('id')
3695         ));
3696         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3697
3698         // Creating a standard evidence with minimal information.
3699         $uc1 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3700         $usercompetencyid = $uc1->get('id');
3701         $evidence = $lpg->create_evidence(array('usercompetencyid' => $usercompetencyid));
3702         $this->assertEquals($uc1->get('id'), $evidence->get('usercompetencyid'));
3703         $uc1->delete();
3704
3705         // Create user competency.
3706         $uc2 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3707
3708         // We can not delete a framework , if competency or competency children exist in user competency.
3709         $this->assertFalse(api::delete_framework($f1->get('id')));
3710         // Check that none of associated data are deleted.
3711         $this->assertEquals($usercompetencyid, $evidence->read()->get('usercompetencyid'));
3712         $this->assertEquals($c2->get('id'), $rc->read()->get('competencyid'));
3713
3714         // We can delete the framework if we remove the competency from user competency.
3715         $uc2->delete();
3716
3717         $this->assertTrue(api::delete_framework($f1->get('id')));
3718         $this->assertFalse(competency::record_exists($c1->get('id')));
3719         $this->assertFalse(competency::record_exists($c2->get('id')));
3720         $this->assertFalse(competency::record_exists($c1a->get('id')));
3721         $this->assertFalse(competency::record_exists($c1b->get('id')));
3722         $this->assertFalse(competency::record_exists($c11b->get('id')));
3723         $this->assertFalse(competency::record_exists($c12b->get('id')));
3724         // Check if evidence are also deleted.
3725         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3726
3727         // Check if related conpetency relation is deleted.
3728         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3729     }
3730
3731     public function test_delete_framework_competency_used_in_usercompetencyplan() {
3732         $this->resetAfterTest(true);
3733         $dg = $this->getDataGenerator();
3734         $lpg = $dg->get_plugin_generator('core_competency');
3735         $this->setAdminUser();
3736
3737         $u1 = $dg->create_user();
3738
3739         $plan = $lpg->create_plan((object) array('userid' => $u1->id));
3740
3741         $f1 = $lpg->create_framework();
3742         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3743         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3744         $c2id = $c2->get('id');
3745         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3746         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3747         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3748         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3749
3750         // Create related competencies.
3751         $rc = $lpg->create_related_competency(array(
3752             'competencyid' => $c2->get('id'),
3753             'relatedcompetencyid' => $c11b->get('id')
3754         ));
3755         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3756
3757         // Creating a standard evidence with minimal information.
3758         $uc1 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3759         $usercompetencyid = $uc1->get('id');
3760         $evidence = $lpg->create_evidence(array('usercompetencyid' => $usercompetencyid));
3761         $this->assertEquals($uc1->get('id'), $evidence->get('usercompetencyid'));
3762         $uc1->delete();
3763
3764         // Create user competency plan.
3765         $uc2 = $lpg->create_user_competency_plan(array(
3766             'userid' => $u1->id,
3767             'competencyid' => $c11b->get('id'),
3768             'planid' => $plan->get('id')
3769         ));
3770
3771         // We can not delete a framework , if competency or competency children exist in user competency plan.
3772         $this->assertFalse(api::delete_framework($f1->get('id')));
3773         // Check that none of associated data are deleted.
3774         $this->assertEquals($usercompetencyid, $evidence->read()->get('usercompetencyid'));
3775         $this->assertEquals($c2->get('id'), $rc->read()->get('competencyid'));
3776
3777         // We can delete the framework if we remove the competency from user competency plan.
3778         $uc2->delete();
3779
3780         $this->assertTrue(api::delete_framework($f1->get('id')));
3781         $this->assertFalse(competency::record_exists($c1->get('id')));
3782         $this->assertFalse(competency::record_exists($c2->get('id')));
3783         $this->assertFalse(competency::record_exists($c1a->get('id')));
3784         $this->assertFalse(competency::record_exists($c1b->get('id')));
3785         $this->assertFalse(competency::record_exists($c11b->get('id')));
3786         $this->assertFalse(competency::record_exists($c12b->get('id')));
3787         // Check if evidence are also deleted.
3788         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3789
3790         // Check if related conpetency relation is deleted.
3791         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3792     }
3793
3794     public function test_delete_framework_competency_used_in_template() {
3795         $this->resetAfterTest(true);
3796         $dg = $this->getDataGenerator();
3797         $lpg = $dg->get_plugin_generator('core_competency');
3798         $this->setAdminUser();
3799
3800         $u1 = $dg->create_user();
3801         $template = $lpg->create_template();
3802
3803         $f1 = $lpg->create_framework();
3804         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3805         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3806         $c2id = $c2->get('id');
3807         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3808         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3809         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3810         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3811
3812         // Create related competencies.
3813         $rc = $lpg->create_related_competency(array(
3814             'competencyid' => $c2->get('id'),
3815             'relatedcompetencyid' => $c11b->get('id')
3816         ));
3817         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3818
3819         // Creating a standard evidence with minimal information.
3820         $uc1 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3821         $usercompetencyid = $uc1->get('id');
3822         $evidence = $lpg->create_evidence(array('usercompetencyid' => $usercompetencyid));
3823         $this->assertEquals($uc1->get('id'), $evidence->get('usercompetencyid'));
3824         $uc1->delete();
3825
3826         // Add competency to a template.
3827         $tc = $lpg->create_template_competency(array(
3828             'templateid' => $template->get('id'),
3829             'competencyid' => $c11b->get('id')
3830         ));
3831         // We can not delete a framework , if competency or competency children is linked to template.
3832         $this->assertFalse(api::delete_framework($f1->get('id')));
3833         // Check that none of associated data are deleted.
3834         $this->assertEquals($usercompetencyid, $evidence->read()->get('usercompetencyid'));
3835         $this->assertEquals($c2->get('id'), $rc->read()->get('competencyid'));
3836
3837         // We can delete the framework if we remove the competency from template.
3838         $tc->delete();
3839
3840         $this->assertTrue(api::delete_framework($f1->get('id')));
3841         $this->assertFalse(competency::record_exists($c1->get('id')));
3842         $this->assertFalse(competency::record_exists($c2->get('id')));
3843         $this->assertFalse(competency::record_exists($c1a->get('id')));
3844         $this->assertFalse(competency::record_exists($c1b->get('id')));
3845         $this->assertFalse(competency::record_exists($c11b->get('id')));
3846         $this->assertFalse(competency::record_exists($c12b->get('id')));
3847         // Check if evidence are also deleted.
3848         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3849
3850         // Check if related conpetency relation is deleted.
3851         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3852     }
3853
3854     public function test_delete_framework_competency_used_in_course() {
3855         $this->resetAfterTest(true);
3856         $dg = $this->getDataGenerator();
3857         $lpg = $dg->get_plugin_generator('core_competency');
3858         $this->setAdminUser();
3859
3860         $cat1 = $dg->create_category();
3861         $u1 = $dg->create_user();
3862         $course = $dg->create_course(array('category' => $cat1->id));
3863
3864         $f1 = $lpg->create_framework();
3865         $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3866         $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));
3867         $c2id = $c2->get('id');
3868         $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1->get('id')));
3869         $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1a->get('id')));
3870         $c11b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3871         $c12b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id'), 'parentid' => $c1b->get('id')));
3872
3873         // Create related competencies.
3874         $rc = $lpg->create_related_competency(array(
3875             'competencyid' => $c2->get('id'),
3876             'relatedcompetencyid' => $c11b->get('id')
3877         ));
3878         $this->assertEquals($c11b->get('id'), $rc->get('relatedcompetencyid'));
3879
3880         // Creating a standard evidence with minimal information.
3881         $uc1 = $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $c11b->get('id')));
3882         $usercompetencyid = $uc1->get('id');
3883         $evidence = $lpg->create_evidence(array('usercompetencyid' => $usercompetencyid));
3884         $this->assertEquals($uc1->get('id'), $evidence->get('usercompetencyid'));
3885         $uc1->delete();
3886
3887         // Add competency to course.
3888         $cc = $lpg->create_course_competency(array(
3889             'courseid' => $course->id,
3890             'competencyid' => $c11b->get('id')
3891         ));
3892
3893         // We can not delete a framework if the competency or competencies children is linked to a course.
3894         $this->assertFalse(api::delete_framework($f1->get('id')));
3895         // Check that none of associated data are deleted.
3896         $this->assertEquals($usercompetencyid, $evidence->read()->get('usercompetencyid'));
3897         $this->assertEquals($c2->get('id'), $rc->read()->get('competencyid'));
3898
3899         // We can delete the framework if we remove the competency from course.
3900         $cc->delete();
3901
3902         $this->assertTrue(api::delete_framework($f1->get('id')));
3903         $this->assertFalse(competency::record_exists($c1->get('id')));
3904         $this->assertFalse(competency::record_exists($c2->get('id')));
3905         $this->assertFalse(competency::record_exists($c1a->get('id')));
3906         $this->assertFalse(competency::record_exists($c1b->get('id')));
3907         $this->assertFalse(competency::record_exists($c11b->get('id')));
3908         $this->assertFalse(competency::record_exists($c12b->get('id')));
3909         // Check if evidence are also deleted.
3910         $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get('id'))));
3911
3912         // Check if related conpetency relation is deleted.
3913         $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
3914     }
3915
3916     public function test_grade_competency_in_course_permissions() {
3917         $this->resetAfterTest();
3918         $dg = $this->getDataGenerator();
3919
3920         $c1 = $dg->create_course();
3921         $c2 = $dg->create_course();
3922         $sysctx = context_system::instance();
3923         $c1ctx = context_course::instance($c1->id);
3924         $c2ctx = context_course::instance($c2->id);
3925
3926         $teacher1 = $dg->create_user();
3927         $noneditingteacher = $dg->create_user();
3928         $student1 = $dg->create_user();
3929         $student2 = $dg->create_user();
3930         $notstudent1 = $dg->create_user();
3931
3932         $lpg = $dg->get_plugin_generator('core_competency');
3933         $framework = $lpg->create_framework();
3934         $comp1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
3935         $comp2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
3936         $lpg->create_course_competency(array('courseid' => $c1->id, 'competencyid' => $comp1->get('id')));
3937
3938         $studentarch = get_archetype_roles('student');
3939         $studentrole = array_shift($studentarch);
3940
3941         $gradablerole = $dg->create_role();
3942         assign_capability('moodle/competency:coursecompetencygradable', CAP_ALLOW, $gradablerole, $sysctx->id);
3943
3944         $notgradablerole = $dg->create_role();
3945         assign_capability('moodle/competency:coursecompetencygradable', CAP_PROHIBIT, $notgradablerole, $sysctx->id);
3946
3947         $canviewucrole = $dg->create_role();
3948         assign_capability('moodle/competency:usercompetencyview', CAP_ALLOW, $canviewucrole, $sysctx->id);
3949
3950         $cannotviewcomp = $dg->create_role();
3951         assign_capability('moodle/competency:competencyview', CAP_PROHIBIT, $cannotviewcomp, $sysctx->id);
3952
3953         $canmanagecomp = $dg->create_role();
3954         assign_capability('moodle/competency:competencymanage', CAP_ALLOW, $canmanagecomp, $sysctx->id);
3955
3956         $cangraderole = $dg->create_role();
3957         assign_capability('moodle/competency:competencygrade', CAP_ALLOW, $cangraderole, $sysctx->id);
3958
3959         // Enrol s1 and s2 as students in course 1.
3960         $dg->enrol_user($student1->id, $c1->id, $studentrole->id);
3961         $dg->enrol_user($student2->id, $c1->id, $studentrole->id);
3962
3963         // Mark the s2 as not being 'gradable'.
3964         $dg->role_assign($notgradablerole, $student2->id, $c1ctx->id);
3965
3966         // Mark the 'non a student' as 'gradable' throughout the site.
3967         $dg->role_assign($gradablerole, $notstudent1->id, $sysctx->id);
3968
3969         // From now we'll iterate over each permission.
3970         accesslib_clear_all_caches_for_unit_testing();
3971         $this->setUser($teacher1);
3972
3973         $this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'View a user competency',
3974             $c1->id, $student1->id, $comp1->get('id'));
3975
3976         // Give permission to view competencies.
3977         $dg->role_assign($canviewucrole, $teacher1->id, $c1ctx->id);
3978         accesslib_clear_all_caches_for_unit_testing();
3979         $this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'Set competency rating',
3980             $c1->id, $student1->id, $comp1->get('id'));
3981
3982         // Give permission to rate.
3983         $dg->role_assign($cangraderole, $teacher1->id, $c1ctx->id);
3984         accesslib_clear_all_caches_for_unit_testing();
3985         $this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get('id'));
3986
3987         // Remove permssion to read competencies, this leads to error.
3988         $dg->role_assign($cannotviewcomp, $teacher1->id, $sysctx->id);
3989         accesslib_clear_all_caches_for_unit_testing();
3990         $this->assertExceptionWithGradeCompetencyInCourse('required_capability_exception', 'View competency frameworks',
3991             $c1->id, $student1->id, $comp1->get('id'));
3992
3993         // Give permssion to manage course competencies, this leads to success.
3994         $dg->role_assign($canmanagecomp, $teacher1->id, $sysctx->id);
3995         accesslib_clear_all_caches_for_unit_testing();
3996         $this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get('id'));
3997
3998         // Try to grade a user that is not gradable, lead to errors.
3999         $this->assertExceptionWithGradeCompetencyInCourse('coding_exception', 'The competency may not be rated at this time.',
4000             $c1->id, $student2->id, $comp1->get('id'));
4001
4002         // Try to grade a competency not in the course.
4003         $this->assertExceptionWithGradeCompetencyInCourse('coding_exception', 'The competency does not belong to this course',
4004             $c1->id, $student1->id, $comp2->get('id'));
4005
4006         // Try to grade a user that is not enrolled, even though they are 'gradable'.
4007         $this->assertExceptionWithGradeCompetencyInCourse('coding_exception', 'The competency may not be rated at this time.',
4008             $c1->id, $notstudent1->id, $comp1->get('id'));
4009
4010         // Give permission for non-editing teacher to grade.
4011         $dg->role_assign($canviewucrole, $noneditingteacher->id, $c1ctx->id);
4012         $dg->role_assign($cangraderole, $noneditingteacher->id, $c1ctx->id);
4013         $this->setUser($noneditingteacher);
4014
4015         accesslib_clear_all_caches_for_unit_testing();
4016         $this->assertSuccessWithGradeCompetencyInCourse($c1->id, $student1->id, $comp1->get('id'));
4017     }
4018
4019     /**
4020      * Assert that a competency was graded in a course.
4021      *
4022      * @param int $courseid The course ID.
4023      * @param int $userid The user ID.
4024      * @param int $compid The competency ID.
4025      * @param int $grade The grade.
4026      */
4027     protected function assertSuccessWithGradeCompetencyInCourse($courseid, $userid, $compid, $grade = 1) {
4028         $beforecount = evidence::count_records();
4029         api::grade_competency_in_course($courseid, $userid, $compid, $grade);
4030         $this->assertEquals($beforecount + 1, evidence::count_records());
4031         $uc = user_competency::get_record(array('userid' => $userid, 'competencyid' => $compid));
4032         $records = evidence::get_records(array(), 'id', 'DESC', 0, 1);
4033         $evidence = array_pop($records);
4034         $this->assertEquals($uc->get('id'), $evidence->get('usercompetencyid'));
4035     }
4036
4037     /**
4038      * Assert that grading a competency in course throws an exception.
4039      *
4040      * @param string $exceptiontype The exception type.
4041      * @param string $exceptiontest The exceptiont text.
4042      * @param int $courseid The course ID.
4043      * @param int $userid The user ID.
4044      * @param int $compid The competency ID.
4045      * @param int $grade The grade.
4046      */
4047     protected function assertExceptionWithGradeCompetencyInCourse($exceptiontype, $exceptiontext, $courseid, $userid, $compid,
4048                                                                   $grade = 1) {
4049
4050         $raised = false;
4051         try {
4052             api::grade_competency_in_course($courseid, $userid, $compid, $grade);
4053         } catch (moodle_exception $e) {
4054             $raised = true;
4055             $this->assertInstanceOf($exceptiontype, $e);
4056             $this->assertRegExp('@' . $exceptiontext . '@', $e->getMessage());
4057         }
4058
4059         if (!$raised) {
4060             $this->fail('Grading should not be allowed.');
4061         }
4062     }
4063
4064     /**
4065      * Test list of evidences for plan completed and not completed.
4066      */
4067     public function test_list_evidence() {
4068         global $DB;
4069
4070         $this->resetAfterTest(true);
4071         $dg = $this->getDataGenerator();
4072         $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
4073
4074         $syscontext = context_system::instance();
4075
4076         // Create users.
4077         $user = $dg->create_user();
4078         $this->setUser($user);
4079
4080         // Create a framework and assign competencies.
4081         $framework = $lpg->create_framework();
4082         $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4083         $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4084
4085         // Create 2 user plans and add competency to each plan.
4086         $p1 = $lpg->create_plan(array('userid' => $user->id));
4087         $p2 = $lpg->create_plan(array('userid' => $user->id));
4088         $pc1 = $lpg->create_plan_competency(array('planid' => $p1->get('id'), 'competencyid' => $c1->get('id')));
4089         $pc2 = $lpg->create_plan_competency(array('planid' => $p2->get('id'), 'competencyid' => $c1->get('id')));
4090
4091         // Create user competency and add an evidence.
4092         $uc = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id')));
4093         $e1 = $lpg->create_evidence(array('usercompetencyid' => $uc->get('id')));
4094
4095         // Check both plans as one evidence.
4096         $this->assertEquals(1, count(api::list_evidence($user->id, $c1->get('id'), $p1->get('id'))));
4097         $this->assertEquals(1, count(api::list_evidence($user->id, $c1->get('id'), $p2->get('id'))));
4098
4099         // Complete second plan.
4100         $p2->set('status', plan::STATUS_COMPLETE);
4101         $p2->update();
4102
4103         // Add another evidence for the same competency, but in the future (time + 1).
4104         $e2 = $lpg->create_evidence(array('usercompetencyid' => $uc->get('id')));
4105         $evidencesql = "UPDATE {" . evidence::TABLE . "} SET timecreated = :currenttime WHERE id = :evidenceid";
4106         $DB->execute($evidencesql, array('currenttime' => time() + 1, 'evidenceid' => $e2->get('id')));
4107
4108         // Check that the first plan, which is not completed, has all the evidence.
4109         $this->assertEquals(2, count(api::list_evidence($user->id, $c1->get('id'), $p1->get('id'))));
4110
4111         // Check that the second plan, completed before the new evidence, only has the first piece of evidence.
4112         $listevidences = api::list_evidence($user->id, $c1->get('id'), $p2->get('id'));
4113         $this->assertEquals(1, count($listevidences));
4114         $this->assertEquals($e1->get('id'), $listevidences[$e1->get('id')]->get('id'));
4115     }
4116
4117     /**
4118      * Get a user competency in a course.
4119      */
4120     public function test_get_user_competency_in_course() {
4121         $this->resetAfterTest(true);
4122         $dg = $this->getDataGenerator();
4123         $lpg = $dg->get_plugin_generator('core_competency');
4124         $this->setAdminUser();
4125
4126         $user = $dg->create_user();
4127         $c1 = $dg->create_course();
4128
4129         // Enrol the user so they can be rated in the course.
4130         $studentarch = get_archetype_roles('student');
4131         $studentrole = array_shift($studentarch);
4132         $coursecontext = context_course::instance($c1->id);
4133         $dg->role_assign($studentrole->id, $user->id, $coursecontext->id);
4134         $dg->enrol_user($user->id, $c1->id, $studentrole->id);
4135
4136         $framework = $lpg->create_framework();
4137         $comp1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4138         $comp2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4139         $lpg->create_course_competency(array('competencyid' => $comp1->get('id'), 'courseid' => $c1->id));
4140         $lpg->create_course_competency(array('competencyid' => $comp2->get('id'), 'courseid' => $c1->id));
4141
4142         // Create a user competency for comp1.
4143         api::grade_competency_in_course($c1, $user->id, $comp1->get('id'), 3, 'Unit test');
4144
4145         // Test for competency already exist in user_competency.
4146         $uc = api::get_user_competency_in_course($c1->id, $user->id, $comp1->get('id'));
4147         $this->assertEquals($comp1->get('id'), $uc->get('competencyid'));
4148         $this->assertEquals($user->id, $uc->get('userid'));
4149         $this->assertEquals(3, $uc->get('grade'));
4150         $this->assertEquals(true, $uc->get('proficiency'));
4151
4152         // Test for competency does not exist in user_competency.
4153         $uc2 = api::get_user_competency_in_course($c1->id, $user->id, $comp2->get('id'));
4154         $this->assertEquals($comp2->get('id'), $uc2->get('competencyid'));
4155         $this->assertEquals($user->id, $uc2->get('userid'));
4156         $this->assertEquals(null, $uc2->get('grade'));
4157         $this->assertEquals(null, $uc2->get('proficiency'));
4158     }
4159
4160     /**
4161      * Test course statistics api functions.
4162      */
4163     public function test_course_statistics() {
4164         $this->resetAfterTest(true);
4165         $dg = $this->getDataGenerator();
4166         $lpg = $dg->get_plugin_generator('core_competency');
4167         $this->setAdminUser();
4168
4169         $u1 = $dg->create_user();
4170         $u2 = $dg->create_user();
4171         $u3 = $dg->create_user();
4172         $u4 = $dg->create_user();
4173         $c1 = $dg->create_course();
4174         $framework = $lpg->create_framework();
4175         // Enrol students in the course.
4176         $studentarch = get_archetype_roles('student');
4177         $studentrole = array_shift($studentarch);
4178         $coursecontext = context_course::instance($c1->id);
4179         $dg->role_assign($studentrole->id, $u1->id, $coursecontext->id);
4180         $dg->enrol_user($u1->id, $c1->id, $studentrole->id);
4181         $dg->role_assign($studentrole->id, $u2->id, $coursecontext->id);
4182         $dg->enrol_user($u2->id, $c1->id, $studentrole->id);
4183         $dg->role_assign($studentrole->id, $u3->id, $coursecontext->id);
4184         $dg->enrol_user($u3->id, $c1->id, $studentrole->id);
4185         $dg->role_assign($studentrole->id, $u4->id, $coursecontext->id);
4186         $dg->enrol_user($u4->id, $c1->id, $studentrole->id);
4187
4188         // Create 6 competencies.
4189         $comp1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4190         $comp2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4191         $comp3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4192         $comp4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4193         $comp5 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4194         $comp6 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4195
4196         // Link 6 out of 6 to a course.
4197         $lpg->create_course_competency(array('competencyid' => $comp1->get('id'), 'courseid' => $c1->id));
4198         $lpg->create_course_competency(array('competencyid' => $comp2->get('id'), 'courseid' => $c1->id));
4199         $lpg->create_course_competency(array('competencyid' => $comp3->get('id'), 'courseid' => $c1->id));
4200         $lpg->create_course_competency(array('competencyid' => $comp4->get('id'), 'courseid' => $c1->id));
4201         $lpg->create_course_competency(array('competencyid' => $comp5->get('id'), 'courseid' => $c1->id));
4202         $lpg->create_course_competency(array('competencyid' => $comp6->get('id'), 'courseid' => $c1->id));
4203
4204         // Rate some competencies.
4205         // User 1.
4206         api::grade_competency_in_course($c1, $u1->id, $comp1->get('id'), 4, 'Unit test');
4207         api::grade_competency_in_course($c1, $u1->id, $comp2->get('id'), 4, 'Unit test');
4208         api::grade_competency_in_course($c1, $u1->id, $comp3->get('id'), 4, 'Unit test');
4209         api::grade_competency_in_course($c1, $u1->id, $comp4->get('id'), 4, 'Unit test');
4210         // User 2.
4211         api::grade_competency_in_course($c1, $u2->id, $comp1->get('id'), 1, 'Unit test');
4212         api::grade_competency_in_course($c1, $u2->id, $comp2->get('id'), 1, 'Unit test');
4213         api::grade_competency_in_course($c1, $u2->id, $comp3->get('id'), 1, 'Unit test');
4214         api::grade_competency_in_course($c1, $u2->id, $comp4->get('id'), 1, 'Unit test');
4215         // User 3.
4216         api::grade_competency_in_course($c1, $u3->id, $comp1->get('id'), 3, 'Unit test');
4217         api::grade_competency_in_course($c1, $u3->id, $comp2->get('id'), 3, 'Unit test');
4218         // User 4.
4219         api::grade_competency_in_course($c1, $u4->id, $comp1->get('id'), 2, 'Unit test');
4220         api::grade_competency_in_course($c1, $u4->id, $comp2->get('id'), 2, 'Unit test');
4221
4222         // OK we have enough data - lets call some API functions and check for expected results.
4223
4224         $result = api::count_proficient_competencies_in_course_for_user($c1->id, $u1->id);
4225         $this->assertEquals(4, $result);
4226         $result = api::count_proficient_competencies_in_course_for_user($c1->id, $u2->id);
4227         $this->assertEquals(0, $result);
4228         $result = api::count_proficient_competencies_in_course_for_user($c1->id, $u3->id);
4229         $this->assertEquals(2, $result);
4230         $result = api::count_proficient_competencies_in_course_for_user($c1->id, $u4->id);
4231         $this->assertEquals(0, $result);
4232
4233         $result = api::get_least_proficient_competencies_for_course($c1->id, 0, 2);
4234         // We should get 5 and 6 in repeatable order.
4235         $valid = false;
4236         if (($comp5->get('id') == $result[0]->get('id')) || ($comp6->get('id') == $result[0]->get('id'))) {
4237             $valid = true;
4238         }
4239         $this->assertTrue($valid);
4240         $valid = false;
4241         if (($comp5->get('id') == $result[1]->get('id')) || ($comp6->get('id') == $result[1]->get('id'))) {
4242             $valid = true;
4243         }
4244         $this->assertTrue($valid);
4245         $expected = $result[1]->get('id');
4246         $result = api::get_least_proficient_competencies_for_course($c1->id, 1, 1);
4247         $this->assertEquals($result[0]->get('id'), $expected);
4248     }
4249
4250     /**
4251      * Test template statistics api functions.
4252      */
4253     public function test_template_statistics() {
4254         $this->resetAfterTest(true);
4255         $dg = $this->getDataGenerator();
4256         $lpg = $dg->get_plugin_generator('core_competency');
4257         $this->setAdminUser();
4258
4259         $u1 = $dg->create_user();
4260         $u2 = $dg->create_user();
4261         $u3 = $dg->create_user();
4262         $u4 = $dg->create_user();
4263         $c1 = $dg->create_course();
4264         $framework = $lpg->create_framework();
4265
4266         // Create 6 competencies.
4267         $comp1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4268         $comp2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4269         $comp3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4270         $comp4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4271         $comp5 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4272         $comp6 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));
4273
4274         // Link 5 out of 6 to a course.
4275         $lpg->create_course_competency(array('competencyid' => $comp1->get('id'), 'courseid' => $c1->id));
4276         $lpg->create_course_competency(array('competencyid' => $comp2->get('id'), 'courseid' => $c1->id));
4277         $lpg->create_course_competency(array('competencyid' => $comp3->get('id'), 'courseid' => $c1->id));
4278         $lpg->create_course_competency(array('competencyid' => $comp4->get('id'), 'courseid' => $c1->id));
4279         $lpg->create_course_competency(array('competencyid' => $comp5->get('id'), 'courseid' => $c1->id));
4280
4281         // Put all 6 in a template.
4282         $tpl = $this->getDataGenerator()->get_plugin_generator('core_competency')->create_template();
4283         $tplc1 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp1->get('id')));
4284         $tplc2 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp2->get('id')));
4285         $tplc3 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp3->get('id')));
4286         $tplc4 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp4->get('id')));
4287         $tplc5 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp5->get('id')));
4288         $tplc6 = $lpg->create_template_competency(array('templateid' => $tpl->get('id'), 'competencyid' => $comp6->get('id')));
4289
4290         // Create some plans from the template.
4291         $p1 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u1->id));
4292         $p2 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u2->id));
4293         $p3 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u3->id));
4294         $p4 = $lpg->create_plan(array('templateid' => $tpl->get('id'), 'userid' => $u4->id));
4295
4296         // Rate some competencies.
4297         // User 1.
4298         $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $comp1->get('id'),
4299                 'proficiency' => true, 'grade' => 1 ));
4300         $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $comp2->get('id'),
4301                 'proficiency' => true, 'grade' => 1 ));
4302         $lpg->create_user_competency(array('userid' => $u1->id, 'competencyid' => $comp3->get('id'),
4303                 'proficiency' => true, 'grade' => 1 ));
4304         // User 2.
4305         $lpg->create_user_competency(array('userid' => $u2->id, 'competencyid' => $comp1->get('id'),
4306                 'proficiency' => false, 'grade' => 1 ));
4307         $lpg->create_user_competency(array('userid' => $u2->id, 'competencyid' => $comp2->get('id'),
4308                 'proficiency' => false, 'grade' => 1 ));
4309         $lpg->create_user_competency(array('userid' => $u2->id, 'competencyid' => $comp3->get('id'),
4310                 'proficiency' => false, 'grade' => 1 ));
4311         // User 3.
4312         $lpg->create_user_competency(array('userid' => $u3->id, 'competencyid' => $comp2->get('id'),
4313                 'proficiency' => false, 'grade' => 1 ));
4314         $lpg->create_user_competency(array('userid' => $u3->id, 'competencyid' => $comp3->get('id'),
4315                 'proficiency' => true, 'grade' => 1 ));
4316         $lpg->create_user_competency(array('userid' => $u3->id, 'competencyid' => $comp4->get('id'),
4317                 'proficiency' => false, 'grade' => 1 ));
4318         $lpg->create_user_competency(array('userid' => $u3->id, 'competencyid' => $comp5->get('id'),
4319                 'proficiency' => true, 'grade' => 1 ));
4320         // User 4.
4321         $lpg->create_user_competency(array('userid' => $u4->id, 'competencyid' => $comp3->get('id'),
4322                 'proficiency' => true, 'grade' => 1 ));
4323         $lpg->create_user_competency(array('userid' => $u4->id, 'competencyid' => $comp5->get('id'),
4324                 'proficiency' => true, 'grade' => 1 ));
4325
4326         // Complete 3 out of 4 plans.
4327         api::complete_plan($p1->get('id'));
4328         api::complete_plan($p2->get('id'));
4329         api::complete_plan($p3->get('id'));
4330
4331         // OK we have enough data - lets call some API functions and check for expected results.
4332
4333         $result = api::count_competencies_in_template_with_no_courses($tpl->get('id'));
4334         $this->assertEquals(1, $result);
4335
4336         $result = api::count_plans_for_template($tpl->get('id'));
4337         $this->assertEquals(4, $result);
4338
4339         $result = api::count_plans_for_template($tpl->get('id'), plan::STATUS_COMPLETE);
4340         $this->assertEquals(3, $result);
4341
4342         // This counts the records of competencies in completed plans for all users with a plan from this template.
4343         $result = api::count_user_competency_plans_for_template($tpl->get('id'));
4344         // There should be 3 plans * 6 competencies.
4345         $this->assertEquals(18, $result);
4346
4347         // This counts the records of proficient competencies in completed plans for all users with a plan from this template.
4348         $result = api::count_user_competency_plans_for_template($tpl->get('id'), true);
4349         // There should be 5.
4350         $this->assertEquals(5, $result);
4351
4352         // This counts the records of not proficient competencies in completed plans for all users with a plan from this template.
4353         $result = api::count_user_competency_plans_for_template($tpl->get('id'), false);
4354         // There should be 13.
4355         $this->assertEquals(13, $result);
4356
4357         // This lists the plans based on this template, optionally filtered by status.
4358         $result = api::list_plans_for_template($tpl->get('id'));
4359
4360         $this->assertEquals(4, count($result));
4361         foreach ($result as $one) {
4362             $this->assertInstanceOf('\core_competency\plan', $one);
4363         }
4364         // This lists the plans based on this template, optionally filtered by status.
4365         $result = api::list_plans_for_template($tpl->get('id'), plan::STATUS_COMPLETE);
4366
4367         $this->assertEquals(3, count($result));
4368         foreach ($result as $one) {
4369             $this->assertInstanceOf('\core_competency\plan', $one);
4370             $this->assertEquals(plan::STATUS_COMPLETE, $one->get('status'));
4371         }
4372
4373         $result = api::get_least_proficient_competencies_for_template($tpl->get('id'), 0, 2);
4374
4375         // Our times completed counts should look like this:
4376         // - comp1 - 1
4377         // - comp2 - 1
4378         // - comp3 - 2
4379         // - comp4 - 0
4380         // - comp5 - 1
4381         // - comp6 - 0
4382         //
4383         // And this is a fullstop to make CiBoT happy.
4384         $this->assertEquals(2, count($result));
4385         $leastarray = array($comp4->get('id'), $comp6->get('id'));
4386         foreach ($result as $one) {
4387             $this->assertInstanceOf('\core_competency\competency', $one);
4388             $this->assertContains($one->get('id'), $leastarray);
4389         }
4390     }
4391
4392     public function test_is_scale_used_anywhere() {
4393         $this->resetAfterTest();
4394         $dg = $this->getDataGenerator();
4395         $lpg = $dg->get_plugin_generator('core_competency');
4396
4397         $scale1 = $dg->create_scale();
4398         $scale2 = $dg->create_scale();
4399         $scale3 = $dg->create_scale();
4400         $scale4 = $dg->create_scale();
4401
4402         $this->assertFalse(api::is_scale_used_anywhere($scale1->id));
4403         $this->assertFalse(api::is_scale_used_anywhere($scale2->id));
4404         $this->assertFalse(api::is_scale_used_anywhere($scale3->id));
4405         $this->assertFalse(api::is_scale_used_anywhere($scale4->id));
4406
4407         // Using scale 1 in a framework.
4408         $f1 = $lpg->create_framework([
4409             'scaleid' => $scale1->id,
4410             'scaleconfiguration' => json_encode([
4411                 ['scaleid' => $scale1->id],
4412                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4413             ])
4414         ]);
4415         $this->assertTrue(api::is_scale_used_anywhere($scale1->id));
4416         $this->assertFalse(api::is_scale_used_anywhere($scale2->id));
4417         $this->assertFalse(api::is_scale_used_anywhere($scale3->id));
4418         $this->assertFalse(api::is_scale_used_anywhere($scale4->id));
4419
4420         // Using scale 2 in a competency.
4421         $f2 = $lpg->create_framework();
4422         $c2 = $lpg->create_competency([
4423             'competencyframeworkid' => $f2->get('id'),
4424             'scaleid' => $scale2->id,
4425             'scaleconfiguration' => json_encode([
4426                 ['scaleid' => $scale2->id],
4427                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4428             ])
4429         ]);
4430
4431         $this->assertTrue(api::is_scale_used_anywhere($scale1->id));
4432         $this->assertTrue(api::is_scale_used_anywhere($scale2->id));
4433         $this->assertFalse(api::is_scale_used_anywhere($scale3->id));
4434         $this->assertFalse(api::is_scale_used_anywhere($scale4->id));
4435
4436         // Using scale 3 in a framework, and scale 4 in a competency of that framework.
4437         $f3 = $lpg->create_framework([
4438             'scaleid' => $scale3->id,
4439             'scaleconfiguration' => json_encode([
4440                 ['scaleid' => $scale3->id],
4441                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4442             ])
4443         ]);
4444         $c3 = $lpg->create_competency([
4445             'competencyframeworkid' => $f3->get('id'),
4446             'scaleid' => $scale4->id,
4447             'scaleconfiguration' => json_encode([
4448                 ['scaleid' => $scale4->id],
4449                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4450             ])
4451         ]);
4452
4453         $this->assertTrue(api::is_scale_used_anywhere($scale1->id));
4454         $this->assertTrue(api::is_scale_used_anywhere($scale2->id));
4455         $this->assertTrue(api::is_scale_used_anywhere($scale3->id));
4456         $this->assertTrue(api::is_scale_used_anywhere($scale4->id));
4457
4458         // Multiple occurrences of the same scale (3, and 4).
4459         $f4 = $lpg->create_framework([
4460             'scaleid' => $scale3->id,
4461             'scaleconfiguration' => json_encode([
4462                 ['scaleid' => $scale3->id],
4463                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4464             ])
4465         ]);
4466         $c4 = $lpg->create_competency([
4467             'competencyframeworkid' => $f3->get('id'),
4468             'scaleid' => $scale4->id,
4469             'scaleconfiguration' => json_encode([
4470                 ['scaleid' => $scale4->id],
4471                 ['id' => 1, 'scaledefault' => 1, 'proficient' => 1]
4472             ])
4473         ]);
4474         $this->assertTrue(api::is_scale_used_anywhere($scale1->id));
4475         $this->assertTrue(api::is_scale_used_anywhere($scale2->id));
4476         $this->assertTrue(api::is_scale_used_anywhere($scale3->id));
4477         $this->assertTrue(api::is_scale_used_anywhere($scale4->id));
4478     }
4479
4480     public function test_delete_evidence() {
4481         $this->resetAfterTest();
4482         $dg = $this->getDataGenerator();
4483         $ccg = $dg->get_plugin_generator('core_competency');
4484
4485         $u1 = $dg->create_user();
4486         $f1 = $ccg->create_framework();
4487         $comp1 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4488         $uc1 = $ccg->create_user_competency(['userid' => $u1->id, 'competencyid' => $comp1->get('id')]);
4489
4490         $ev1 = $ccg->create_evidence(['usercompetencyid' => $uc1->get('id')]);
4491         $ev2 = $ccg->create_evidence(['usercompetencyid' => $uc1->get('id')]);
4492
4493         $this->setAdminUser($u1);
4494
4495         $this->assertEquals(2, evidence::count_records());
4496         api::delete_evidence($ev1);
4497         $this->assertEquals(1, evidence::count_records());
4498         $this->assertFalse(evidence::record_exists($ev1->get('id')));
4499         $this->assertTrue(evidence::record_exists($ev2->get('id')));
4500     }
4501
4502     /**
4503      * @expectedException required_capability_exception
4504      */
4505     public function test_delete_evidence_without_permissions() {
4506         $this->resetAfterTest();
4507         $dg = $this->getDataGenerator();
4508         $ccg = $dg->get_plugin_generator('core_competency');
4509
4510         $u1 = $dg->create_user();
4511         $f1 = $ccg->create_framework();
4512         $comp1 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4513         $uc1 = $ccg->create_user_competency(['userid' => $u1->id, 'competencyid' => $comp1->get('id')]);
4514         $ev1 = $ccg->create_evidence(['usercompetencyid' => $uc1->get('id')]);
4515
4516         $this->setUser($u1);
4517
4518         api::delete_evidence($ev1);
4519     }
4520
4521     public function test_list_plans_to_review() {
4522         $dg = $this->getDataGenerator();
4523         $this->resetAfterTest();
4524         $ccg = $dg->get_plugin_generator('core_competency');
4525         $sysctx = context_system::instance();
4526         $this->setAdminUser();
4527
4528         $reviewer = $dg->create_user();
4529         $roleallow = $dg->create_role();
4530         $roleprohibit = $dg->create_role();
4531         assign_capability('moodle/competency:planreview', CAP_ALLOW, $roleallow, $sysctx->id);
4532         assign_capability('moodle/competency:planreview', CAP_PROHIBIT, $roleprohibit, $sysctx->id);
4533         role_assign($roleallow, $reviewer->id, $sysctx->id);
4534         accesslib_clear_all_caches_for_unit_testing();
4535
4536         $u1 = $dg->create_user();
4537         $u2 = $dg->create_user();
4538         $f1 = $ccg->create_framework();
4539         $comp1 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4540         $p1a = $ccg->create_plan(['userid' => $u1->id, 'status' => plan::STATUS_WAITING_FOR_REVIEW]);
4541         $p1b = $ccg->create_plan(['userid' => $u1->id, 'status' => plan::STATUS_IN_REVIEW, 'reviewerid' => $reviewer->id]);
4542         $p1c = $ccg->create_plan(['userid' => $u1->id, 'status' => plan::STATUS_DRAFT]);
4543         $p2a = $ccg->create_plan(['userid' => $u2->id, 'status' => plan::STATUS_WAITING_FOR_REVIEW]);
4544         $p2b = $ccg->create_plan(['userid' => $u2->id, 'status' => plan::STATUS_IN_REVIEW]);
4545         $p2c = $ccg->create_plan(['userid' => $u2->id, 'status' => plan::STATUS_ACTIVE]);
4546         $p2d = $ccg->create_plan(['userid' => $u2->id, 'status' => plan::STATUS_ACTIVE]);
4547         api::complete_plan($p2d);
4548
4549         // The reviewer can review all plans waiting for review, or in review where they are the reviewer.
4550         $this->setUser($reviewer);
4551         $result = api::list_plans_to_review();
4552         $this->assertEquals(3, $result['count']);
4553         $this->assertEquals($p1a->get('id'), $result['plans'][0]->plan->get('id'));
4554         $this->assertEquals($p1b->get('id'), $result['plans'][1]->plan->get('id'));
4555         $this->assertEquals($p2a->get('id'), $result['plans'][2]->plan->get('id'));
4556
4557         // The reviewer cannot view the plans when they do not have the permission in the user's context.
4558         role_assign($roleprohibit, $reviewer->id, context_user::instance($u2->id)->id);
4559         accesslib_clear_all_caches_for_unit_testing();
4560         $result = api::list_plans_to_review();
4561         $this->assertEquals(2, $result['count']);
4562         $this->assertEquals($p1a->get('id'), $result['plans'][0]->plan->get('id'));
4563         $this->assertEquals($p1b->get('id'), $result['plans'][1]->plan->get('id'));
4564     }
4565
4566     public function test_list_user_competencies_to_review() {
4567         global $CFG;
4568         require_once($CFG->dirroot . '/user/lib.php');
4569
4570         $dg = $this->getDataGenerator();
4571         $this->resetAfterTest();
4572         $ccg = $dg->get_plugin_generator('core_competency');
4573         $sysctx = context_system::instance();
4574         $this->setAdminUser();
4575
4576         $reviewer = $dg->create_user();
4577         $roleallow = $dg->create_role();
4578         $roleprohibit = $dg->create_role();
4579         assign_capability('moodle/competency:usercompetencyreview', CAP_ALLOW, $roleallow, $sysctx->id);
4580         assign_capability('moodle/competency:usercompetencyreview', CAP_PROHIBIT, $roleprohibit, $sysctx->id);
4581         role_assign($roleallow, $reviewer->id, $sysctx->id);
4582         accesslib_clear_all_caches_for_unit_testing();
4583
4584         $u1 = $dg->create_user();
4585         $u2 = $dg->create_user();
4586         $u3 = $dg->create_user();
4587         $f1 = $ccg->create_framework();
4588         $c1 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4589         $c2 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4590         $c3 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4591         $c4 = $ccg->create_competency(['competencyframeworkid' => $f1->get('id')]);
4592         $uc1a = $ccg->create_user_competency(['userid' => $u1->id, 'competencyid' => $c1->get('id'),
4593             'status' => user_competency::STATUS_IDLE]);
4594         $uc1b = $ccg->create_user_competency(['userid' => $u1->id, 'competencyid' => $c2->get('id'),
4595             'status' => user_competency::STATUS_WAITING_FOR_REVIEW]);
4596         $uc1c = $ccg->create_user_competency(['userid' => $u1->id, 'competencyid' => $c3->get('id'),
4597             'status' => user_competency::STATUS_IN_REVIEW, 'reviewerid' => $reviewer->id]);
4598         $uc2a = $ccg->create_user_competency(['userid' => $u2->id, 'competencyid' => $c1->get('id'),
4599             'status' => user_competency::STATUS_WAITING_FOR_REVIEW]);
4600         $uc2b = $ccg->create_user_competency(['userid' => $u2->id, 'competencyid' => $c2->get('id'),
4601             'status' => user_competency::STATUS_IDLE]);
4602         $uc2c = $ccg->create_user_competency(['userid' => $u2->id, 'competencyid' => $c3->get('id'),
4603             'status' => user_competency::STATUS_IN_REVIEW]);
4604         $uc3a = $ccg->create_user_competency(['userid' => $u3->id, 'competencyid' => $c4->get('id'),
4605             'status' => user_competency::STATUS_WAITING_FOR_REVIEW]);
4606
4607         // The reviewer can review all plans waiting for review, or in review where they are the reviewer.
4608         $this->setUser($reviewer);
4609         $result = api::list_user_competencies_to_review();
4610         $this->assertEquals(4, $result['count']);
4611         $this->assertEquals($uc2a->get('id'), $result['competencies'][0]->usercompetency->get('id'));
4612         $this->assertEquals($uc1b->get('id'), $result['competencies'][1]->usercompetency->get('id'));
4613         $this->assertEquals($uc1c->get('id'), $result['competencies'][2]->usercompetency->get('id'));
4614         $this->assertEquals($uc3a->get('id'), $result['competencies'][3]->usercompetency->get('id'));
4615
4616         // Now, let's delete user 3.
4617         // It should not be listed on user competencies to review any more.
4618         user_delete_user($u3);
4619         $result = api::list_user_competencies_to_review();
4620         $this->assertEquals(3, $result['count']);
4621
4622         // The reviewer cannot view the plans when they do not have the permission in the user's context.
4623         role_assign($roleprohibit, $reviewer->id, context_user::instance($u2->id)->id);
4624         accesslib_clear_all_caches_for_unit_testing();
4625         $result = api::list_user_competencies_to_review();
4626         $this->assertEquals(2, $result['count']);
4627         $this->assertEquals($uc1b->get('id'), $result['competencies'][0]->usercompetency->get('id'));
4628         $this->assertEquals($uc1c->get('id'), $result['competencies'][1]->usercompetency->get('id'));
4629     }
4630 }