[Summary view]

   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   * Privacy provider tests.
  19   *
  20   * @package    mod_lti
  21   * @copyright  2018 Mark Nelson <markn@moodle.com>
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  use core_privacy\local\metadata\collection;
  26  use mod_lti\privacy\provider;
  27  
  28  defined('MOODLE_INTERNAL') || die();
  29  
  30  /**
  31   * Privacy provider tests class.
  32   *
  33   * @package    mod_lti
  34   * @copyright  2018 Mark Nelson <markn@moodle.com>
  35   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36   */
  37  class mod_lti_privacy_provider_testcase extends \core_privacy\tests\provider_testcase {
  38  
  39      /**
  40       * Test for provider::get_metadata().
  41       */
  42      public function test_get_metadata() {
  43          $collection = new collection('mod_lti');
  44          $newcollection = provider::get_metadata($collection);
  45          $itemcollection = $newcollection->get_collection();
  46          $this->assertCount(4, $itemcollection);
  47  
  48          $ltiproviderexternal = array_shift($itemcollection);
  49          $this->assertEquals('lti_provider', $ltiproviderexternal->get_name());
  50  
  51          $ltisubmissiontable = array_shift($itemcollection);
  52          $this->assertEquals('lti_submission', $ltisubmissiontable->get_name());
  53  
  54          $ltitoolproxies = array_shift($itemcollection);
  55          $this->assertEquals('lti_tool_proxies', $ltitoolproxies->get_name());
  56  
  57          $ltitypestable = array_shift($itemcollection);
  58          $this->assertEquals('lti_types', $ltitypestable->get_name());
  59  
  60          $privacyfields = $ltisubmissiontable->get_privacy_fields();
  61          $this->assertArrayHasKey('userid', $privacyfields);
  62          $this->assertArrayHasKey('datesubmitted', $privacyfields);
  63          $this->assertArrayHasKey('dateupdated', $privacyfields);
  64          $this->assertArrayHasKey('gradepercent', $privacyfields);
  65          $this->assertArrayHasKey('originalgrade', $privacyfields);
  66          $this->assertEquals('privacy:metadata:lti_submission', $ltisubmissiontable->get_summary());
  67  
  68          $privacyfields = $ltitoolproxies->get_privacy_fields();
  69          $this->assertArrayHasKey('name', $privacyfields);
  70          $this->assertArrayHasKey('createdby', $privacyfields);
  71          $this->assertArrayHasKey('timecreated', $privacyfields);
  72          $this->assertArrayHasKey('timemodified', $privacyfields);
  73          $this->assertEquals('privacy:metadata:lti_tool_proxies', $ltitoolproxies->get_summary());
  74  
  75          $privacyfields = $ltitypestable->get_privacy_fields();
  76          $this->assertArrayHasKey('name', $privacyfields);
  77          $this->assertArrayHasKey('createdby', $privacyfields);
  78          $this->assertArrayHasKey('timecreated', $privacyfields);
  79          $this->assertArrayHasKey('timemodified', $privacyfields);
  80          $this->assertEquals('privacy:metadata:lti_types', $ltitypestable->get_summary());
  81      }
  82  
  83      /**
  84       * Test for provider::get_contexts_for_userid().
  85       */
  86      public function test_get_contexts_for_userid() {
  87          $this->resetAfterTest();
  88  
  89          $course = $this->getDataGenerator()->create_course();
  90  
  91          // The LTI activity the user will have submitted something for.
  92          $lti = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
  93  
  94          // Another LTI activity that has no user activity.
  95          $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
  96  
  97          // Create a user which will make a submission.
  98          $user = $this->getDataGenerator()->create_user();
  99  
 100          $this->create_lti_submission($lti->id, $user->id);
 101  
 102          // Check the contexts supplied are correct.
 103          $contextlist = provider::get_contexts_for_userid($user->id);
 104          $this->assertCount(2, $contextlist);
 105  
 106          $contextformodule = $contextlist->current();
 107          $cmcontext = context_module::instance($lti->cmid);
 108          $this->assertEquals($cmcontext->id, $contextformodule->id);
 109  
 110          $contextlist->next();
 111          $contextforsystem = $contextlist->current();
 112          $this->assertEquals(SYSCONTEXTID, $contextforsystem->id);
 113      }
 114  
 115      /**
 116       * Test for provider::test_get_users_in_context()
 117       */
 118      public function test_get_users_in_context() {
 119          $this->resetAfterTest();
 120  
 121          $course = $this->getDataGenerator()->create_course();
 122          $component = 'mod_lti';
 123  
 124          // The LTI activity the user will have submitted something for.
 125          $lti1 = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 126  
 127          // Another LTI activity that has no user activity.
 128          $lti2 = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 129  
 130          // Create user which will make a submission each.
 131          $user1 = $this->getDataGenerator()->create_user();
 132          $user2 = $this->getDataGenerator()->create_user();
 133  
 134          $this->create_lti_submission($lti1->id, $user1->id);
 135          $this->create_lti_submission($lti1->id, $user2->id);
 136  
 137          $context = context_module::instance($lti1->cmid);
 138          $userlist = new \core_privacy\local\request\userlist($context, $component);
 139          provider::get_users_in_context($userlist);
 140  
 141          $this->assertCount(2, $userlist);
 142          $expected = [$user1->id, $user2->id];
 143          $actual = $userlist->get_userids();
 144          sort($expected);
 145          sort($actual);
 146  
 147          $this->assertEquals($expected, $actual);
 148  
 149          $context = context_module::instance($lti2->cmid);
 150          $userlist = new \core_privacy\local\request\userlist($context, $component);
 151          provider::get_users_in_context($userlist);
 152  
 153          $this->assertEmpty($userlist);
 154      }
 155  
 156      /**
 157       * Test for provider::export_user_data().
 158       */
 159      public function test_export_for_context_submissions() {
 160          $this->resetAfterTest();
 161  
 162          $course = $this->getDataGenerator()->create_course();
 163  
 164          $lti = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 165  
 166          // Create users which will make submissions.
 167          $user1 = $this->getDataGenerator()->create_user();
 168          $user2 = $this->getDataGenerator()->create_user();
 169  
 170          $this->create_lti_submission($lti->id, $user1->id);
 171          $this->create_lti_submission($lti->id, $user1->id);
 172          $this->create_lti_submission($lti->id, $user2->id);
 173  
 174          // Export all of the data for the context for user 1.
 175          $cmcontext = context_module::instance($lti->cmid);
 176          $this->export_context_data_for_user($user1->id, $cmcontext, 'mod_lti');
 177          $writer = \core_privacy\local\request\writer::with_context($cmcontext);
 178  
 179          $this->assertTrue($writer->has_any_data());
 180  
 181          $data = $writer->get_data();
 182          $this->assertCount(2, $data->submissions);
 183      }
 184  
 185      /**
 186       * Test for provider::export_user_data().
 187       */
 188      public function test_export_for_context_tool_types() {
 189          $this->resetAfterTest();
 190  
 191          $course1 = $this->getDataGenerator()->create_course();
 192          $course2 = $this->getDataGenerator()->create_course();
 193  
 194          // Create a user which will make a tool type.
 195          $user = $this->getDataGenerator()->create_user();
 196          $this->setUser($user);
 197  
 198          // Create a user that will not make a tool type.
 199          $this->getDataGenerator()->create_user();
 200  
 201          $type = new stdClass();
 202          $type->baseurl = 'http://moodle.org';
 203          $type->course = $course1->id;
 204          lti_add_type($type, new stdClass());
 205  
 206          $type = new stdClass();
 207          $type->baseurl = 'http://moodle.org';
 208          $type->course = $course1->id;
 209          lti_add_type($type, new stdClass());
 210  
 211          $type = new stdClass();
 212          $type->baseurl = 'http://moodle.org';
 213          $type->course = $course2->id;
 214          lti_add_type($type, new stdClass());
 215  
 216          // Export all of the data for the context.
 217          $coursecontext = context_course::instance($course1->id);
 218          $this->export_context_data_for_user($user->id, $coursecontext, 'mod_lti');
 219          $writer = \core_privacy\local\request\writer::with_context($coursecontext);
 220  
 221          $this->assertTrue($writer->has_any_data());
 222  
 223          $data = $writer->get_data();
 224          $this->assertCount(2, $data->lti_types);
 225  
 226          $coursecontext = context_course::instance($course2->id);
 227          $this->export_context_data_for_user($user->id, $coursecontext, 'mod_lti');
 228          $writer = \core_privacy\local\request\writer::with_context($coursecontext);
 229  
 230          $this->assertTrue($writer->has_any_data());
 231  
 232          $data = $writer->get_data();
 233          $this->assertCount(1, $data->lti_types);
 234      }
 235  
 236      /**
 237       * Test for provider::export_user_data().
 238       */
 239      public function test_export_for_context_tool_proxies() {
 240          $this->resetAfterTest();
 241  
 242          // Create a user that will not make a tool proxy.
 243          $user = $this->getDataGenerator()->create_user();
 244          $this->setUser($user);
 245  
 246          $toolproxy = new stdClass();
 247          $toolproxy->createdby = $user;
 248          lti_add_tool_proxy($toolproxy);
 249  
 250          // Export all of the data for the context.
 251          $systemcontext = context_system::instance();
 252          $this->export_context_data_for_user($user->id, $systemcontext, 'mod_lti');
 253          $writer = \core_privacy\local\request\writer::with_context($systemcontext);
 254  
 255          $this->assertTrue($writer->has_any_data());
 256  
 257          $data = $writer->get_data();
 258          $this->assertCount(1, $data->lti_tool_proxies);
 259      }
 260  
 261      /**
 262       * Test for provider::delete_data_for_all_users_in_context().
 263       */
 264      public function test_delete_data_for_all_users_in_context() {
 265          global $DB;
 266  
 267          $this->resetAfterTest();
 268  
 269          $course = $this->getDataGenerator()->create_course();
 270  
 271          $lti = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 272  
 273          // Create users that will make submissions.
 274          $user1 = $this->getDataGenerator()->create_user();
 275          $user2 = $this->getDataGenerator()->create_user();
 276  
 277          $this->create_lti_submission($lti->id, $user1->id);
 278          $this->create_lti_submission($lti->id, $user2->id);
 279  
 280          // Before deletion, we should have 2 responses.
 281          $count = $DB->count_records('lti_submission', ['ltiid' => $lti->id]);
 282          $this->assertEquals(2, $count);
 283  
 284          // Delete data based on context.
 285          $cmcontext = context_module::instance($lti->cmid);
 286          provider::delete_data_for_all_users_in_context($cmcontext);
 287  
 288          // After deletion, the lti submissions for that lti activity should have been deleted.
 289          $count = $DB->count_records('lti_submission', ['ltiid' => $lti->id]);
 290          $this->assertEquals(0, $count);
 291      }
 292  
 293      /**
 294       * Test for provider::delete_data_for_user().
 295       */
 296      public function test_delete_data_for_user() {
 297          global $DB;
 298  
 299          $this->resetAfterTest();
 300  
 301          $course = $this->getDataGenerator()->create_course();
 302  
 303          $lti = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 304  
 305          // Create users that will make submissions.
 306          $user1 = $this->getDataGenerator()->create_user();
 307          $user2 = $this->getDataGenerator()->create_user();
 308  
 309          $this->create_lti_submission($lti->id, $user1->id);
 310          $this->create_lti_submission($lti->id, $user2->id);
 311  
 312          // Before deletion we should have 2 responses.
 313          $count = $DB->count_records('lti_submission', ['ltiid' => $lti->id]);
 314          $this->assertEquals(2, $count);
 315  
 316          $context = \context_module::instance($lti->cmid);
 317          $contextlist = new \core_privacy\local\request\approved_contextlist($user1, 'lti',
 318              [context_system::instance()->id, $context->id]);
 319          provider::delete_data_for_user($contextlist);
 320  
 321          // After deletion the lti submission for the first user should have been deleted.
 322          $count = $DB->count_records('lti_submission', ['ltiid' => $lti->id, 'userid' => $user1->id]);
 323          $this->assertEquals(0, $count);
 324  
 325          // Check the submission for the other user is still there.
 326          $ltisubmission = $DB->get_records('lti_submission');
 327          $this->assertCount(1, $ltisubmission);
 328          $lastsubmission = reset($ltisubmission);
 329          $this->assertEquals($user2->id, $lastsubmission->userid);
 330      }
 331  
 332      /**
 333       * Test for provider::delete_data_for_users().
 334       */
 335      public function test_delete_data_for_users() {
 336          global $DB;
 337          $component = 'mod_lti';
 338  
 339          $this->resetAfterTest();
 340  
 341          $course = $this->getDataGenerator()->create_course();
 342  
 343          $lti = $this->getDataGenerator()->create_module('lti', array('course' => $course->id));
 344  
 345          // Create users that will make submissions.
 346          $user1 = $this->getDataGenerator()->create_user();
 347          $user2 = $this->getDataGenerator()->create_user();
 348          $user3 = $this->getDataGenerator()->create_user();
 349  
 350          $this->create_lti_submission($lti->id, $user1->id);
 351          $this->create_lti_submission($lti->id, $user2->id);
 352          $this->create_lti_submission($lti->id, $user3->id);
 353  
 354          // Before deletion we should have 2 responses.
 355          $count = $DB->count_records('lti_submission', ['ltiid' => $lti->id]);
 356          $this->assertEquals(3, $count);
 357  
 358          $context = \context_module::instance($lti->cmid);
 359          $approveduserids = [$user1->id, $user2->id];
 360          $approvedlist = new core_privacy\local\request\approved_userlist($context, $component, $approveduserids);
 361          provider::delete_data_for_users($approvedlist);
 362  
 363          // After deletion the lti submission for the first two users should have been deleted.
 364          list($insql, $inparams) = $DB->get_in_or_equal($approveduserids, SQL_PARAMS_NAMED);
 365          $sql = "ltiid = :ltiid AND userid {$insql}";
 366          $params = array_merge($inparams, ['ltiid' => $lti->id]);
 367          $count = $DB->count_records_select('lti_submission', $sql, $params);
 368          $this->assertEquals(0, $count);
 369  
 370          // Check the submission for the third user is still there.
 371          $ltisubmission = $DB->get_records('lti_submission');
 372          $this->assertCount(1, $ltisubmission);
 373          $lastsubmission = reset($ltisubmission);
 374          $this->assertEquals($user3->id, $lastsubmission->userid);
 375      }
 376  
 377      /**
 378       * Mimicks the creation of an LTI submission.
 379       *
 380       * There is no API we can use to insert an LTI submission, so we
 381       * will simply insert directly into the database.
 382       *
 383       * @param int $ltiid
 384       * @param int $userid
 385       */
 386      protected function create_lti_submission(int $ltiid, int $userid) {
 387          global $DB;
 388  
 389          $ltisubmissiondata = [
 390              'ltiid' => $ltiid,
 391              'userid' => $userid,
 392              'datesubmitted' => time(),
 393              'dateupdated' => time(),
 394              'gradepercent' => 65,
 395              'originalgrade' => 70,
 396              'launchid' => 3,
 397              'state' => 1
 398          ];
 399  
 400          $DB->insert_record('lti_submission', $ltisubmissiondata);
 401      }
 402  }