<?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/>.

/**
 * Event tests.
 *
 * @package    core_competency
 * @copyright  2016 Serge Gauthier <serge.gauthier.2@umontreal.ca>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

defined('MOODLE_INTERNAL') || die();
global $CFG;
require_once($CFG->dirroot . '/comment/lib.php');

use core_competency\api;
use core_competency\url;

/**
 * Event tests.
 *
 * @package    core_competency
 * @copyright  2016 Serge Gauthier <serge.gauthier.2@umontreal.ca>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_competency_event_testcase extends advanced_testcase {

    /**
     * Test the competency framework created event.
     *
     */
    public function test_competency_framework_created() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        // Use DataGenerator to have a record framework with the right format.
        $record = $lpg->create_framework()->to_record();
        $record->id = 0;
        $record->shortname = "New shortname";
        $record->idnumber = "New idnumber";

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $framework = api::create_framework((object) $record);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_framework_created', $event);
        $this->assertEquals($framework->get_id(), $event->objectid);
        $this->assertEquals($framework->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency framework deleted event.
     *
     */
    public function test_competency_framework_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $framework = $lpg->create_framework();

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::delete_framework($framework->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_framework_deleted', $event);
        $this->assertEquals($framework->get_id(), $event->objectid);
        $this->assertEquals($framework->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency framework updated event.
     *
     */
    public function test_competency_framework_updated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $framework = $lpg->create_framework();

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $framework->set_shortname('Shortname modified');
        api::update_framework($framework->to_record());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_framework_updated', $event);
        $this->assertEquals($framework->get_id(), $event->objectid);
        $this->assertEquals($framework->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency framework viewed event.
     *
     */
    public function test_competency_framework_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $framework = $lpg->create_framework();

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::competency_framework_viewed($framework);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_framework_viewed', $event);
        $this->assertEquals($framework->get_id(), $event->objectid);
        $this->assertEquals($framework->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency viewed event.
     *
     */
    public function test_competency_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $framework = $lpg->create_framework();
        $competency = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::competency_viewed($competency);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_viewed', $event);
        $this->assertEquals($competency->get_id(), $event->objectid);
        $this->assertEquals($competency->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the template viewed event.
     *
     */
    public function test_template_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $template = $lpg->create_template();
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::template_viewed($template);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_template_viewed', $event);
        $this->assertEquals($template->get_id(), $event->objectid);
        $this->assertEquals($template->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the template created event.
     *
     */
    public function test_template_created() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        // Use DataGenerator to have a template record with the right format.
        $record = $lpg->create_template()->to_record();
        $record->id = 0;
        $record->shortname = "New shortname";

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $template = api::create_template((object) $record);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        $this->assertInstanceOf('\core\event\competency_template_created', $event);
        $this->assertEquals($template->get_id(), $event->objectid);
        $this->assertEquals($template->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the template deleted event.
     *
     */
    public function test_template_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $template = $lpg->create_template();

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::delete_template($template->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_template_deleted', $event);
        $this->assertEquals($template->get_id(), $event->objectid);
        $this->assertEquals($template->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the template updated event.
     *
     */
    public function test_template_updated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $template = $lpg->create_template();

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $template->set_shortname('Shortname modified');
        api::update_template($template->to_record());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_template_updated', $event);
        $this->assertEquals($template->get_id(), $event->objectid);
        $this->assertEquals($template->get_contextid(), $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency updated event.
     *
     */
    public function test_competency_updated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $f1 = $lpg->create_framework();
        $competency = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c12 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id(), 'parentid' => $c1->get_id()));
        $c13 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id(), 'parentid' => $c1->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $competency->set_shortname('Shortname modified');
        api::update_competency($competency->to_record());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_updated', $event);
        $this->assertEquals($competency->get_id(), $event->objectid);
        $this->assertEquals($competency->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency created event.
     *
     */
    public function test_competency_created() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $f1 = $lpg->create_framework();
        $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $record = $c1->to_record();
        $record->id = 0;
        $record->idnumber = 'comp idnumber';

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        // Create competency should trigger a created event.
        $competency = api::create_competency($record);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        $this->assertInstanceOf('\core\event\competency_created', $event);
        $this->assertEquals($competency->get_id(), $event->objectid);
        $this->assertEquals($competency->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency created event by duplicate framework.
     *
     */
    public function test_competency_created_by_duplicateframework() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $f1 = $lpg->create_framework();
        $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c12 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id(), 'parentid' => $c1->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        // Create framework should trigger a created event for competencies.
        api::duplicate_framework($f1->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $this->assertEquals(4, count($events));

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_created', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_created', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_created', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_framework_created', $event);
    }

    /**
     * Test the competency deleted event.
     *
     */
    public function test_competency_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $f1 = $lpg->create_framework();
        $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c1id = $c1->get_id();
        $contextid = $c1->get_context()->id;

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        // Delete competency should trigger a deleted event.
        api::delete_competency($c1id);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        $this->assertInstanceOf('\core\event\competency_deleted', $event);
        $this->assertEquals($c1id, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the competency deleted event by delete framework.
     *
     */
    public function test_competency_deleted_by_deleteframework() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $f1 = $lpg->create_framework();
        $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
        $c12 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id(), 'parentid' => $c1->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        // Delete framework should trigger a deleted event for competencies.
        api::delete_framework($f1->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $this->assertEquals(4, count($events));

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_framework_deleted', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_deleted', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_deleted', $event);

        $event = array_shift($events);
        $this->assertInstanceOf('\core\event\competency_deleted', $event);
    }

    /**
     * Test the plan created event.
     *
     */
    public function test_plan_created() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $plan = array (
            'name' => 'plan',
            'userid' => $user->id
        );
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $plan = api::create_plan((object)$plan);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_plan_created', $event);
        $this->assertEquals($plan->get_id(), $event->objectid);
        $this->assertEquals($plan->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan created event using template_cohort.
     *
     */
    public function test_plan_created_using_templatecohort() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $user2 = $dg->create_user();
        $c1 = $dg->create_cohort();
        // Add 2 users to the cohort.
        cohort_add_member($c1->id, $user1->id);
        cohort_add_member($c1->id, $user2->id);
        $t1 = $lpg->create_template();
        $tc = $lpg->create_template_cohort(array(
            'templateid' => $t1->get_id(),
            'cohortid' => $c1->id
        ));
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::create_plans_from_template_cohort($t1->get_id(), $c1->id);
        // Get our event event.
        $plans = core_competency\plan::get_records(array('templateid' => $t1->get_id()), 'id');
        $events = $sink->get_events();
        $this->assertCount(2, $events);
        $this->assertCount(2, $plans);
        $event = $events[0];
        $plan = $plans[0];
        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_plan_created', $event);
        $this->assertEquals($plan->get_id(), $event->objectid);
        $this->assertEquals($plan->get_context()->id, $event->contextid);
        $event = $events[1];
        $plan = $plans[1];
        $this->assertInstanceOf('\core\event\competency_plan_created', $event);
        $this->assertEquals($plan->get_id(), $event->objectid);
        $this->assertEquals($plan->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan updated event.
     *
     */
    public function test_plan_updated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));
        $record = $plan->to_record();
        $record->name = 'Plan updated';
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $plan = api::update_plan($record);
        $this->assertEquals('Plan updated', $plan->get_name());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_updated', $event);
        $this->assertEquals($plan->get_id(), $event->objectid);
        $this->assertEquals($plan->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan deleted event.
     *
     */
    public function test_plan_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::delete_plan($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_deleted', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan viewed event.
     *
     */
    public function test_plan_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::plan_viewed($plan);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_plan_viewed', $event);
        $this->assertEquals($plan->get_id(), $event->objectid);
        $this->assertEquals($plan->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the evidence of prior learning created event.
     *
     */
    public function test_user_evidence_created() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $user = $dg->create_user();
        // Use DataGenerator to have a user_evidence record with the right format.
        $record = $userevidence = $lpg->create_user_evidence(array('userid' => $user->id))->to_record();
        $record->id = 0;
        $record->name = "New name";

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $userevidence = api::create_user_evidence((object) $record);

         // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        $this->assertInstanceOf('\core\event\competency_user_evidence_created', $event);
        $this->assertEquals($userevidence->get_id(), $event->objectid);
        $this->assertEquals($userevidence->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the evidence of prior learning  deleted event.
     *
     */
    public function test_user_evidence_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $user = $dg->create_user();
        $userevidence = $lpg->create_user_evidence(array('userid' => $user->id));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::delete_user_evidence($userevidence->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_evidence_deleted', $event);
        $this->assertEquals($userevidence->get_id(), $event->objectid);
        $this->assertEquals($userevidence->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the evidence of prior learning  updated event.
     *
     */
    public function test_user_evidence_updated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');

        $user = $dg->create_user();
        $userevidence = $lpg->create_user_evidence(array('userid' => $user->id));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $userevidence->set_name('Name modified');
        api::update_user_evidence($userevidence->to_record());

         // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_evidence_updated', $event);
        $this->assertEquals($userevidence->get_id(), $event->objectid);
        $this->assertEquals($userevidence->get_context()->id, $event->contextid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the user competency viewed event in plan.
     *
     */
    public function test_user_competency_viewed_in_plan() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user->id));
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $pc = $lpg->create_plan_competency(array('planid' => $plan->get_id(), 'competencyid' => $c->get_id()));
        $uc = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c->get_id()));

        // Can not log the event for user competency using completed plan.
        api::complete_plan($plan);

        try {
            api::user_competency_viewed_in_plan($uc, $plan->get_id());
            $this->fail('To log the user competency in completed plan '
                    . 'use user_competency_plan_viewed method.');
        } catch (coding_exception $e) {
            $this->assertRegExp('/To log the user competency in completed plan '
                    . 'use user_competency_plan_viewed method./', $e->getMessage());
        }

        api::reopen_plan($plan);
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::user_competency_viewed_in_plan($uc, $plan->get_id());

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_competency_viewed_in_plan', $event);
        $this->assertEquals($uc->get_id(), $event->objectid);
        $this->assertEquals($uc->get_context()->id, $event->contextid);
        $this->assertEquals($uc->get_userid(), $event->relateduserid);
        $this->assertEquals($plan->get_id(), $event->other['planid']);
        $this->assertEquals($c->get_id(), $event->other['competencyid']);

        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();

        // Test validation.
        $params = array (
            'objectid' => $uc->get_id(),
            'contextid' => $uc->get_context()->id,
            'other' => null
        );

        // Other value null.
        try {
            \core\event\competency_user_competency_viewed_in_plan::create($params)->trigger();
            $this->fail('The \'competencyid\' and \'planid\' values must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' and 'planid' values must be set./", $e->getMessage());
        }

        $params['other']['anythingelse'] = '';
        // Missing competencyid.
        try {
            \core\event\competency_user_competency_viewed_in_plan::create($params)->trigger();
            $this->fail('The \'competencyid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' value must be set./", $e->getMessage());
        }

        $params['other']['competencyid'] = $c->get_id();
        // Missing planid.
        try {
            \core\event\competency_user_competency_viewed_in_plan::create($params)->trigger();
            $this->fail('The \'planid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'planid' value must be set./", $e->getMessage());
        }
    }

    /**
     * Test the user competency viewed event in course.
     *
     */
    public function test_user_competency_viewed_in_course() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $course = $dg->create_course();
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $pc = $lpg->create_course_competency(array('courseid' => $course->id, 'competencyid' => $c->get_id()));
        $params = array('userid' => $user->id, 'competencyid' => $c->get_id(), 'courseid' => $course->id);
        $ucc = $lpg->create_user_competency_course($params);

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::user_competency_viewed_in_course($ucc);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_competency_viewed_in_course', $event);
        $this->assertEquals($ucc->get_id(), $event->objectid);
        $this->assertEquals(context_course::instance($course->id)->id, $event->contextid);
        $this->assertEquals($ucc->get_userid(), $event->relateduserid);
        $this->assertEquals($course->id, $event->courseid);
        $this->assertEquals($c->get_id(), $event->other['competencyid']);

        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();

        // Test validation.
        $params = array (
            'objectid' => $ucc->get_id(),
            'contextid' => $ucc->get_context()->id,
            'other' => null
        );

        // Missing courseid.
        try {
            \core\event\competency_user_competency_viewed_in_course::create($params)->trigger();
            $this->fail('The \'courseid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'courseid' value must be set./", $e->getMessage());
        }

        $params['contextid'] = context_course::instance($course->id)->id;
        $params['courseid'] = $course->id;
        // Missing competencyid.
        try {
            \core\event\competency_user_competency_viewed_in_course::create($params)->trigger();
            $this->fail('The \'competencyid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' value must be set./", $e->getMessage());
        }
    }

    /**
     * Test the user competency plan viewed event.
     *
     */
    public function test_user_competency_plan_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user->id));
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $ucp = $lpg->create_user_competency_plan(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id(),
            'planid' => $plan->get_id()
        ));

        // Can not log the event for user competency using non completed plan.
        try {
            api::user_competency_plan_viewed($ucp);
            $this->fail('To log the user competency in non-completed plan '
                    . 'use user_competency_viewed_in_plan method.');
        } catch (coding_exception $e) {
            $this->assertRegExp('/To log the user competency in non-completed plan '
                    . 'use user_competency_viewed_in_plan method./', $e->getMessage());
        }

        // Complete the plan.
        api::complete_plan($plan);

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::user_competency_plan_viewed($ucp);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_competency_plan_viewed', $event);
        $this->assertEquals($ucp->get_id(), $event->objectid);
        $this->assertEquals($ucp->get_context()->id, $event->contextid);
        $this->assertEquals($ucp->get_userid(), $event->relateduserid);
        $this->assertEquals($plan->get_id(), $event->other['planid']);
        $this->assertEquals($c->get_id(), $event->other['competencyid']);

        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();

        // Test validation.
        $params = array (
            'objectid' => $ucp->get_id(),
            'contextid' => $ucp->get_context()->id,
            'other' => null
        );

        // Other value null.
        try {
            \core\event\competency_user_competency_plan_viewed::create($params)->trigger();
            $this->fail('The \'competencyid\' and \'planid\' values must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' and 'planid' values must be set./", $e->getMessage());
        }

        $params['other']['anythingelse'] = '';
        // Missing competencyid.
        try {
            \core\event\competency_user_competency_plan_viewed::create($params)->trigger();
            $this->fail('The \'competencyid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' value must be set./", $e->getMessage());
        }

        $params['other']['competencyid'] = $c->get_id();
        // Missing planid.
        try {
            \core\event\competency_user_competency_plan_viewed::create($params)->trigger();
            $this->fail('The \'planid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'planid' value must be set./", $e->getMessage());
        }
    }

    /**
     * Test the user competency viewed event.
     *
     */
    public function test_user_competency_viewed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()
        ));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::user_competency_viewed($uc);

        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_user_competency_viewed', $event);
        $this->assertEquals($uc->get_id(), $event->objectid);
        $this->assertEquals($uc->get_context()->id, $event->contextid);
        $this->assertEquals($uc->get_userid(), $event->relateduserid);
        $this->assertEquals($c->get_id(), $event->other['competencyid']);

        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();

        // Test validation.
        $params = array (
            'objectid' => $uc->get_id(),
            'contextid' => $uc->get_context()->id
        );

        // Missing competencyid.
        try {
            \core\event\competency_user_competency_viewed::create($params)->trigger();
            $this->fail('The \'competencyid\' value must be set.');
        } catch (coding_exception $e) {
            $this->assertRegExp("/The 'competencyid' value must be set./", $e->getMessage());
        }
    }

    /**
     * Test the plan approved event.
     *
     */
    public function test_plan_approved() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::approve_plan($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_approved', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan unapproved event.
     *
     */
    public function test_plan_unapproved() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_ACTIVE));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::unapprove_plan($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_unapproved', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan reopened event.
     *
     */
    public function test_plan_reopened() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::reopen_plan($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_reopened', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan completed event.
     *
     */
    public function test_plan_completed() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_ACTIVE));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::complete_plan($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_completed', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan unlinked event.
     *
     */
    public function test_plan_unlinked() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $template = $lpg->create_template();
        $plan = $lpg->create_plan(array(
            'userid' => $user1->id,
            'status' => \core_competency\plan::STATUS_ACTIVE,
            'templateid' => $template->get_id()
        ));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::unlink_plan_from_template($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_unlinked', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan review requested event.
     *
     */
    public function test_plan_review_requested() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::plan_request_review($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_review_requested', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan review request cancelled event.
     *
     */
    public function test_plan_review_request_cancelled() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_WAITING_FOR_REVIEW));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::plan_cancel_review_request($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_review_request_cancelled', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan review started event.
     *
     */
    public function test_plan_review_started() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_WAITING_FOR_REVIEW));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::plan_start_review($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_review_started', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the plan review stopped event.
     *
     */
    public function test_plan_review_stopped() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_IN_REVIEW));
        $planid = $plan->get_id();
        $contextid = $plan->get_context()->id;
        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        $result = api::plan_stop_review($plan->get_id());
        $this->assertTrue($result);
        // Get our event event.
        $events = $sink->get_events();
        $event = reset($events);
        $this->assertInstanceOf('\core\event\competency_plan_review_stopped', $event);
        $this->assertEquals($planid, $event->objectid);
        $this->assertEquals($contextid, $event->contextid);
        $this->assertEquals($plan->get_userid(), $event->relateduserid);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test plan comment created event.
     */
    public function test_plan_comment_created() {
        $this->resetAfterTest(true);
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $this->setUser($user);
        $plan = $lpg->create_plan(array('userid' => $user->id));
        $context = context_user::instance($user->id);

        $cmt = new stdClass();
        $cmt->context = $context;
        $cmt->area = 'plan';
        $cmt->itemid = $plan->get_id();
        $cmt->component = 'competency';
        $cmt->showcount = 1;
        $manager = new comment($cmt);
        $manager->set_post_permission(true);

        // Triggering and capturing the event.
        $sink = $this->redirectEvents();
        $manager->add("New comment for plan");
        $events = $sink->get_events();
        // Add comment will trigger 2 other events message_viewed and message_sent.
        $this->assertCount(1, $events);
        $event = array_pop($events);

        // Checking that the event contains the expected values.
        $this->assertInstanceOf('\core\event\competency_comment_created', $event);
        $this->assertEquals($context, $event->get_context());
        $this->assertEquals($plan->get_id(), $event->other['itemid']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test plan comment deleted event.
     */
    public function test_plan_comment_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user1 = $dg->create_user();
        $plan = $lpg->create_plan(array('userid' => $user1->id));

        $context = context_user::instance($user1->id);

        $cmt = new stdClass();
        $cmt->context = $context;
        $cmt->area = 'plan';
        $cmt->itemid = $plan->get_id();
        $cmt->component = 'competency';
        $manager = new comment($cmt);
        $newcomment = $manager->add("Comment to be deleted");

        // Triggering and capturing the event.
        $sink = $this->redirectEvents();
        $manager->delete($newcomment->id);
        $events = $sink->get_events();
        $this->assertCount(1, $events);
        $event = reset($events);

        // Checking that the event contains the expected values.
        $this->assertInstanceOf('\core\event\competency_comment_deleted', $event);
        $this->assertEquals($context, $event->get_context());
        $this->assertEquals($plan->get_id(), $event->other['itemid']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test evidence_created event.
     */
    public function test_evidence_created() {
        global $USER;

        $this->resetAfterTest(true);
        $dg = $this->getDataGenerator();
        $syscontext = context_system::instance();

        // Create a student.
        $student = $dg->create_user();

        // Create a competency for the course.
        $lpg = $dg->get_plugin_generator('core_competency');
        $framework = $lpg->create_framework();
        $comp = $lpg->create_competency(['competencyframeworkid' => $framework->get_id()]);

        // Trigger and capture the event.
        $sink = $this->redirectEvents();

        // Add evidence.
        $recommend = false;
        $evidence = api::add_evidence($student->id, $comp, $syscontext, \core_competency\evidence::ACTION_OVERRIDE,
            'commentincontext', 'core', null, $recommend, null, 1);

        // Get event.
        $events = $sink->get_events();
        $event = reset($events);

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_evidence_created', $event);
        $this->assertEquals($evidence->get_contextid(), $event->contextid);
        $this->assertEquals($evidence->get_id(), $event->objectid);
        $this->assertEquals($evidence->get_actionuserid(), $event->userid);
        $this->assertEquals($student->id, $event->relateduserid);
        $this->assertEquals($evidence->get_usercompetencyid(), $event->other['usercompetencyid']);
        $this->assertEquals($comp->get_id(), $event->other['competencyid']);
        $this->assertEquals($evidence->get_action(), $event->other['action']);
        $this->assertEquals($recommend, $event->other['recommend']);

        // Test get_name().
        $this->assertEquals(get_string('eventevidencecreated', 'core_competency'), $event->get_name());

        // Test get_description().
        $description = "The user with id '$USER->id' created an evidence with id '{$evidence->get_id()}'.";
        $this->assertEquals($description, $event->get_description());

        // Test get_url().
        $url = url::user_competency($evidence->get_usercompetencyid());
        $this->assertEquals($url, $event->get_url());

        // Test get_objectid_mapping().
        $this->assertEquals(\core\event\base::NOT_MAPPED, $event->get_objectid_mapping());

        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test evidence_created event by linking an invalid user competency to an evidence.
     */
    public function test_evidence_created_with_invalid_user_competency() {
        $this->resetAfterTest(true);
        $dg = $this->getDataGenerator();
        $syscontext = context_system::instance();

        // Create students.
        $student = $dg->create_user();
        $student2 = $dg->create_user();

        // Create a competency for the course.
        $lpg = $dg->get_plugin_generator('core_competency');
        $framework = $lpg->create_framework();
        $comp = $lpg->create_competency(['competencyframeworkid' => $framework->get_id()]);

        // Create a different user competency.
        $otheruc = \core_competency\user_competency::create_relation($student2->id, $comp->get_id());
        $otheruc->create();

        // Add evidence.
        $recommend = false;
        $evidence = api::add_evidence($student->id, $comp, $syscontext, \core_competency\evidence::ACTION_OVERRIDE,
            'commentincontext', 'core', null, $recommend, null, 1);

        // We expect this to fail and throw a coding exception.
        $this->setExpectedException('coding_exception', 'The user competency linked with this evidence is invalid.');
        \core\event\competency_evidence_created::create_from_evidence($evidence, $otheruc, $recommend)->trigger();
    }

    /**
     * Test creation of evidence_created event with missing data.
     *
     * These data are validated by \core_competency\evidence_created::validate_data().
     */
    public function test_evidence_created_with_missing_data() {
        $eventdata = [
            'contextid'  => 1,
            'objectid' => 1,
            'userid' => 1
        ];

        // No relateduserid.
        $errormsg = 'The \'relateduserid\' must be set.';
        try {
            \core\event\competency_evidence_created::create($eventdata)->trigger();
            $this->fail('Coding exception should have been thrown: ' . $errormsg);
        } catch (coding_exception $e) {
            $this->assertContains($errormsg, $e->getMessage());
        }
        $eventdata['relateduserid'] = 1;

        // No other['usercompetencyid'].
        $errormsg = 'The \'usercompetencyid\' data in \'other\' must be set.';
        try {
            \core\event\competency_evidence_created::create($eventdata)->trigger();
            $this->fail('Coding exception should have been thrown: ' . $errormsg);
        } catch (coding_exception $e) {
            $this->assertContains($errormsg, $e->getMessage());
        }
        $eventdata['other']['usercompetencyid'] = 1;

        // No other['competencyid'].
        $errormsg = 'The \'competencyid\' data in \'other\' must be set.';
        try {
            \core\event\competency_evidence_created::create($eventdata)->trigger();
            $this->fail('Coding exception should have been thrown: ' . $errormsg);
        } catch (coding_exception $e) {
            $this->assertContains($errormsg, $e->getMessage());
        }
        $eventdata['other']['competencyid'] = 1;

        // No other['action'].
        $errormsg = 'The \'action\' data in \'other\' must be set.';
        try {
            \core\event\competency_evidence_created::create($eventdata)->trigger();
            $this->fail('Coding exception should have been thrown: ' . $errormsg);
        } catch (coding_exception $e) {
            $this->assertContains($errormsg, $e->getMessage());
        }
        $eventdata['other']['action'] = 1;

        // No other['recommend'].
        $errormsg = 'The \'recommend\' data in \'other\' must be set.';
        try {
            \core\event\competency_evidence_created::create($eventdata)->trigger();
            $this->fail('Coding exception should have been thrown: ' . $errormsg);
        } catch (coding_exception $e) {
            $this->assertContains($errormsg, $e->getMessage());
        }
        $eventdata['other']['recommend'] = 1;

        // Event should be triggered without any problems.
        \core\event\competency_evidence_created::create($eventdata)->trigger();
    }

    /**
     * Test the user competency grade rated event.
     *
     */
    public function test_user_competency_rated() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
        $scaleconfig = array(array('scaleid' => $scale->id));
        $scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
        $scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array(
            'competencyframeworkid' => $fr->get_id(),
            'scaleid' => $scale->id,
            'scaleconfiguration' => $scaleconfig
        ));

        $user = $dg->create_user();
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::grade_competency($user->id, $c->get_id(), 2, true);

        // Get our event event.
        $events = $sink->get_events();
        // Evidence created.
        $this->assertCount(2, $events);
        $evidencecreatedevent = $events[0];
        $event = $events[1];

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_evidence_created', $evidencecreatedevent);
        $this->assertInstanceOf('\core\event\competency_user_competency_rated', $event);
        $this->assertEquals($uc->get_id(), $event->objectid);
        $this->assertEquals($uc->get_context()->id, $event->contextid);
        $this->assertEquals($uc->get_userid(), $event->relateduserid);
        $this->assertEquals(2, $event->other['grade']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the user competency grade rated in course event.
     *
     */
    public function test_user_competency_rated_in_course() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
        $course = $dg->create_course();
        $user = $dg->create_user();
        $studentarch = get_archetype_roles('student');
        $studentrole = array_shift($studentarch);
        $scaleconfig = array(array('scaleid' => $scale->id));
        $scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
        $scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array(
            'competencyframeworkid' => $fr->get_id(),
            'scaleid' => $scale->id,
            'scaleconfiguration' => $scaleconfig
        ));
        // Enrol the user as students in course.
        $dg->enrol_user($user->id, $course->id, $studentrole->id);
        $lpg->create_course_competency(array(
            'courseid' => $course->id,
            'competencyid' => $c->get_id()));
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::grade_competency_in_course($course->id, $user->id, $c->get_id(), 2, true);

        // Get our event event.
        $events = $sink->get_events();
        // Evidence created.
        $this->assertCount(2, $events);
        $evidencecreatedevent = $events[0];
        $event = $events[1];

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_evidence_created', $evidencecreatedevent);
        $this->assertInstanceOf('\core\event\competency_user_competency_rated_in_course', $event);
        $this->assertEquals(context_course::instance($course->id)->id, $event->contextid);
        $this->assertEquals($course->id, $event->courseid);
        $this->assertEquals($uc->get_userid(), $event->relateduserid);
        $this->assertEquals($uc->get_competencyid(), $event->other['competencyid']);
        $this->assertEquals(2, $event->other['grade']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test the user competency grade rated in plan event.
     *
     */
    public function test_user_competency_rated_in_plan() {
         $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $scale = $dg->create_scale(array('scale' => 'A,B,C,D'));
        $user = $dg->create_user();
        $scaleconfig = array(array('scaleid' => $scale->id));
        $scaleconfig[] = array('name' => 'A', 'id' => 1, 'scaledefault' => 0, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'B', 'id' => 2, 'scaledefault' => 1, 'proficient' => 0);
        $scaleconfig[] = array('name' => 'C', 'id' => 3, 'scaledefault' => 0, 'proficient' => 1);
        $scaleconfig[] = array('name' => 'D', 'id' => 4, 'scaledefault' => 0, 'proficient' => 1);
        $plan = $lpg->create_plan(array('userid' => $user->id));
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array(
            'competencyframeworkid' => $fr->get_id(),
            'scaleid' => $scale->id,
            'scaleconfiguration' => $scaleconfig
        ));
        $pc = $lpg->create_plan_competency(array('planid' => $plan->get_id(), 'competencyid' => $c->get_id()));
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()));

        // Trigger and capture the event.
        $sink = $this->redirectEvents();
        api::grade_competency_in_plan($plan->get_id(), $c->get_id(), 3, true);

        // Get our event event.
        $events = $sink->get_events();
        // Evidence created.
        $this->assertCount(2, $events);
        $evidencecreatedevent = $events[0];
        $event = $events[1];

        // Check that the event data is valid.
        $this->assertInstanceOf('\core\event\competency_evidence_created', $evidencecreatedevent);
        $this->assertInstanceOf('\core\event\competency_user_competency_rated_in_plan', $event);
        $this->assertEquals($uc->get_id(), $event->objectid);
        $this->assertEquals($uc->get_context()->id, $event->contextid);
        $this->assertEquals($uc->get_userid(), $event->relateduserid);
        $this->assertEquals($uc->get_competencyid(), $event->other['competencyid']);
        $this->assertEquals(3, $event->other['grade']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test user competency comment created event.
     */
    public function test_user_competency_comment_created() {
        $this->resetAfterTest(true);

        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $this->setUser($user);
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()
        ));

        $context = context_user::instance($user->id);
        $cmt = new stdClass();
        $cmt->context = $context;
        $cmt->area = 'user_competency';
        $cmt->itemid = $uc->get_id();
        $cmt->component = 'competency';
        $cmt->showcount = 1;
        $manager = new comment($cmt);

        // Triggering and capturing the event.
        $sink = $this->redirectEvents();
        $manager->add("New comment for user competency");
        $events = $sink->get_events();
        // Add comment will trigger 2 other events message_viewed and message_sent.
        $this->assertCount(1, $events);
        $event = reset($events);

        // Checking that the event contains the expected values.
        $this->assertInstanceOf('\core\event\competency_comment_created', $event);
        $this->assertEquals($context, $event->get_context());
        $this->assertEquals($uc->get_id(), $event->other['itemid']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test plan comment deleted event.
     */
    public function test_user_competency_comment_deleted() {
        $this->resetAfterTest(true);
        $this->setAdminUser();
        $dg = $this->getDataGenerator();
        $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency');
        $user = $dg->create_user();
        $fr = $lpg->create_framework();
        $c = $lpg->create_competency(array('competencyframeworkid' => $fr->get_id()));
        $uc = $lpg->create_user_competency(array(
            'userid' => $user->id,
            'competencyid' => $c->get_id()
        ));
        $context = context_user::instance($user->id);

        $cmt = new stdClass();
        $cmt->context = $context;
        $cmt->area = 'user_competency';
        $cmt->itemid = $uc->get_id();
        $cmt->component = 'competency';
        $manager = new comment($cmt);
        $newcomment = $manager->add("Comment to be deleted");

        // Triggering and capturing the event.
        $sink = $this->redirectEvents();
        $manager->delete($newcomment->id);
        $events = $sink->get_events();
        $this->assertCount(1, $events);
        $event = reset($events);

        // Checking that the event contains the expected values.
        $this->assertInstanceOf('\core\event\competency_comment_deleted', $event);
        $this->assertEquals($context, $event->get_context());
        $this->assertEquals($uc->get_id(), $event->other['itemid']);
        $this->assertEventContextNotUsed($event);
        $this->assertDebuggingNotCalled();
    }
}
