enrol/lti/tests/sync_members_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Tests for the sync_members scheduled task class.
  19  *
  20  * @package enrol_lti
  21  * @copyright 2016 Jun Pataleta <jun@moodle.com>
  22  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 use enrol_lti\data_connector;
  26 use enrol_lti\helper;
  27 use enrol_lti\task\sync_members;
  28 use enrol_lti\tool_provider;
  29 use IMSGlobal\LTI\ToolProvider\Context;
  30 use IMSGlobal\LTI\ToolProvider\ResourceLink;
  31 use IMSGlobal\LTI\ToolProvider\ToolConsumer;
  32 use IMSGlobal\LTI\ToolProvider\User;
  33
  34 defined('MOODLE_INTERNAL') || die();
  35
  36 /**
  37  * Tests for the sync_members scheduled task class.
  38  *
  39  * @package enrol_lti
  40  * @copyright 2016 Jun Pataleta <jun@moodle.com>
  41  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  42  */
  43 class sync_members_testcase extends advanced_testcase {
  44     /** @var dummy_sync_members_task $task */
  45     protected $task;
  46
  47     /** @var  stdClass $tool The published tool. */
  48     protected $tool;
  49
  50     /** @var User[] $members */
  51     protected $members;
  52
  53     /** @var  ToolConsumer $consumer */
  54     protected $consumer;
  55
  56     /** @var  Context $context */
  57     protected $context;
  58
  59     /** @var  ResourceLink $resourcelink */
  60     protected $resourcelink;
  61
  62     public function setUp(): void {
  63         $this->resetAfterTest();
  64
  65         // Set this user as the admin.
  66         $this->setAdminUser();
  67
  68         $this->task = new dummy_sync_members_task();
  69
  70         $generator = $this->getDataGenerator();
  71         $course = $generator->create_course();
  72         $tooldata = [
  73             'courseid' => $course->id,
  74             'membersyncmode' => helper::MEMBER_SYNC_ENROL_AND_UNENROL,
  75             'membersync' => 1,
  76         ];
  77         $tool = $generator->create_lti_tool((object)$tooldata);
  78         $this->tool = helper::get_lti_tool($tool->id);
  79
  80         $dataconnector = $this->task->get_dataconnector();
  81         $this->consumer = new ToolConsumer('Consumer1Key', $dataconnector);
  82         $this->consumer->name = 'Consumer1';
  83         $this->consumer->secret = 'Consumer1Secret';
  84         $this->consumer->save();
  85
  86         $toolprovider = new tool_provider($this->tool->id);
  87         $toolprovider->consumer = $this->consumer;
  88         $toolprovider->map_tool_to_consumer();
  89
  90         $imageurl = $this->getExternalTestFileUrl('test.jpg');
  91         $count = 10;
  92         $this->members = [];
  93         for ($i = 1; $i <= $count; $i++) {
  94             $user = new User();
  95             $user->firstname = 'Firstname' . $i;
  96             $user->lastname = 'Lastname' . $i;
  97             $user->ltiUserId = 'user' . $i;
  98             // Set user image values for some users.
  99             if ($i % 3 == 0) {
 100                 $user->image = $imageurl;
 101             }
 102             $this->members[] = $user;
 103         }
 104
 105         $this->context = Context::fromConsumer($this->consumer, 'testlticontextid');
 106         $this->context->save();
 107
 108         $this->resourcelink = ResourceLink::fromContext($this->context, 'testresourcelinkid');
 109         $this->resourcelink->save();
 110     }
 111
 112     /**
 113      * Test for sync_members::do_context_membership_request().
 114      */
 115     public function test_do_context_membership_request() {
 116         // Suppress output.
 117         ob_start();
 118         $members = $this->task->do_context_membership_request($this->context);
 119         ob_end_clean();
 120         $this->assertFalse($members);
 121     }
 122
 123     /**
 124      * Test for sync_members::do_resourcelink_membership_request().
 125      */
 126     public function test_do_resourcelink_membership_request() {
 127         $members = $this->task->do_resourcelink_membership_request($this->resourcelink);
 128         $this->assertFalse($members);
 129     }
 130
 131     /**
 132      * Test for sync_members::execute() when auth_lti is disabled.
 133      */
 134     public function test_execute_authdisabled() {
 135         ob_start();
 136         $this->task->execute();
 137         $output = ob_get_clean();
 138         $message = 'Skipping task - ' . get_string('pluginnotenabled', 'auth', get_string('pluginname', 'auth_lti'));
 139         $this->assertContains($message, $output);
 140     }
 141
 142     /**
 143      * Test for sync_members::execute() when enrol_lti is disabled.
 144      */
 145     public function test_execute_enroldisabled() {
 146         // Enable auth_lti.
 147         $this->enable_auth();
 148
 149         ob_start();
 150         $this->task->execute();
 151         $output = ob_get_clean();
 152         $message = 'Skipping task - ' . get_string('enrolisdisabled', 'enrol_lti');
 153         $this->assertContains($message, $output);
 154     }
 155
 156     /**
 157      * Test for sync_members::execute().
 158      */
 159     public function test_execute() {
 160         // Enable auth_lti.
 161         $this->enable_auth();
 162
 163         // Enable enrol_lti.
 164         $this->enable_enrol();
 165
 166         ob_start();
 167         $this->task->execute();
 168         $output = ob_get_clean();
 169
 170         $membersyncmessage = "Completed - Synced members for tool '{$this->tool->id}' in the course '{$this->tool->courseid}'";
 171         $this->assertContains($membersyncmessage, $output);
 172
 173         $imagesyncmessage = "Completed - Synced 0 profile images.";
 174         $this->assertContains($imagesyncmessage, $output);
 175     }
 176
 177     /**
 178      * Test for sync_members::fetch_members_from_consumer() with no resource link nor context associated with the consumer.
 179      */
 180     public function test_fetch_members_from_consumer_noresourcelink_nocontext() {
 181         // Suppress output.
 182         ob_start();
 183         $members = $this->task->fetch_members_from_consumer($this->consumer);
 184         ob_end_clean();
 185         $this->assertFalse($members);
 186     }
 187
 188     /**
 189      * Test for sync_members::get_name().
 190      */
 191     public function test_get_name() {
 192         $this->assertEquals(get_string('tasksyncmembers', 'enrol_lti'), $this->task->get_name());
 193     }
 194
 195     /**
 196      * Test for sync_members::should_sync_enrol().
 197      */
 198     public function test_should_sync_enrol() {
 199         $this->assertTrue($this->task->should_sync_enrol(helper::MEMBER_SYNC_ENROL_AND_UNENROL));
 200         $this->assertTrue($this->task->should_sync_enrol(helper::MEMBER_SYNC_ENROL_NEW));
 201         $this->assertFalse($this->task->should_sync_enrol(helper::MEMBER_SYNC_UNENROL_MISSING));
 202     }
 203
 204     /**
 205      * Test for sync_members::should_sync_unenrol().
 206      */
 207     public function test_should_sync_unenrol() {
 208         $this->assertTrue($this->task->should_sync_unenrol(helper::MEMBER_SYNC_ENROL_AND_UNENROL));
 209         $this->assertFalse($this->task->should_sync_unenrol(helper::MEMBER_SYNC_ENROL_NEW));
 210         $this->assertTrue($this->task->should_sync_unenrol(helper::MEMBER_SYNC_UNENROL_MISSING));
 211     }
 212
 213     /**
 214      * Test for sync_members::sync_member_information().
 215      */
 216     public function test_sync_member_information() {
 217         list($totalcount, $enrolledcount) = $this->task->sync_member_information($this->tool, $this->consumer, $this->members);
 218         $membercount = count($this->members);
 219         $this->assertCount(10, $this->members);
 220         $this->assertEquals($membercount, $totalcount);
 221         $this->assertEquals($membercount, $enrolledcount);
 222     }
 223
 224     /**
 225      * Test for sync_members::sync_profile_images().
 226      */
 227     public function test_sync_profile_images() {
 228         $task = $this->task;
 229         list($totalcount, $enrolledcount) = $task->sync_member_information($this->tool, $this->consumer, $this->members);
 230         $membercount = count($this->members);
 231         $this->assertCount(10, $this->members);
 232         $this->assertEquals($membercount, $totalcount);
 233         $this->assertEquals($membercount, $enrolledcount);
 234
 235         // Suppress output.
 236         ob_start();
 237         $this->assertEquals(3, $task->sync_profile_images());
 238         ob_end_clean();
 239     }
 240
 241     /**
 242      * Test for sync_members::sync_unenrol().
 243      */
 244     public function test_sync_unenrol() {
 245         $tool = $this->tool;
 246         $task = $this->task;
 247
 248         $task->sync_member_information($tool, $this->consumer, $this->members);
 249
 250         // Simulate that the fetched list of current users has been reduced by 3.
 251         $unenrolcount = 3;
 252         for ($i = 0; $i < $unenrolcount; $i++) {
 253             $task->pop_current_users();
 254         }
 255         $this->assertEquals($unenrolcount, $task->sync_unenrol($tool));
 256     }
 257
 258     /**
 259      * Enable auth_lti plugin.
 260      */
 261     protected function enable_auth() {
 262         $auths = get_enabled_auth_plugins(true);
 263         if (!in_array('lti', $auths)) {
 264             $auths[] = 'lti';
 265         }
 266         set_config('auth', implode(',', $auths));
 267     }
 268
 269     /**
 270      * Enable enrol_lti plugin.
 271      */
 272     protected function enable_enrol() {
 273         $enabled = enrol_get_plugins(true);
 274         $enabled['lti'] = true;
 275         $enabled = array_keys($enabled);
 276         set_config('enrol_plugins_enabled', implode(',', $enabled));
 277     }
 278 }
 279
 280 /**
 281  * Class dummy_sync_members_task.
 282  *
 283  * A class that extends sync_members so that we can expose the protected methods that we would like to test.
 284  *
 285  * @copyright 2016 Jun Pataleta <jun@moodle.com>
 286  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 287  */
 288 class dummy_sync_members_task extends sync_members {
 289     /**
 290      * Exposes/generates the dataconnector property.
 291      *
 292      * @return data_connector
 293      */
 294     public function get_dataconnector() {
 295         if (!$this->dataconnector) {
 296             $this->dataconnector = new data_connector();
 297         }
 298         return $this->dataconnector;
 299     }
 300
 301     /**
 302      * Helper method that removes an element in the array of current users.
 303      */
 304     public function pop_current_users() {
 305         array_pop($this->currentusers);
 306     }
 307
 308     /**
 309      * Exposes sync_members::do_context_membership_request()
 310      *
 311      * @param Context $context The context object.
 312      * @param ResourceLink $resourcelink The resource link object.
 313      * @param string $membershipsurltemplate The memberships endpoint URL template.
 314      * @return bool|User[] Array of User objects upon successful membership service request. False, otherwise.
 315      */
 316     public function do_context_membership_request(Context $context, ResourceLink $resourcelink = null,
 317                                                   $membershipsurltemplate = '') {
 318         $members = parent::do_context_membership_request($context, $resourcelink, $membershipsurltemplate);
 319         return $members;
 320     }
 321
 322
 323     /**
 324      * Exposes sync_members::do_resourcelink_membership_request()
 325      *
 326      * @param ResourceLink $resourcelink
 327      * @return bool|User[]
 328      */
 329     public function do_resourcelink_membership_request(ResourceLink $resourcelink) {
 330         $members = parent::do_resourcelink_membership_request($resourcelink);
 331         return $members;
 332     }
 333
 334     /**
 335      * Exposes sync_members::fetch_members_from_consumer()
 336      *
 337      * @param ToolConsumer $consumer
 338      * @return bool|User[]
 339      */
 340     public function fetch_members_from_consumer(ToolConsumer $consumer) {
 341         $members = parent::fetch_members_from_consumer($consumer);
 342         return $members;
 343     }
 344
 345     /**
 346      * Exposes sync_members::should_sync_unenrol()
 347      *
 348      * @param int $syncmode The tool's membersyncmode.
 349      * @return bool
 350      */
 351     public function should_sync_unenrol($syncmode) {
 352         $shouldsync = parent::should_sync_unenrol($syncmode);
 353         return $shouldsync;
 354     }
 355
 356     /**
 357      * Exposes sync_members::should_sync_enrol()
 358      *
 359      * @param int $syncmode The tool's membersyncmode.
 360      * @return bool
 361      */
 362     public function should_sync_enrol($syncmode) {
 363         $shouldsync = parent::should_sync_enrol($syncmode);
 364         return $shouldsync;
 365     }
 366
 367     /**
 368      * Exposes sync_members::sync_member_information()
 369      *
 370      * @param stdClass $tool
 371      * @param ToolConsumer $consumer
 372      * @param User[] $members
 373      * @return array
 374      */
 375     public function sync_member_information(stdClass $tool, ToolConsumer $consumer, $members) {
 376         $result = parent::sync_member_information($tool, $consumer, $members);
 377         return $result;
 378     }
 379
 380     /**
 381      * Exposes sync_members::sync_profile_images()
 382      *
 383      * @return int
 384      */
 385     public function sync_profile_images() {
 386         $count = parent::sync_profile_images();
 387         return $count;
 388     }
 389
 390     /**
 391      * Exposes sync_members::sync_unenrol()
 392      *
 393      * @param stdClass $tool
 394      * @return int
 395      */
 396     public function sync_unenrol(stdClass $tool) {
 397         $count = parent::sync_unenrol($tool);
 398         return $count;
 399     }
 400 }