diff --git a/admin/tool/lp/tests/externallib_test.php b/admin/tool/lp/tests/externallib_test.php
index 2d860133806..21bb65ae032 100644
--- a/admin/tool/lp/tests/externallib_test.php
+++ b/admin/tool/lp/tests/externallib_test.php
@@ -39,12 +39,21 @@ use tool_lp\plan;
  */
 class tool_lp_external_testcase extends externallib_advanced_testcase {
 
-    /** @var stdClass $learningplancreator User with enough permissions to create */
+    /** @var stdClass $creator User with enough permissions to create insystem context. */
     protected $creator = null;
 
-    /** @var stdClass $learningplanuser User with enough permissions to view */
+    /** @var stdClass $learningplancreator User with enough permissions to create incategory context. */
+    protected $catcreator = null;
+
+    /** @var stdClass $category Category */
+    protected $category = null;
+
+    /** @var stdClass $user User with enough permissions to view insystem context */
     protected $user = null;
 
+    /** @var stdClass $catuser User with enough permissions to view incategory context */
+    protected $catuser = null;
+
     /** @var int Creator role id */
     protected $creatorrole = null;
 
@@ -52,7 +61,7 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
     protected $userrole = null;
 
     /**
-     * Setup function - we will create a course and add an assign instance to it.
+     * Setup function- we will create a course and add an assign instance to it.
      */
     protected function setUp() {
         global $DB;
@@ -62,24 +71,49 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         // Create some users.
         $creator = $this->getDataGenerator()->create_user();
         $user = $this->getDataGenerator()->create_user();
-        $syscontext = context_system::instance();
+        $catuser = $this->getDataGenerator()->create_user();
+        $category = $this->getDataGenerator()->create_category();
+        $catcreator = $this->getDataGenerator()->create_user();
 
+        $syscontext = context_system::instance();
+        $catcontext = context_coursecat::instance($category->id);
+
+        // Fetching default authenticated user role.
+        $userroles = get_archetype_roles('user');
+        $this->assertCount(1, $userroles);
+        $authrole = array_pop($userroles);
+
+        // Reset all default authenticated users permissions.
+        unassign_capability('tool/lp:competencymanage', $authrole->id);
+        unassign_capability('tool/lp:competencyread', $authrole->id);
+        unassign_capability('tool/lp:planmanageall', $authrole->id);
+        unassign_capability('tool/lp:planmanageown', $authrole->id);
+        unassign_capability('tool/lp:planviewall', $authrole->id);
+        unassign_capability('tool/lp:templatemanage', $authrole->id);
+        unassign_capability('tool/lp:templateread', $authrole->id);
+
+        // Creating specific roles.
         $this->creatorrole = create_role('Creator role', 'creatorrole', 'learning plan creator role description');
         $this->userrole = create_role('User role', 'userrole', 'learning plan user role description');
 
         assign_capability('tool/lp:competencymanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
-        assign_capability('tool/lp:competencyview', CAP_ALLOW, $this->userrole, $syscontext->id);
+        assign_capability('tool/lp:competencyread', CAP_ALLOW, $this->userrole, $syscontext->id);
         assign_capability('tool/lp:planmanageall', CAP_ALLOW, $this->creatorrole, $syscontext->id);
         assign_capability('tool/lp:planmanageown', CAP_ALLOW, $this->creatorrole, $syscontext->id);
         assign_capability('tool/lp:planviewall', CAP_ALLOW, $this->creatorrole, $syscontext->id);
         assign_capability('tool/lp:templatemanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
-        assign_capability('tool/lp:templatemanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
+        assign_capability('tool/lp:templateread', CAP_ALLOW, $this->userrole, $syscontext->id);
 
         role_assign($this->creatorrole, $creator->id, $syscontext->id);
+        role_assign($this->creatorrole, $catcreator->id, $catcontext->id);
         role_assign($this->userrole, $user->id, $syscontext->id);
+        role_assign($this->userrole, $catuser->id, $catcontext->id);
 
         $this->creator = $creator;
+        $this->catcreator = $catcreator;
         $this->user = $user;
+        $this->catuser = $catuser;
+        $this->category = $category;
         accesslib_clear_all_caches_for_unit_testing();
     }
 
@@ -93,6 +127,16 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
             array('contextid' => context_system::instance()->id));
     }
 
+    /**
+     * Test we can't create a competency framework with only read permissions.
+     */
+    public function test_create_competency_frameworks_with_read_permissions_in_category() {
+        $this->setExpectedException('required_capability_exception');
+        $this->setUser($this->catuser);
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+    }
+
     /**
      * Test we can create a competency framework with manage permissions.
      */
@@ -112,6 +156,32 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals(true, $result->visible);
     }
 
+    /**
+     * Test we can create a competency framework with manage permissions.
+     */
+    public function test_create_competency_frameworks_with_manage_permissions_in_category() {
+        $this->setUser($this->catcreator);
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $result = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        $this->assertGreaterThan(0, $result->timecreated);
+        $this->assertGreaterThan(0, $result->timemodified);
+        $this->assertEquals($this->catcreator->id, $result->usermodified);
+        $this->assertEquals('shortname', $result->shortname);
+        $this->assertEquals('idnumber', $result->idnumber);
+        $this->assertEquals('description', $result->description);
+        $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
+        $this->assertEquals(true, $result->visible);
+
+        try {
+            external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+                array('contextid' => context_system::instance()->id));
+            $this->fail('User cannot create a framework at system level.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we cannot create a competency framework with nasty data.
      */
@@ -145,6 +215,42 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals(true, $result->visible);
     }
 
+    /**
+     * Test we can read a competency framework with manage permissions.
+     */
+    public function test_read_competency_frameworks_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        $this->setUser($this->catcreator);
+        $id = $incat->id;
+        $result = external::read_competency_framework($id);
+        $result = (object) external_api::clean_returnvalue(external::read_competency_framework_returns(), $result);
+
+        $this->assertGreaterThan(0, $result->timecreated);
+        $this->assertGreaterThan(0, $result->timemodified);
+        $this->assertEquals($this->creator->id, $result->usermodified);
+        $this->assertEquals('catshortname', $result->shortname);
+        $this->assertEquals('catidnumber', $result->idnumber);
+        $this->assertEquals('catdescription', $result->description);
+        $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
+        $this->assertEquals(true, $result->visible);
+
+        try {
+            $id = $insystem->id;
+            $result = external::read_competency_framework($id);
+            $result = (object) external_api::clean_returnvalue(external::read_competency_framework_returns(), $result);
+            $this->fail('User cannot read a framework at system level.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we can read a competency framework with read permissions.
      */
@@ -169,6 +275,41 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
         $this->assertEquals(true, $result->visible);
     }
+    /**
+     * Test we can read a competency framework with read permissions.
+     */
+    public function test_read_competency_frameworks_with_read_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        // Switch users to someone with less permissions.
+        $this->setUser($this->catuser);
+        $id = $incat->id;
+        $result = external::read_competency_framework($id);
+        $result = (object) external_api::clean_returnvalue(external::read_competency_framework_returns(), $result);
+
+        $this->assertGreaterThan(0, $result->timecreated);
+        $this->assertGreaterThan(0, $result->timemodified);
+        $this->assertEquals($this->creator->id, $result->usermodified);
+        $this->assertEquals('catshortname', $result->shortname);
+        $this->assertEquals('catidnumber', $result->idnumber);
+        $this->assertEquals('catdescription', $result->description);
+        $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
+        $this->assertEquals(true, $result->visible);
+
+        // Switching to user with no permissions.
+        try {
+            $result = external::read_competency_framework($insystem->id);
+            $this->fail('Current user cannot should not be able to read the framework.');
+        } catch (required_capability_exception $e) {
+        }
+    }
 
     /**
      * Test we can delete a competency framework with manage permissions.
@@ -186,6 +327,35 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertTrue($result);
     }
 
+    /**
+     * Test we can delete a competency framework with manage permissions.
+     */
+    public function test_delete_competency_frameworks_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        $this->setUser($this->catcreator);
+        $id = $incat->id;
+        $result = external::delete_competency_framework($id);
+        $result = external_api::clean_returnvalue(external::delete_competency_framework_returns(), $result);
+
+        $this->assertTrue($result);
+
+        try {
+            $id = $insystem->id;
+            $result = external::delete_competency_framework($id);
+            $result = external_api::clean_returnvalue(external::delete_competency_framework_returns(), $result);
+            $this->fail('Current user cannot should not be able to delete the framework.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we can delete a competency framework with read permissions.
      */
@@ -218,6 +388,36 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertTrue($result);
     }
 
+    /**
+     * Test we can update a competency framework with manage permissions.
+     */
+    public function test_update_competency_frameworks_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        $this->setUser($this->catcreator);
+        $id = $incat->id;
+
+        $result = external::update_competency_framework($id, 'shortname2', 'idnumber2', 'description2', FORMAT_PLAIN, false);
+        $result = external_api::clean_returnvalue(external::update_competency_framework_returns(), $result);
+
+        $this->assertTrue($result);
+
+        try {
+            $id = $insystem->id;
+            $result = external::update_competency_framework($id, 'shortname3', 'idnumber3', 'description3', FORMAT_PLAIN, false);
+            $result = external_api::clean_returnvalue(external::update_competency_framework_returns(), $result);
+            $this->fail('Current user cannot should not be able to update the framework.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we can update a competency framework with read permissions.
      */
@@ -338,6 +538,44 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals($framework->id, $competency->competencyframeworkid);
     }
 
+
+    /**
+     * Test we can create a competency with manage permissions.
+     */
+    public function test_create_competency_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+
+        $this->setUser($this->catcreator);
+
+        $competency = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $incat->id, 0);
+        $competency = (object) external_api::clean_returnvalue(external::create_competency_returns(), $competency);
+
+        $this->assertGreaterThan(0, $competency->timecreated);
+        $this->assertGreaterThan(0, $competency->timemodified);
+        $this->assertEquals($this->catcreator->id, $competency->usermodified);
+        $this->assertEquals('shortname', $competency->shortname);
+        $this->assertEquals('idnumber', $competency->idnumber);
+        $this->assertEquals('description', $competency->description);
+        $this->assertEquals(FORMAT_HTML, $competency->descriptionformat);
+        $this->assertEquals(true, $competency->visible);
+        $this->assertEquals(0, $competency->parentid);
+        $this->assertEquals($incat->id, $competency->competencyframeworkid);
+
+        try {
+            $competency = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $insystem->id, 0);
+            $competency = (object) external_api::clean_returnvalue(external::create_competency_returns(), $competency);
+            $this->fail('User should not be able to create a competency in system context.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we cannot create a competency with nasty data.
      */
@@ -375,7 +613,48 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
         $this->assertEquals(true, $result->visible);
         $this->assertEquals(0, $result->parentid);
+        $this->assertEquals($framework->id, $result->competencyframeworkid);
+    }
+
+    /**
+     * Test we can read a competency with manage permissions.
+     */
+    public function test_read_competencies_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $sysframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $catframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $this->setUser($this->catcreator);
+        $id = $incat->id;
+        $result = external::read_competency($id);
+        $result = (object) external_api::clean_returnvalue(external::read_competency_returns(), $result);
+
+        $this->assertGreaterThan(0, $result->timecreated);
+        $this->assertGreaterThan(0, $result->timemodified);
+        $this->assertEquals($this->creator->id, $result->usermodified);
+        $this->assertEquals('shortname', $result->shortname);
+        $this->assertEquals('idnumber', $result->idnumber);
+        $this->assertEquals('description', $result->description);
+        $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
+        $this->assertEquals(true, $result->visible);
         $this->assertEquals(0, $result->parentid);
+        $this->assertEquals($catframework->id, $result->competencyframeworkid);
+
+        try {
+            external::read_competency($insystem->id);
+            $this->fail('User should not be able to read a competency in system context.');
+        } catch (required_capability_exception $e) {
+        }
     }
 
     /**
@@ -404,7 +683,49 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
         $this->assertEquals(true, $result->visible);
         $this->assertEquals(0, $result->parentid);
+        $this->assertEquals($framework->id, $result->competencyframeworkid);
+    }
+
+    /**
+     * Test we can read a competency with read permissions.
+     */
+    public function test_read_competencies_with_read_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $sysframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $catframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        // Switch users to someone with less permissions.
+        $this->setUser($this->catuser);
+        $id = $incat->id;
+        $result = external::read_competency($id);
+        $result = (object) external_api::clean_returnvalue(external::read_competency_returns(), $result);
+
+        $this->assertGreaterThan(0, $result->timecreated);
+        $this->assertGreaterThan(0, $result->timemodified);
+        $this->assertEquals($this->creator->id, $result->usermodified);
+        $this->assertEquals('shortname', $result->shortname);
+        $this->assertEquals('idnumber', $result->idnumber);
+        $this->assertEquals('description', $result->description);
+        $this->assertEquals(FORMAT_HTML, $result->descriptionformat);
+        $this->assertEquals(true, $result->visible);
         $this->assertEquals(0, $result->parentid);
+        $this->assertEquals($catframework->id, $result->competencyframeworkid);
+
+        try {
+            external::read_competency($insystem->id);
+            $this->fail('User should not be able to read a competency in system context.');
+        } catch (required_capability_exception $e) {
+        }
     }
 
     /**
@@ -425,6 +746,38 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertTrue($result);
     }
 
+    /**
+     * Test we can delete a competency with manage permissions.
+     */
+    public function test_delete_competency_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $sysframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $catframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $this->setUser($this->catcreator);
+        $id = $incat->id;
+        $result = external::delete_competency($id);
+        $result = external_api::clean_returnvalue(external::delete_competency_returns(), $result);
+
+        $this->assertTrue($result);
+
+        try {
+            $result = external::delete_competency($insystem->id);
+            $this->fail('User should not be able to delete a competency in system context.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we can delete a competency with read permissions.
      */
@@ -460,6 +813,38 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
         $this->assertTrue($result);
     }
 
+    /**
+     * Test we can update a competency with manage permissions.
+     */
+    public function test_update_competency_with_manage_permissions_in_category() {
+        $this->setUser($this->creator);
+
+        $result = external::create_competency_framework('shortname', 'idnumber', 'description', FORMAT_HTML, true,
+            array('contextid' => context_system::instance()->id));
+        $sysframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $insystem = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $result = external::create_competency_framework('catshortname', 'catidnumber', 'catdescription', FORMAT_HTML, true,
+            array('contextid' => context_coursecat::instance($this->category->id)->id));
+        $catframework = (object) external_api::clean_returnvalue(external::create_competency_framework_returns(), $result);
+        $result = external::create_competency('shortname', 'idnumber', 'description', FORMAT_HTML, true, $result->id, 0);
+        $incat = (object) external_api::clean_returnvalue(external::create_competency_returns(), $result);
+
+        $this->setUser($this->catcreator);
+
+        $result = external::update_competency($incat->id, 'shortname2', 'idnumber2', 'description2', FORMAT_HTML, false);
+        $result = external_api::clean_returnvalue(external::update_competency_returns(), $result);
+
+        $this->assertTrue($result);
+
+        try {
+            external::update_competency($insystem->id, 'shortname2', 'idnumber2', 'description2', FORMAT_HTML, false);
+            $this->fail('User should not be able to update a competency in system context.');
+        } catch (required_capability_exception $e) {
+        }
+    }
+
     /**
      * Test we can update a competency with read permissions.
      */