backup/tests/privacy_provider_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  * Privacy provider tests.
  19  *
  20  * @package    core_backup
  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_backup\privacy\provider;
  26 use core_privacy\local\request\approved_userlist;
  27
  28 defined('MOODLE_INTERNAL') || die();
  29
  30 /**
  31  * Privacy provider tests class.
  32  *
  33  * @copyright  2018 Mark Nelson <markn@moodle.com>
  34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  35  */
  36 class core_backup_privacy_provider_testcase extends \core_privacy\tests\provider_testcase {
  37
  38     /**
  39      * Test getting the context for the user ID related to this plugin.
  40      */
  41     public function test_get_contexts_for_userid() {
  42         global $DB;
  43
  44         $this->resetAfterTest();
  45
  46         $course = $this->getDataGenerator()->create_course();
  47         $user = $this->getDataGenerator()->create_user();
  48
  49         // Just insert directly into the 'backup_controllers' table.
  50         $bcdata = (object) [
  51             'backupid' => 1,
  52             'operation' => 'restore',
  53             'type' => 'course',
  54             'itemid' => $course->id,
  55             'format' => 'moodle2',
  56             'interactive' => 1,
  57             'purpose' => 10,
  58             'userid' => $user->id,
  59             'status' => 1000,
  60             'execution' => 1,
  61             'executiontime' => 0,
  62             'checksum' => 'checksumyolo',
  63             'timecreated' => time(),
  64             'timemodified' => time(),
  65             'controller' => ''
  66         ];
  67         $DB->insert_record('backup_controllers', $bcdata);
  68
  69         $contextlist = provider::get_contexts_for_userid($user->id);
  70         $this->assertCount(1, $contextlist);
  71         $contextforuser = $contextlist->current();
  72         $context = context_course::instance($course->id);
  73         $this->assertEquals($context->id, $contextforuser->id);
  74     }
  75
  76     /**
  77      * Test for provider::export_user_data().
  78      */
  79     public function test_export_for_context() {
  80         global $DB;
  81
  82         $this->resetAfterTest();
  83
  84         $course = $this->getDataGenerator()->create_course();
  85         $user1 = $this->getDataGenerator()->create_user();
  86
  87         // Just insert directly into the 'backup_controllers' table.
  88         $bcdata1 = (object) [
  89             'backupid' => 1,
  90             'operation' => 'restore',
  91             'type' => 'course',
  92             'itemid' => $course->id,
  93             'format' => 'moodle2',
  94             'interactive' => 1,
  95             'purpose' => 10,
  96             'userid' => $user1->id,
  97             'status' => 1000,
  98             'execution' => 1,
  99             'executiontime' => 0,
 100             'checksum' => 'checksumyolo',
 101             'timecreated' => time(),
 102             'timemodified' => time(),
 103             'controller' => ''
 104         ];
 105         $DB->insert_record('backup_controllers', $bcdata1);
 106
 107         // Create another user who will perform a backup operation.
 108         $user2 = $this->getDataGenerator()->create_user();
 109         $bcdata2 = (object) [
 110             'backupid' => 2,
 111             'operation' => 'restore',
 112             'type' => 'course',
 113             'itemid' => $course->id,
 114             'format' => 'moodle2',
 115             'interactive' => 1,
 116             'purpose' => 10,
 117             'userid' => $user2->id,
 118             'status' => 1000,
 119             'execution' => 1,
 120             'executiontime' => 0,
 121             'checksum' => 'checksumyolo',
 122             'timecreated' => time(),
 123             'timemodified' => time(),
 124             'controller' => ''
 125         ];
 126         $DB->insert_record('backup_controllers', $bcdata2);
 127
 128         // Create another backup_controllers record.
 129         $bcdata3 = (object) [
 130             'backupid' => 3,
 131             'operation' => 'backup',
 132             'type' => 'course',
 133             'itemid' => $course->id,
 134             'format' => 'moodle2',
 135             'interactive' => 1,
 136             'purpose' => 10,
 137             'userid' => $user1->id,
 138             'status' => 1000,
 139             'execution' => 1,
 140             'executiontime' => 0,
 141             'checksum' => 'checksumyolo',
 142             'timecreated' => time() + DAYSECS,
 143             'timemodified' => time() + DAYSECS,
 144             'controller' => ''
 145         ];
 146         $DB->insert_record('backup_controllers', $bcdata3);
 147
 148         $coursecontext = context_course::instance($course->id);
 149
 150         // Export all of the data for the context.
 151         $this->export_context_data_for_user($user1->id, $coursecontext, 'core_backup');
 152         $writer = \core_privacy\local\request\writer::with_context($coursecontext);
 153         $this->assertTrue($writer->has_any_data());
 154
 155         $data = (array) $writer->get_data([get_string('backup'), $course->id]);
 156
 157         $this->assertCount(2, $data);
 158
 159         $bc1 = array_shift($data);
 160         $this->assertEquals('restore', $bc1['operation']);
 161
 162         $bc2 = array_shift($data);
 163         $this->assertEquals('backup', $bc2['operation']);
 164     }
 165
 166     /**
 167      * Test for provider::delete_data_for_all_users_in_context().
 168      */
 169     public function test_delete_data_for_all_users_in_context() {
 170         global $DB;
 171
 172         $this->resetAfterTest();
 173
 174         $course = $this->getDataGenerator()->create_course();
 175         $user1 = $this->getDataGenerator()->create_user();
 176
 177         // Just insert directly into the 'backup_controllers' table.
 178         $bcdata1 = (object) [
 179             'backupid' => 1,
 180             'operation' => 'restore',
 181             'type' => 'course',
 182             'itemid' => $course->id,
 183             'format' => 'moodle2',
 184             'interactive' => 1,
 185             'purpose' => 10,
 186             'userid' => $user1->id,
 187             'status' => 1000,
 188             'execution' => 1,
 189             'executiontime' => 0,
 190             'checksum' => 'checksumyolo',
 191             'timecreated' => time(),
 192             'timemodified' => time(),
 193             'controller' => ''
 194         ];
 195         $DB->insert_record('backup_controllers', $bcdata1);
 196
 197         // Create another user who will perform a backup operation.
 198         $user2 = $this->getDataGenerator()->create_user();
 199         $bcdata2 = (object) [
 200             'backupid' => 2,
 201             'operation' => 'restore',
 202             'type' => 'course',
 203             'itemid' => $course->id,
 204             'format' => 'moodle2',
 205             'interactive' => 1,
 206             'purpose' => 10,
 207             'userid' => $user2->id,
 208             'status' => 1000,
 209             'execution' => 1,
 210             'executiontime' => 0,
 211             'checksum' => 'checksumyolo',
 212             'timecreated' => time(),
 213             'timemodified' => time(),
 214             'controller' => ''
 215         ];
 216         $DB->insert_record('backup_controllers', $bcdata2);
 217
 218         // Before deletion, we should have 2 operations.
 219         $count = $DB->count_records('backup_controllers', ['itemid' => $course->id]);
 220         $this->assertEquals(2, $count);
 221
 222         // Delete data based on context.
 223         $coursecontext = context_course::instance($course->id);
 224         provider::delete_data_for_all_users_in_context($coursecontext);
 225
 226         // After deletion, the operations for that course should have been deleted.
 227         $count = $DB->count_records('backup_controllers', ['itemid' => $course->id]);
 228         $this->assertEquals(0, $count);
 229     }
 230
 231     /**
 232      * Test for provider::delete_data_for_user().
 233      */
 234     public function test_delete_data_for_user() {
 235         global $DB;
 236
 237         $this->resetAfterTest();
 238
 239         $course = $this->getDataGenerator()->create_course();
 240         $user1 = $this->getDataGenerator()->create_user();
 241
 242         // Just insert directly into the 'backup_controllers' table.
 243         $bcdata1 = (object) [
 244             'backupid' => 1,
 245             'operation' => 'restore',
 246             'type' => 'course',
 247             'itemid' => $course->id,
 248             'format' => 'moodle2',
 249             'interactive' => 1,
 250             'purpose' => 10,
 251             'userid' => $user1->id,
 252             'status' => 1000,
 253             'execution' => 1,
 254             'executiontime' => 0,
 255             'checksum' => 'checksumyolo',
 256             'timecreated' => time(),
 257             'timemodified' => time(),
 258             'controller' => ''
 259         ];
 260         $DB->insert_record('backup_controllers', $bcdata1);
 261
 262         // Create another user who will perform a backup operation.
 263         $user2 = $this->getDataGenerator()->create_user();
 264         $bcdata2 = (object) [
 265             'backupid' => 2,
 266             'operation' => 'restore',
 267             'type' => 'course',
 268             'itemid' => $course->id,
 269             'format' => 'moodle2',
 270             'interactive' => 1,
 271             'purpose' => 10,
 272             'userid' => $user2->id,
 273             'status' => 1000,
 274             'execution' => 1,
 275             'executiontime' => 0,
 276             'checksum' => 'checksumyolo',
 277             'timecreated' => time(),
 278             'timemodified' => time(),
 279             'controller' => ''
 280         ];
 281         $DB->insert_record('backup_controllers', $bcdata2);
 282
 283         // Before deletion, we should have 2 operations.
 284         $count = $DB->count_records('backup_controllers', ['itemid' => $course->id]);
 285         $this->assertEquals(2, $count);
 286
 287         $coursecontext = context_course::instance($course->id);
 288         $contextlist = new \core_privacy\local\request\approved_contextlist($user1, 'core_backup',
 289             [context_system::instance()->id, $coursecontext->id]);
 290         provider::delete_data_for_user($contextlist);
 291
 292         // After deletion, the backup operation for the user should have been deleted.
 293         $count = $DB->count_records('backup_controllers', ['itemid' => $course->id, 'userid' => $user1->id]);
 294         $this->assertEquals(0, $count);
 295
 296         // Confirm we still have the other users record.
 297         $bcs = $DB->get_records('backup_controllers');
 298         $this->assertCount(1, $bcs);
 299         $lastsubmission = reset($bcs);
 300         $this->assertNotEquals($user1->id, $lastsubmission->userid);
 301     }
 302
 303     /**
 304      * Test that only users with a course and module context are fetched.
 305      */
 306     public function test_get_users_in_context() {
 307         global $DB;
 308
 309         $this->resetAfterTest();
 310
 311         $component = 'core_backup';
 312
 313         $course = $this->getDataGenerator()->create_course();
 314         $activity = $this->getDataGenerator()->create_module('chat', ['course' => $course->id]);
 315
 316         $user = $this->getDataGenerator()->create_user();
 317         $user2 = $this->getDataGenerator()->create_user();
 318
 319         $coursecontext = context_course::instance($course->id);
 320         $activitycontext = \context_module::instance($activity->cmid);
 321
 322         // The list of users for course context should return the user.
 323         $userlist = new \core_privacy\local\request\userlist($coursecontext, $component);
 324         provider::get_users_in_context($userlist);
 325         $this->assertCount(0, $userlist);
 326
 327         // Create a course backup.
 328         // Just insert directly into the 'backup_controllers' table.
 329         $bcdata = (object) [
 330             'backupid' => 1,
 331             'operation' => 'restore',
 332             'type' => 'course',
 333             'itemid' => $course->id,
 334             'format' => 'moodle2',
 335             'interactive' => 1,
 336             'purpose' => 10,
 337             'userid' => $user->id,
 338             'status' => 1000,
 339             'execution' => 1,
 340             'executiontime' => 0,
 341             'checksum' => 'checksumyolo',
 342             'timecreated' => time(),
 343             'timemodified' => time(),
 344             'controller' => ''
 345         ];
 346
 347         $DB->insert_record('backup_controllers', $bcdata);
 348
 349         // The list of users for the course context should return user.
 350         provider::get_users_in_context($userlist);
 351         $this->assertCount(1, $userlist);
 352         $expected = [$user->id];
 353         $actual = $userlist->get_userids();
 354         $this->assertEquals($expected, $actual);
 355
 356         // Create an activity backup.
 357         // Just insert directly into the 'backup_controllers' table.
 358         $bcdata = (object) [
 359             'backupid' => 2,
 360             'operation' => 'restore',
 361             'type' => 'activity',
 362             'itemid' => $activity->cmid,
 363             'format' => 'moodle2',
 364             'interactive' => 1,
 365             'purpose' => 10,
 366             'userid' => $user2->id,
 367             'status' => 1000,
 368             'execution' => 1,
 369             'executiontime' => 0,
 370             'checksum' => 'checksumyolo',
 371             'timecreated' => time(),
 372             'timemodified' => time(),
 373             'controller' => ''
 374         ];
 375
 376         $DB->insert_record('backup_controllers', $bcdata);
 377
 378         // The list of users for the course context should return user2.
 379         $userlist = new \core_privacy\local\request\userlist($activitycontext, $component);
 380         provider::get_users_in_context($userlist);
 381         $this->assertCount(1, $userlist);
 382         $expected = [$user2->id];
 383         $actual = $userlist->get_userids();
 384         $this->assertEquals($expected, $actual);
 385
 386         // The list of users for system context should not return any users.
 387         $systemcontext = context_system::instance();
 388         $userlist = new \core_privacy\local\request\userlist($systemcontext, $component);
 389         provider::get_users_in_context($userlist);
 390         $this->assertCount(0, $userlist);
 391     }
 392
 393     /**
 394      * Test that data for users in approved userlist is deleted.
 395      */
 396     public function test_delete_data_for_users() {
 397         global $DB;
 398
 399         $this->resetAfterTest();
 400
 401         $component = 'core_backup';
 402
 403         // Create course1.
 404         $course1 = $this->getDataGenerator()->create_course();
 405         $coursecontext = context_course::instance($course1->id);
 406         // Create course2.
 407         $course2 = $this->getDataGenerator()->create_course();
 408         $coursecontext2 = context_course::instance($course2->id);
 409         // Create an activity.
 410         $activity = $this->getDataGenerator()->create_module('chat', ['course' => $course1->id]);
 411         $activitycontext = \context_module::instance($activity->cmid);
 412         // Create user1.
 413         $user1 = $this->getDataGenerator()->create_user();
 414         // Create user2.
 415         $user2 = $this->getDataGenerator()->create_user();
 416         // Create user2.
 417         $user3 = $this->getDataGenerator()->create_user();
 418
 419         // Just insert directly into the 'backup_controllers' table.
 420         $bcdata1 = (object) [
 421             'backupid' => 1,
 422             'operation' => 'restore',
 423             'type' => 'course',
 424             'itemid' => $course1->id,
 425             'format' => 'moodle2',
 426             'interactive' => 1,
 427             'purpose' => 10,
 428             'userid' => $user1->id,
 429             'status' => 1000,
 430             'execution' => 1,
 431             'executiontime' => 0,
 432             'checksum' => 'checksumyolo',
 433             'timecreated' => time(),
 434             'timemodified' => time(),
 435             'controller' => ''
 436         ];
 437         $DB->insert_record('backup_controllers', $bcdata1);
 438
 439         // Just insert directly into the 'backup_controllers' table.
 440         $bcdata2 = (object) [
 441             'backupid' => 2,
 442             'operation' => 'backup',
 443             'type' => 'course',
 444             'itemid' => $course1->id,
 445             'format' => 'moodle2',
 446             'interactive' => 1,
 447             'purpose' => 10,
 448             'userid' => $user2->id,
 449             'status' => 1000,
 450             'execution' => 1,
 451             'executiontime' => 0,
 452             'checksum' => 'checksumyolo',
 453             'timecreated' => time(),
 454             'timemodified' => time(),
 455             'controller' => ''
 456         ];
 457         $DB->insert_record('backup_controllers', $bcdata2);
 458
 459         // Just insert directly into the 'backup_controllers' table.
 460         $bcdata3 = (object) [
 461             'backupid' => 3,
 462             'operation' => 'restore',
 463             'type' => 'activity',
 464             'itemid' => $activity->cmid,
 465             'format' => 'moodle2',
 466             'interactive' => 1,
 467             'purpose' => 10,
 468             'userid' => $user3->id,
 469             'status' => 1000,
 470             'execution' => 1,
 471             'executiontime' => 0,
 472             'checksum' => 'checksumyolo',
 473             'timecreated' => time(),
 474             'timemodified' => time(),
 475             'controller' => ''
 476         ];
 477         $DB->insert_record('backup_controllers', $bcdata3);
 478
 479         // The list of users for coursecontext should return user1 and user2.
 480         $userlist1 = new \core_privacy\local\request\userlist($coursecontext, $component);
 481         provider::get_users_in_context($userlist1);
 482         $this->assertCount(2, $userlist1);
 483         $expected = [$user1->id, $user2->id];
 484         $actual = $userlist1->get_userids();
 485         $this->assertEquals($expected, $actual, '', 0.0, 10, true);
 486
 487         // The list of users for coursecontext2 should not return users.
 488         $userlist2 = new \core_privacy\local\request\userlist($coursecontext2, $component);
 489         provider::get_users_in_context($userlist2);
 490         $this->assertCount(0, $userlist2);
 491
 492         // The list of users for activitycontext should return user3.
 493         $userlist3 = new \core_privacy\local\request\userlist($activitycontext, $component);
 494         provider::get_users_in_context($userlist3);
 495         $this->assertCount(1, $userlist3);
 496         $expected = [$user3->id];
 497         $actual = $userlist3->get_userids();
 498         $this->assertEquals($expected, $actual);
 499
 500         // Add user1 to the approved user list.
 501         $approvedlist = new approved_userlist($coursecontext, $component, [$user1->id]);
 502         // Delete user data using delete_data_for_user for usercontext1.
 503         provider::delete_data_for_users($approvedlist);
 504
 505         // Re-fetch users in coursecontext - The user list should now return only user2.
 506         $userlist1 = new \core_privacy\local\request\userlist($coursecontext, $component);
 507         provider::get_users_in_context($userlist1);
 508         $this->assertCount(1, $userlist1);
 509         $expected = [$user2->id];
 510         $actual = $userlist1->get_userids();
 511         $this->assertEquals($expected, $actual);
 512
 513         // Re-fetch users in activitycontext - The user list should not be empty (user3).
 514         $userlist3 = new \core_privacy\local\request\userlist($activitycontext, $component);
 515         provider::get_users_in_context($userlist3);
 516         $this->assertCount(1, $userlist3);
 517
 518         // Add user1 to the approved user list.
 519         $approvedlist = new approved_userlist($activitycontext, $component, [$user3->id]);
 520         // Delete user data using delete_data_for_user for usercontext1.
 521         provider::delete_data_for_users($approvedlist);
 522
 523         // Re-fetch users in activitycontext - The user list should not return any users.
 524         $userlist3 = new \core_privacy\local\request\userlist($activitycontext, $component);
 525         provider::get_users_in_context($userlist3);
 526         $this->assertCount(0, $userlist3);
 527
 528         // User data should be only removed in the course context and module context.
 529         $systemcontext = context_system::instance();
 530         // Add userlist2 to the approved user list in the system context.
 531         $approvedlist = new approved_userlist($systemcontext, $component, $userlist2->get_userids());
 532         // Delete user1 data using delete_data_for_user.
 533         provider::delete_data_for_users($approvedlist);
 534         // Re-fetch users in usercontext2 - The user list should not be empty (user2).
 535         $userlist2 = new \core_privacy\local\request\userlist($coursecontext, $component);
 536         provider::get_users_in_context($userlist2);
 537         $this->assertCount(1, $userlist2);
 538     }
 539 }