Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace core_competency;

/**

 * API tests.

 *

 * @package    core_competency

 * @copyright  2015 Frédéric Massart - FMCorz.net

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class api_test extends \advanced_testcase {

    public function test_get_framework_related_contexts() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $cat1 = $dg->create_category();

        $cat2 = $dg->create_category(array('parent' => $cat1->id));

        $cat3 = $dg->create_category(array('parent' => $cat2->id));

        $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.

        $cat1ctx = \context_coursecat::instance($cat1->id);

        $cat2ctx = \context_coursecat::instance($cat2->id);

        $cat3ctx = \context_coursecat::instance($cat3->id);

        $sysctx = \context_system::instance();

        $expected = array($cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'self'));

        $expected = array($cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx, $cat3ctx->id => $cat3ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children'));

        $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents'));

    }

    public function test_get_framework_related_contexts_with_capabilities() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $user = $dg->create_user();

        $cat1 = $dg->create_category();

        $cat2 = $dg->create_category(array('parent' => $cat1->id));

        $cat3 = $dg->create_category(array('parent' => $cat2->id));

        $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.

        $cat1ctx = \context_coursecat::instance($cat1->id);

        $cat2ctx = \context_coursecat::instance($cat2->id);

        $cat3ctx = \context_coursecat::instance($cat3->id);

        $sysctx = \context_system::instance();

        $roleallow = create_role('Allow', 'allow', 'Allow read');

        assign_capability('moodle/competency:competencyview', CAP_ALLOW, $roleallow, $sysctx->id);

        role_assign($roleallow, $user->id, $sysctx->id);

        $roleprevent = create_role('Prevent', 'prevent', 'Prevent read');

        assign_capability('moodle/competency:competencyview', CAP_PROHIBIT, $roleprevent, $sysctx->id);

        role_assign($roleprevent, $user->id, $cat2ctx->id);

        accesslib_clear_all_caches_for_unit_testing();

        $this->setUser($user);

        $this->assertFalse(has_capability('moodle/competency:competencyview', $cat2ctx));

        $requiredcap = array('moodle/competency:competencyview');

        $expected = array();

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'self', $requiredcap));

        $expected = array($cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children', $requiredcap));

        $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents', $requiredcap));

    }

    public function test_get_template_related_contexts() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $cat1 = $dg->create_category();

        $cat2 = $dg->create_category(array('parent' => $cat1->id));

        $cat3 = $dg->create_category(array('parent' => $cat2->id));

        $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.

        $cat1ctx = \context_coursecat::instance($cat1->id);

        $cat2ctx = \context_coursecat::instance($cat2->id);

        $cat3ctx = \context_coursecat::instance($cat3->id);

        $sysctx = \context_system::instance();

        $expected = array($cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'self'));

        $expected = array($cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx, $cat3ctx->id => $cat3ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children'));

        $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx, $cat2ctx->id => $cat2ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents'));

    }

    public function test_get_template_related_contexts_with_capabilities() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $user = $dg->create_user();

        $cat1 = $dg->create_category();

        $cat2 = $dg->create_category(array('parent' => $cat1->id));

        $cat3 = $dg->create_category(array('parent' => $cat2->id));

        $c1 = $dg->create_course(array('category' => $cat2->id));   // This context should not be returned.

        $cat1ctx = \context_coursecat::instance($cat1->id);

        $cat2ctx = \context_coursecat::instance($cat2->id);

        $cat3ctx = \context_coursecat::instance($cat3->id);

        $sysctx = \context_system::instance();

        $roleallow = create_role('Allow', 'allow', 'Allow read');

        assign_capability('moodle/competency:templateview', CAP_ALLOW, $roleallow, $sysctx->id);

        role_assign($roleallow, $user->id, $sysctx->id);

        $roleprevent = create_role('Prevent', 'prevent', 'Prevent read');

        assign_capability('moodle/competency:templateview', CAP_PROHIBIT, $roleprevent, $sysctx->id);

        role_assign($roleprevent, $user->id, $cat2ctx->id);

        accesslib_clear_all_caches_for_unit_testing();

        $this->setUser($user);

        $this->assertFalse(has_capability('moodle/competency:templateview', $cat2ctx));

        $requiredcap = array('moodle/competency:templateview');

        $expected = array();

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'self', $requiredcap));

        $expected = array($cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat1ctx, 'children', $requiredcap));

        $expected = array($sysctx->id => $sysctx, $cat1ctx->id => $cat1ctx);

        $this->assertEquals($expected, api::get_related_contexts($cat2ctx, 'parents', $requiredcap));

    }

    /**

     * Test updating a template.

     */

    public function test_update_template() {

        $cat = $this->getDataGenerator()->create_category();

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $syscontext = \context_system::instance();

        $template = api::create_template((object) array('shortname' => 'testing', 'contextid' => $syscontext->id));

        $this->assertEquals('testing', $template->get('shortname'));

        $this->assertEquals($syscontext->id, $template->get('contextid'));

        // Simple update.

        api::update_template((object) array('id' => $template->get('id'), 'shortname' => 'success'));

        $template = api::read_template($template->get('id'));

        $this->assertEquals('success', $template->get('shortname'));

        // Trying to change the context.

        $this->expectException(\coding_exception::class);

        api::update_template((object) ['id' => $template->get('id'), 'contextid' => \context_coursecat::instance($cat->id)->id]);

    }

    /**

     * Test listing framework with order param.

     */

    public function test_list_frameworks() {

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        // Create a list of frameworks.

        $framework1 = $lpg->create_framework(array(

            'shortname' => 'shortname_alpha',

            'idnumber' => 'idnumber_cinnamon',

            'description' => 'description',

            'descriptionformat' => FORMAT_HTML,

            'visible' => true,

            'contextid' => \context_system::instance()->id

        ));

        $framework2 = $lpg->create_framework(array(

            'shortname' => 'shortname_beetroot',

            'idnumber' => 'idnumber_apple',

            'description' => 'description',

            'descriptionformat' => FORMAT_HTML,

            'visible' => true,

            'contextid' => \context_system::instance()->id

        ));

        $framework3 = $lpg->create_framework(array(

            'shortname' => 'shortname_crisps',

            'idnumber' => 'idnumber_beer',

            'description' => 'description',

            'descriptionformat' => FORMAT_HTML,

            'visible' => false,

            'contextid' => \context_system::instance()->id

        ));

        // Get frameworks list order by shortname desc.

        $result = api::list_frameworks('shortname', 'DESC', null, 3, \context_system::instance());

        $f = (object) array_shift($result);

        $this->assertEquals($framework3->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework2->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework1->get('id'), $f->get('id'));

        // Get frameworks list order by idnumber asc.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance());

        $f = (object) array_shift($result);

        $this->assertEquals($framework2->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework3->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework1->get('id'), $f->get('id'));

        // Repeat excluding the non-visible ones.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance(), 'self', true);

        $this->assertCount(2, $result);

        $f = (object) array_shift($result);

        $this->assertEquals($framework2->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework1->get('id'), $f->get('id'));

        // Search by query string, trying match on shortname.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance(), 'self', false, 'crisp');

        $this->assertCount(1, $result);

        $f = (object) array_shift($result);

        $this->assertEquals($framework3->get('id'), $f->get('id'));

        // Search by query string, trying match on shortname, but hidden.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance(), 'self', true, 'crisp');

        $this->assertCount(0, $result);

        // Search by query string, trying match on ID number.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance(), 'self', false, 'apple');

        $this->assertCount(1, $result);

        $f = (object) array_shift($result);

        $this->assertEquals($framework2->get('id'), $f->get('id'));

        // Search by query string, trying match on both.

        $result = api::list_frameworks('idnumber', 'ASC', null, 3, \context_system::instance(), 'self', false, 'bee');

        $this->assertCount(2, $result);

        $f = (object) array_shift($result);

        $this->assertEquals($framework2->get('id'), $f->get('id'));

        $f = (object) array_shift($result);

        $this->assertEquals($framework3->get('id'), $f->get('id'));

    }

    /**

     * Test duplicate a framework.

     */

    public function test_duplicate_framework() {

        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $syscontext = \context_system::instance();

        $params = array(

                'shortname' => 'shortname_a',

                'idnumber' => 'idnumber_c',

                'description' => 'description',

                'descriptionformat' => FORMAT_HTML,

                'visible' => true,

                'contextid' => $syscontext->id

        );

        $framework = $lpg->create_framework($params);

        $competency1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $competency2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $competency3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $competency4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $competency41 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id'),

                                                        'parentid' => $competency4->get('id'))

                                                    );

        $competency42 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id'),

                                                        'parentid' => $competency4->get('id'))

                                                    );

        $competencyidnumbers = array($competency1->get('idnumber'),

                                        $competency2->get('idnumber'),

                                        $competency3->get('idnumber'),

                                        $competency4->get('idnumber'),

                                        $competency41->get('idnumber'),

                                        $competency42->get('idnumber')

                                    );

        $config = json_encode(array(

            'base' => array('points' => 4),

            'competencies' => array(

                array('id' => $competency41->get('id'), 'points' => 3, 'required' => 0),

                array('id' => $competency42->get('id'), 'points' => 2, 'required' => 1),

            )

        ));

        $competency4->set('ruletype', 'core_competency\competency_rule_points');

        $competency4->set('ruleoutcome', \core_competency\competency::OUTCOME_EVIDENCE);

        $competency4->set('ruleconfig', $config);

        $competency4->update();

        api::add_related_competency($competency1->get('id'), $competency2->get('id'));

        api::add_related_competency($competency3->get('id'), $competency4->get('id'));

        $frameworkduplicated1 = api::duplicate_framework($framework->get('id'));

        $frameworkduplicated2 = api::duplicate_framework($framework->get('id'));

        $this->assertEquals($framework->get('idnumber').'_1', $frameworkduplicated1->get('idnumber'));

        $this->assertEquals($framework->get('idnumber').'_2', $frameworkduplicated2->get('idnumber'));

        $competenciesfr1 = api::list_competencies(array('competencyframeworkid' => $frameworkduplicated1->get('id')));

        $competenciesfr2 = api::list_competencies(array('competencyframeworkid' => $frameworkduplicated2->get('id')));

        $competencyidsfr1 = array();

        $competencyidsfr2 = array();

        foreach ($competenciesfr1 as $cmp) {

            $competencyidsfr1[] = $cmp->get('idnumber');

        }

        foreach ($competenciesfr2 as $cmp) {

            $competencyidsfr2[] = $cmp->get('idnumber');

        }

        $this->assertEmpty(array_diff($competencyidsfr1, $competencyidnumbers));

        $this->assertEmpty(array_diff($competencyidsfr2, $competencyidnumbers));

        $this->assertCount(6, $competenciesfr1);

        $this->assertCount(6, $competenciesfr2);

        // Test the related competencies.

        reset($competenciesfr1);

        $compduplicated1 = current($competenciesfr1);

        $relatedcompetencies = $compduplicated1->get_related_competencies();

        $comprelated = current($relatedcompetencies);

        $this->assertEquals($comprelated->get('idnumber'), $competency2->get('idnumber'));

        // Check if config rule have been ported correctly.

        $competency4duplicated = competency::get_record(array(

                                                            'idnumber' => $competency4->get('idnumber'),

                                                            'competencyframeworkid' => $frameworkduplicated2->get('id')

                                                        ));

        $configduplicated = json_decode($competency4duplicated->get('ruleconfig'), true);

        $configorigin = json_decode($config, true);

        // Check that the 2 config have the same base.

        $this->assertEquals($configorigin['base'], $configduplicated['base']);

        $this->assertEquals(count($configorigin['competencies']), count($configduplicated['competencies']));

        $competencyidsrules = array();

        foreach ($configduplicated['competencies'] as $key => $value) {

            // Check that the only difference between the 2 config is id competency.

            $this->assertEquals(1, count(array_diff($value, $configorigin['competencies'][$key])));

            $competencyidsrules[] = $value['id'];

        }

        $this->assertTrue($competency4duplicated->is_parent_of($competencyidsrules));

        // Test duplicate an empty framework.

        $emptyfrm = $lpg->create_framework();

        $emptyfrmduplicated = api::duplicate_framework($emptyfrm->get('id'));

        $this->assertEquals($emptyfrm->get('idnumber').'_1', $emptyfrmduplicated->get('idnumber'));

        $nbcomp = api::count_competencies(array('competencyframeworkid' => $emptyfrmduplicated->get('id')));

        $this->assertEquals(0, $nbcomp);

    }

    /**

     * Test update plan.

     */

    public function test_update_plan() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $usermanageowndraft = $dg->create_user();

        $usermanageown = $dg->create_user();

        $usermanagedraft = $dg->create_user();

        $usermanage = $dg->create_user();

        $syscontext = \context_system::instance();

        // Creating specific roles.

        $manageowndraftrole = $dg->create_role(array(

            'name' => 'User manage own draft',

            'shortname' => 'manage-own-draft'

        ));

        $manageownrole = $dg->create_role(array(

            'name' => 'User manage own',

            'shortname' => 'manage-own'

        ));

        $managedraftrole = $dg->create_role(array(

            'name' => 'User manage draft',

            'shortname' => 'manage-draft'

        ));

        $managerole = $dg->create_role(array(

            'name' => 'User manage',

            'shortname' => 'manage'

        ));

        assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $manageowndraftrole, $syscontext->id);

        assign_capability('moodle/competency:planviewowndraft', CAP_ALLOW, $manageowndraftrole, $syscontext->id);

        assign_capability('moodle/competency:planmanageown', CAP_ALLOW, $manageownrole, $syscontext->id);

        assign_capability('moodle/competency:planviewown', CAP_ALLOW, $manageownrole, $syscontext->id);

        assign_capability('moodle/competency:planmanagedraft', CAP_ALLOW, $managedraftrole, $syscontext->id);

        assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $managedraftrole, $syscontext->id);

        assign_capability('moodle/competency:planmanage', CAP_ALLOW, $managerole, $syscontext->id);

        assign_capability('moodle/competency:planview', CAP_ALLOW, $managerole, $syscontext->id);

        $dg->role_assign($manageowndraftrole, $usermanageowndraft->id, $syscontext->id);

        $dg->role_assign($manageownrole, $usermanageown->id, $syscontext->id);

        $dg->role_assign($managedraftrole, $usermanagedraft->id, $syscontext->id);

        $dg->role_assign($managerole, $usermanage->id, $syscontext->id);

        // Create first learning plan with user create draft.

        $this->setUser($usermanageowndraft);

        $plan = array (

            'name' => 'plan own draft',

            'description' => 'plan own draft',

            'userid' => $usermanageowndraft->id

        );

        $plan = api::create_plan((object)$plan);

        $record = $plan->to_record();

        $record->name = 'plan own draft modified';

        // Check if user create draft can edit the plan name.

        $plan = api::update_plan($record);

        $this->assertInstanceOf('\core_competency\plan', $plan);

        // The status cannot be changed in this method.

        $record->status = \core_competency\plan::STATUS_ACTIVE;

        try {

            $plan = api::update_plan($record);

            $this->fail('Updating the status is not allowed.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/To change the status of a plan use the appropriate methods./',

                $e->getMessage());

        }

        // Test when user with manage own plan capability try to edit other user plan.

        $record->status = \core_competency\plan::STATUS_DRAFT;

        $record->name = 'plan create draft modified 2';

        $this->setUser($usermanageown);

        try {

            $plan = api::update_plan($record);

            $this->fail('User with manage own plan capability can only edit his own plan.');

        } catch (\required_capability_exception $e) {

            $this->assertTrue(true);

        }

        // User with manage plan capability cannot edit the other user plans with status draft.

        $this->setUser($usermanage);

        $record->name = 'plan create draft modified 3';

        try {

            $plan = api::update_plan($record);

            $this->fail('User with manage plan capability cannot edit the other user plans with status draft');

        } catch (\required_capability_exception $e) {

            $this->assertTrue(true);

        }

        // User with manage draft capability can edit other user's learning plan if the status is draft.

        $this->setUser($usermanagedraft);

        $record->status = \core_competency\plan::STATUS_DRAFT;

        $record->name = 'plan manage draft modified 3';

        $plan = api::update_plan($record);

        $this->assertInstanceOf('\core_competency\plan', $plan);

        // User with manage  plan capability can create/edit learning plan if status is active/complete.

        $this->setUser($usermanage);

        $plan = array (

            'name' => 'plan create',

            'description' => 'plan create',

            'userid' => $usermanage->id,

            'status' => \core_competency\plan::STATUS_ACTIVE

        );

        $plan = api::create_plan((object)$plan);

        // Silently transition to complete status to avoid errors about transitioning to complete.

        $plan->set('status', \core_competency\plan::STATUS_COMPLETE);

        $plan->update();

        $record = $plan->to_record();

        $record->name = 'plan create own modified';

        try {

            api::update_plan($record);

            $this->fail('Completed plan can not be edited');

        } catch (\coding_exception $e) {

            $this->assertTrue(true);

        }

    }

    public function test_create_plan_from_template() {

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $u1 = $this->getDataGenerator()->create_user();

        $tpl = $this->getDataGenerator()->get_plugin_generator('core_competency')->create_template();

        // Creating a new plan.

        $plan = api::create_plan_from_template($tpl, $u1->id);

        $record = $plan->to_record();

        $this->assertInstanceOf('\core_competency\plan', $plan);

        $this->assertTrue(\core_competency\plan::record_exists($plan->get('id')));

        $this->assertEquals($tpl->get('id'), $plan->get('templateid'));

        $this->assertEquals($u1->id, $plan->get('userid'));

        $this->assertTrue($plan->is_based_on_template());

        // Creating a plan that already exists.

        $plan = api::create_plan_from_template($tpl, $u1->id);

        $this->assertFalse($plan);

        // Check that api::create_plan cannot be used.

        unset($record->id);

        $this->expectException(\coding_exception::class);

        $plan = api::create_plan($record);

    }

    public function test_update_plan_based_on_template() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $lpg = $dg->get_plugin_generator('core_competency');

        $u1 = $dg->create_user();

        $u2 = $dg->create_user();

        $this->setAdminUser();

        $tpl1 = $lpg->create_template();

        $tpl2 = $lpg->create_template();

        $up1 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id')));

        $up2 = $lpg->create_plan(array('userid' => $u2->id, 'templateid' => null));

        try {

            // Trying to remove the template dependency.

            $record = $up1->to_record();

            $record->templateid = null;

            api::update_plan($record);

            $this->fail('A plan cannot be unlinked using api::update_plan()');

        } catch (\coding_exception $e) {

            // All good.

        }

        try {

            // Trying to switch to another template.

            $record = $up1->to_record();

            $record->templateid = $tpl2->get('id');

            api::update_plan($record);

            $this->fail('A plan cannot be moved to another template.');

        } catch (\coding_exception $e) {

            // All good.

        }

        try {

            // Trying to switch to using a template.

            $record = $up2->to_record();

            $record->templateid = $tpl1->get('id');

            api::update_plan($record);

            $this->fail('A plan cannot be update to use a template.');

        } catch (\coding_exception $e) {

            // All good.

        }

    }

    public function test_unlink_plan_from_template() {

        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();

        $lpg = $dg->get_plugin_generator('core_competency');

        $u1 = $dg->create_user();

        $u2 = $dg->create_user();

        $this->setAdminUser();

        $f1 = $lpg->create_framework();

        $f2 = $lpg->create_framework();

        $c1a = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));

        $c2a = $lpg->create_competency(array('competencyframeworkid' => $f2->get('id')));

        $c1b = $lpg->create_competency(array('competencyframeworkid' => $f1->get('id')));

        $tpl1 = $lpg->create_template();

        $tpl2 = $lpg->create_template();

        $tplc1a = $lpg->create_template_competency(array('templateid' => $tpl1->get('id'), 'competencyid' => $c1a->get('id'),

            'sortorder' => 9));

        $tplc1b = $lpg->create_template_competency(array('templateid' => $tpl1->get('id'), 'competencyid' => $c1b->get('id'),

            'sortorder' => 8));

        $tplc2a = $lpg->create_template_competency(array('templateid' => $tpl2->get('id'), 'competencyid' => $c2a->get('id')));

        $plan1 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id'), 'status' => plan::STATUS_ACTIVE));

        $plan2 = $lpg->create_plan(array('userid' => $u2->id, 'templateid' => $tpl2->get('id')));

        $plan3 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get('id'), 'status' => plan::STATUS_COMPLETE));

        // Check that we have what we expect at this stage.

        $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get('id'))));

        $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get('id'))));

        $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan1->get('id'))));

        $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get('id'))));

        $this->assertTrue($plan1->is_based_on_template());

        $this->assertTrue($plan2->is_based_on_template());

        // Let's do this!

        $tpl1comps = \core_competency\template_competency::list_competencies($tpl1->get('id'), true);

        $tpl2comps = \core_competency\template_competency::list_competencies($tpl2->get('id'), true);

        api::unlink_plan_from_template($plan1);

        $plan1->read();

        $plan2->read();

        $this->assertCount(2, $tpl1comps);

        $this->assertCount(1, $tpl2comps);

        $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get('id'))));

        $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get('id'))));

        $this->assertEquals(2, \core_competency\plan_competency::count_records(array('planid' => $plan1->get('id'))));

        $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get('id'))));

        $this->assertFalse($plan1->is_based_on_template());

        $this->assertEquals($tpl1->get('id'), $plan1->get('origtemplateid'));

        $this->assertTrue($plan2->is_based_on_template());

        $this->assertEquals(null, $plan2->get('origtemplateid'));

        // Check we can unlink draft plan.

        try {

            api::unlink_plan_from_template($plan2);

        } catch (\coding_exception $e) {

            $this->fail('Fail to unlink draft plan.');

        }

        // Check we can not unlink completed plan.

        try {

            api::unlink_plan_from_template($plan3);

            $this->fail('We can not unlink completed plan.');

        } catch (\coding_exception $e) {

            // All good.

        }

        // Even the order remains.

        $plan1comps = \core_competency\plan_competency::list_competencies($plan1->get('id'));

        $before = reset($tpl1comps);

        $after = reset($plan1comps);

        $this->assertEquals($before->get('id'), $after->get('id'));

        $this->assertEquals($before->get('sortorder'), $after->get('sortorder'));

        $before = next($tpl1comps);

        $after = next($plan1comps);

        $this->assertEquals($before->get('id'), $after->get('id'));

        $this->assertEquals($before->get('sortorder'), $after->get('sortorder'));

    }

    public function test_update_template_updates_plans() {

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $dg = $this->getDataGenerator();

        $u1 = $dg->create_user();

        $u2 = $dg->create_user();

        $lpg = $dg->get_plugin_generator('core_competency');

        $tpl1 = $lpg->create_template();

        $tpl2 = $lpg->create_template();

        // Create plans with data not matching templates.

        $time = time();

        $plan1 = $lpg->create_plan(array('templateid' => $tpl1->get('id'), 'userid' => $u1->id,

            'name' => 'Not good name', 'duedate' => $time + 3600, 'description' => 'Ahah', 'descriptionformat' => FORMAT_MARKDOWN));

        $plan2 = $lpg->create_plan(array('templateid' => $tpl1->get('id'), 'userid' => $u2->id,

            'name' => 'Not right name', 'duedate' => $time + 3601, 'description' => 'Ahah', 'descriptionformat' => FORMAT_PLAIN));

        $plan3 = $lpg->create_plan(array('templateid' => $tpl2->get('id'), 'userid' => $u1->id,

            'name' => 'Not sweet name', 'duedate' => $time + 3602, 'description' => 'Ahah', 'descriptionformat' => FORMAT_PLAIN));

        // Prepare our expectations.

        $plan1->read();

        $plan2->read();

        $plan3->read();

        $this->assertEquals($tpl1->get('id'), $plan1->get('templateid'));

        $this->assertEquals($tpl1->get('id'), $plan2->get('templateid'));

        $this->assertEquals($tpl2->get('id'), $plan3->get('templateid'));

        $this->assertNotEquals($tpl1->get('shortname'), $plan1->get('name'));

        $this->assertNotEquals($tpl1->get('shortname'), $plan2->get('name'));

        $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));

        $this->assertNotEquals($tpl1->get('description'), $plan1->get('description'));

        $this->assertNotEquals($tpl1->get('description'), $plan2->get('description'));

        $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));

        $this->assertNotEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));

        $this->assertNotEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));

        $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));

        $this->assertNotEquals($tpl1->get('duedate'), $plan1->get('duedate'));

        $this->assertNotEquals($tpl1->get('duedate'), $plan2->get('duedate'));

        $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));

        // Update the template without changing critical fields does not update the plans.

        $data = $tpl1->to_record();

        $data->visible = 0;

        api::update_template($data);

        $this->assertNotEquals($tpl1->get('shortname'), $plan1->get('name'));

        $this->assertNotEquals($tpl1->get('shortname'), $plan2->get('name'));

        $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));

        $this->assertNotEquals($tpl1->get('description'), $plan1->get('description'));

        $this->assertNotEquals($tpl1->get('description'), $plan2->get('description'));

        $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));

        $this->assertNotEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));

        $this->assertNotEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));

        $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));

        $this->assertNotEquals($tpl1->get('duedate'), $plan1->get('duedate'));

        $this->assertNotEquals($tpl1->get('duedate'), $plan2->get('duedate'));

        $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));

        // Now really update the template.

        $data = $tpl1->to_record();

        $data->shortname = 'Awesome!';

        $data->description = 'This is too awesome!';

        $data->descriptionformat = FORMAT_HTML;

        $data->duedate = $time + 200;

        api::update_template($data);

        $tpl1->read();

        // Now confirm that the right plans were updated.

        $plan1->read();

        $plan2->read();

        $plan3->read();

        $this->assertEquals($tpl1->get('id'), $plan1->get('templateid'));

        $this->assertEquals($tpl1->get('id'), $plan2->get('templateid'));

        $this->assertEquals($tpl2->get('id'), $plan3->get('templateid'));

        $this->assertEquals($tpl1->get('shortname'), $plan1->get('name'));

        $this->assertEquals($tpl1->get('shortname'), $plan2->get('name'));

        $this->assertNotEquals($tpl2->get('shortname'), $plan3->get('name'));

        $this->assertEquals($tpl1->get('description'), $plan1->get('description'));

        $this->assertEquals($tpl1->get('description'), $plan2->get('description'));

        $this->assertNotEquals($tpl2->get('description'), $plan3->get('description'));

        $this->assertEquals($tpl1->get('descriptionformat'), $plan1->get('descriptionformat'));

        $this->assertEquals($tpl1->get('descriptionformat'), $plan2->get('descriptionformat'));

        $this->assertNotEquals($tpl2->get('descriptionformat'), $plan3->get('descriptionformat'));

        $this->assertEquals($tpl1->get('duedate'), $plan1->get('duedate'));

        $this->assertEquals($tpl1->get('duedate'), $plan2->get('duedate'));

        $this->assertNotEquals($tpl2->get('duedate'), $plan3->get('duedate'));

    }

    /**

     * Test that the method to complete a plan.

     */

    public function test_complete_plan() {

        global $DB;

        $this->resetAfterTest(true);

        $this->setAdminUser();

        $dg = $this->getDataGenerator();

        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $user = $dg->create_user();

        // Create a framework and assign competencies.

        $framework = $lpg->create_framework();

        $c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        $c4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get('id')));

        // Create two plans and assign competencies.

        $plan = $lpg->create_plan(array('userid' => $user->id));

        $otherplan = $lpg->create_plan(array('userid' => $user->id));

        $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c1->get('id')));

        $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c2->get('id')));

        $lpg->create_plan_competency(array('planid' => $plan->get('id'), 'competencyid' => $c3->get('id')));

        $lpg->create_plan_competency(array('planid' => $otherplan->get('id'), 'competencyid' => $c1->get('id')));

        $uclist = array(

            $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get('id'),

                'proficiency' => true, 'grade' => 1 )),

            $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c2->get('id'),

                'proficiency' => false, 'grade' => 2 ))

        );

        $this->assertEquals(2, \core_competency\user_competency::count_records());

        $this->assertEquals(0, \core_competency\user_competency_plan::count_records());

        // Change status of the plan to complete.

        api::complete_plan($plan);

        // Check that user competencies are now in user_competency_plan objects and still in user_competency.

        $this->assertEquals(2, \core_competency\user_competency::count_records());

        $this->assertEquals(3, \core_competency\user_competency_plan::count_records());

        $usercompetenciesplan = \core_competency\user_competency_plan::get_records();

        $this->assertEquals($uclist[0]->get('userid'), $usercompetenciesplan[0]->get('userid'));

        $this->assertEquals($uclist[0]->get('competencyid'), $usercompetenciesplan[0]->get('competencyid'));

        $this->assertEquals($uclist[0]->get('proficiency'), (bool) $usercompetenciesplan[0]->get('proficiency'));

        $this->assertEquals($uclist[0]->get('grade'), $usercompetenciesplan[0]->get('grade'));

        $this->assertEquals($plan->get('id'), $usercompetenciesplan[0]->get('planid'));

        $this->assertEquals($uclist[1]->get('userid'), $usercompetenciesplan[1]->get('userid'));

        $this->assertEquals($uclist[1]->get('competencyid'), $usercompetenciesplan[1]->get('competencyid'));

        $this->assertEquals($uclist[1]->get('proficiency'), (bool) $usercompetenciesplan[1]->get('proficiency'));

        $this->assertEquals($uclist[1]->get('grade'), $usercompetenciesplan[1]->get('grade'));

        $this->assertEquals($plan->get('id'), $usercompetenciesplan[1]->get('planid'));

        $this->assertEquals($user->id, $usercompetenciesplan[2]->get('userid'));

        $this->assertEquals($c3->get('id'), $usercompetenciesplan[2]->get('competencyid'));

        $this->assertNull($usercompetenciesplan[2]->get('proficiency'));

        $this->assertNull($usercompetenciesplan[2]->get('grade'));

        $this->assertEquals($plan->get('id'), $usercompetenciesplan[2]->get('planid'));

        // Check we can not add competency to completed plan.

        try {

            api::add_competency_to_plan($plan->get('id'), $c4->get('id'));

            $this->fail('We can not add competency to completed plan.');

        } catch (\coding_exception $e) {

            // All good.

        }

        // Check we can not remove competency to completed plan.

        try {

            api::remove_competency_from_plan($plan->get('id'), $c3->get('id'));

            $this->fail('We can not remove competency to completed plan.');

        } catch (\coding_exception $e) {

            // All good.

        }

        // Completing a plan that is completed throws an exception.

        $this->expectException(\coding_exception::class);

        api::complete_plan($plan);

    }

    /**

     * Set-up the workflow data (review, active, ...).

     *

     * @return array

     */

    protected function setup_workflow_data() {

        $this->resetAfterTest();

        $dg = $this->getDataGenerator();

        $user = $dg->create_user();

        $reviewer = $dg->create_user();

        $otheruser = $dg->create_user();

        $syscontext = \context_system::instance();

        $userrole = $dg->create_role();

        $reviewerrole = $dg->create_role();

        $otheruserrole = $dg->create_role();

        assign_capability('moodle/competency:planmanageowndraft', CAP_ALLOW, $userrole, $syscontext->id);

        assign_capability('moodle/competency:planmanage', CAP_ALLOW, $reviewerrole, $syscontext->id);

        assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $reviewerrole, $syscontext->id);

        $dg->role_assign($userrole, $user->id, $syscontext->id);

        $dg->role_assign($reviewerrole, $reviewer->id, $syscontext->id);

        accesslib_clear_all_caches_for_unit_testing();

        $lpg = $dg->get_plugin_generator('core_competency');

        $tpl = $lpg->create_template();

        $plan = $lpg->create_plan(array('userid' => $user->id));

        $tplplan = $lpg->create_plan(array('userid' => $user->id, 'templateid' => $tpl->get('id')));

        return array(

            'dg' => $dg,

            'lpg' => $lpg,

            'user' => $user,

            'reviewer' => $reviewer,

            'otheruser' => $otheruser,

            'plan' => $plan,

            'tplplan' => $tplplan,

        );

    }

    /**

     * Testing requesting the review of a plan.

     */

    public function test_plan_request_review() {

        $data = $this->setup_workflow_data();

        $dg = $data['dg'];

        $lpg = $data['lpg'];

        $user = $data['user'];

        $reviewer = $data['reviewer'];

        $otheruser = $data['otheruser'];

        $plan = $data['plan'];

        $tplplan = $data['tplplan'];

        $this->assertEquals(plan::STATUS_DRAFT, $plan->get('status'));

        $this->assertEquals(plan::STATUS_DRAFT, $tplplan->get('status'));

        // Foreign user cannot do anything.

        $this->setUser($otheruser);

        try {

            api::plan_request_review($plan);

            $this->fail('The user can not read the plan.');

        } catch (\required_capability_exception $e) {

            $this->assertEquals('nopermissions', $e->errorcode);

        }

        // Can not change a plan based on a template.

        $this->setUser($user);

        try {

            api::plan_request_review($tplplan);

            $this->fail('The plan is based on a template.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/Template plans cannot be reviewed./', $e->getMessage());

        }

        // Can not send for review when not draft.

        $this->setUser($user);

        $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);

        try {

            api::plan_request_review($plan);

            $this->fail('The plan cannot be sent for review at this stage.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/The plan cannot be sent for review at this stage./', $e->getMessage());

        }

        // Can not send for review when not draft.

        $this->setUser($user);

        $plan->set('status', plan::STATUS_ACTIVE);

        try {

            api::plan_request_review($plan);

            $this->fail('The plan cannot be sent for review at this stage.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/The plan cannot be sent for review at this stage./', $e->getMessage());

        }

        // Can not send for review when not draft.

        $this->setUser($user);

        $plan->set('status', plan::STATUS_IN_REVIEW);

        try {

            api::plan_request_review($plan);

            $this->fail('The plan cannot be sent for review at this stage.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/The plan cannot be sent for review at this stage./', $e->getMessage());

        }

        // Can not send for review when not draft.

        $this->setUser($user);

        $plan->set('status', plan::STATUS_COMPLETE);

        try {

            api::plan_request_review($plan);

            $this->fail('The plan cannot be sent for review at this stage.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/The plan cannot be sent for review at this stage./', $e->getMessage());

        }

        // Sending for review as a reviewer.

        $this->setUser($reviewer);

        $plan->set('status', plan::STATUS_DRAFT);

        try {

            api::plan_request_review($plan);

            $this->fail('The user can not request a review.');

        } catch (\required_capability_exception $e) {

            $this->assertEquals('nopermissions', $e->errorcode);

        }

        // Sending for review.

        $this->setUser($user);

        api::plan_request_review($plan);

        $plan->read();

        $this->assertEquals(plan::STATUS_WAITING_FOR_REVIEW, $plan->get('status'));

        // Sending for review by ID.

        $plan->set('status', plan::STATUS_DRAFT);

        $plan->update();

        api::plan_request_review($plan->get('id'));

        $plan->read();

        $this->assertEquals(plan::STATUS_WAITING_FOR_REVIEW, $plan->get('status'));

    }

    /**

     * Testing cancelling the review request.

     */

    public function test_plan_cancel_review_request() {

        $data = $this->setup_workflow_data();

        $dg = $data['dg'];

        $lpg = $data['lpg'];

        $user = $data['user'];

        $reviewer = $data['reviewer'];

        $otheruser = $data['otheruser'];

        $plan = $data['plan'];

        $tplplan = $data['tplplan'];

        // Set waiting for review.

        $tplplan->set('status', plan::STATUS_WAITING_FOR_REVIEW);

        $tplplan->update();

        $plan->set('status', plan::STATUS_WAITING_FOR_REVIEW);

        $plan->update();

        // Foreign user cannot do anything.

        $this->setUser($otheruser);

        try {

            api::plan_cancel_review_request($plan);

            $this->fail('The user can not read the plan.');

        } catch (\required_capability_exception $e) {

            $this->assertEquals('nopermissions', $e->errorcode);

        }

        // Can not change a plan based on a template.

        $this->setUser($user);

        try {

            api::plan_cancel_review_request($tplplan);

            $this->fail('The plan is based on a template.');

        } catch (\coding_exception $e) {

            $this->assertMatchesRegularExpression('/Template plans cannot be reviewed./', $e->getMessage());

        }

        // Can not cancel review request when not waiting for review.

        $this->setUser($user);

        $plan->set('status', plan::STATUS_DRAFT);

        try {

            api::plan_cancel_review_request($plan);

            $this->fail('The plan cannot be sent for review at this stage.');

        } catch (\coding_exception $e) {