Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.

Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 38 and 311] [Versions 39 and 311]

   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  namespace tool_dataprivacy;
  18  
  19  /**
  20   * Expired contexts tests.
  21   *
  22   * @package    tool_dataprivacy
  23   * @copyright  2018 David Monllao
  24   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  25   */
  26  class expired_contexts_test extends \advanced_testcase {
  27  
  28      /**
  29       * Setup the basics with the specified retention period.
  30       *
  31       * @param   string  $system Retention policy for the system.
  32       * @param   string  $user Retention policy for users.
  33       * @param   string  $course Retention policy for courses.
  34       * @param   string  $activity Retention policy for activities.
  35       */
  36      protected function setup_basics(string $system, string $user, string $course = null, string $activity = null) : \stdClass {
  37          $this->resetAfterTest();
  38  
  39          $purposes = (object) [
  40              'system' => $this->create_and_set_purpose_for_contextlevel($system, CONTEXT_SYSTEM),
  41              'user' => $this->create_and_set_purpose_for_contextlevel($user, CONTEXT_USER),
  42          ];
  43  
  44          if (null !== $course) {
  45              $purposes->course = $this->create_and_set_purpose_for_contextlevel($course, CONTEXT_COURSE);
  46          }
  47  
  48          if (null !== $activity) {
  49              $purposes->activity = $this->create_and_set_purpose_for_contextlevel($activity, CONTEXT_MODULE);
  50          }
  51  
  52          return $purposes;
  53      }
  54  
  55      /**
  56       * Create a retention period and set it for the specified context level.
  57       *
  58       * @param   string  $retention
  59       * @param   int     $contextlevel
  60       * @return  purpose
  61       */
  62      protected function create_and_set_purpose_for_contextlevel(string $retention, int $contextlevel) : purpose {
  63          $purpose = new purpose(0, (object) [
  64              'name' => 'Test purpose ' . rand(1, 1000),
  65              'retentionperiod' => $retention,
  66              'lawfulbases' => 'gdpr_art_6_1_a',
  67          ]);
  68          $purpose->create();
  69  
  70          $cat = new category(0, (object) ['name' => 'Test category']);
  71          $cat->create();
  72  
  73          if ($contextlevel <= CONTEXT_USER) {
  74              $record = (object) [
  75                  'purposeid'     => $purpose->get('id'),
  76                  'categoryid'    => $cat->get('id'),
  77                  'contextlevel'  => $contextlevel,
  78              ];
  79              api::set_contextlevel($record);
  80          } else {
  81              list($purposevar, ) = data_registry::var_names_from_context(
  82                      \context_helper::get_class_for_level($contextlevel)
  83                  );
  84              set_config($purposevar, $purpose->get('id'), 'tool_dataprivacy');
  85          }
  86  
  87          return $purpose;
  88      }
  89  
  90      /**
  91       * Ensure that a user with no lastaccess is not flagged for deletion.
  92       */
  93      public function test_flag_not_setup() {
  94          $this->resetAfterTest();
  95  
  96          $user = $this->getDataGenerator()->create_user();
  97  
  98          $this->setUser($user);
  99          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 100          $context = \context_block::instance($block->instance->id);
 101          $this->setUser();
 102  
 103          // Flag all expired contexts.
 104          $manager = new \tool_dataprivacy\expired_contexts_manager();
 105          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 106  
 107          $this->assertEquals(0, $flaggedcourses);
 108          $this->assertEquals(0, $flaggedusers);
 109      }
 110  
 111      /**
 112       * Ensure that a user with no lastaccess is not flagged for deletion.
 113       */
 114      public function test_flag_user_no_lastaccess() {
 115          $this->resetAfterTest();
 116  
 117          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 118  
 119          $user = $this->getDataGenerator()->create_user();
 120  
 121          $this->setUser($user);
 122          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 123          $context = \context_block::instance($block->instance->id);
 124          $this->setUser();
 125  
 126          // Flag all expired contexts.
 127          $manager = new \tool_dataprivacy\expired_contexts_manager();
 128          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 129  
 130          $this->assertEquals(0, $flaggedcourses);
 131          $this->assertEquals(0, $flaggedusers);
 132      }
 133  
 134      /**
 135       * Ensure that a user with a recent lastaccess is not flagged for deletion.
 136       */
 137      public function test_flag_user_recent_lastaccess() {
 138          $this->resetAfterTest();
 139  
 140          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 141  
 142          $user = $this->getDataGenerator()->create_user(['lastaccess' => time()]);
 143  
 144          $this->setUser($user);
 145          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 146          $context = \context_block::instance($block->instance->id);
 147          $this->setUser();
 148  
 149          // Flag all expired contexts.
 150          $manager = new \tool_dataprivacy\expired_contexts_manager();
 151          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 152  
 153          $this->assertEquals(0, $flaggedcourses);
 154          $this->assertEquals(0, $flaggedusers);
 155      }
 156  
 157      /**
 158       * Ensure that a user with a lastaccess in the past is flagged for deletion.
 159       */
 160      public function test_flag_user_past_lastaccess() {
 161          $this->resetAfterTest();
 162  
 163          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 164  
 165          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 166  
 167          $this->setUser($user);
 168          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 169          $context = \context_block::instance($block->instance->id);
 170          $this->setUser();
 171  
 172          // Flag all expired contexts.
 173          $manager = new \tool_dataprivacy\expired_contexts_manager();
 174          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 175  
 176          // Although there is a block in the user context, everything in the user context is regarded as one.
 177          $this->assertEquals(0, $flaggedcourses);
 178          $this->assertEquals(1, $flaggedusers);
 179      }
 180  
 181      /**
 182       * Ensure that a user with a lastaccess in the past but active enrolments is not flagged for deletion.
 183       */
 184      public function test_flag_user_past_lastaccess_still_enrolled() {
 185          $this->resetAfterTest();
 186  
 187          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 188  
 189          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 190          $course = $this->getDataGenerator()->create_course(['startdate' => time(), 'enddate' => time() + YEARSECS]);
 191          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
 192  
 193          $otheruser = $this->getDataGenerator()->create_user();
 194          $this->getDataGenerator()->enrol_user($otheruser->id, $course->id, 'student');
 195  
 196          $this->setUser($user);
 197          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 198          $context = \context_block::instance($block->instance->id);
 199          $this->setUser();
 200  
 201          // Flag all expired contexts.
 202          $manager = new \tool_dataprivacy\expired_contexts_manager();
 203          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 204  
 205          $this->assertEquals(0, $flaggedcourses);
 206          $this->assertEquals(0, $flaggedusers);
 207      }
 208  
 209      /**
 210       * Ensure that a user with a lastaccess in the past and no active enrolments is flagged for deletion.
 211       */
 212      public function test_flag_user_update_existing() {
 213          $this->resetAfterTest();
 214  
 215          $this->setup_basics('PT1H', 'PT1H', 'P5Y');
 216  
 217          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 218          $usercontext = \context_user::instance($user->id);
 219  
 220          // Create an existing expired_context.
 221          $expiredcontext = new expired_context(0, (object) [
 222                  'contextid' => $usercontext->id,
 223                  'defaultexpired' => 0,
 224                  'status' => expired_context::STATUS_EXPIRED,
 225              ]);
 226          $expiredcontext->save();
 227          $this->assertEquals(0, $expiredcontext->get('defaultexpired'));
 228  
 229          // Flag all expired contexts.
 230          $manager = new \tool_dataprivacy\expired_contexts_manager();
 231          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 232  
 233          $this->assertEquals(0, $flaggedcourses);
 234          $this->assertEquals(1, $flaggedusers);
 235  
 236          // The user context will now have expired.
 237          $updatedcontext = new expired_context($expiredcontext->get('id'));
 238          $this->assertEquals(1, $updatedcontext->get('defaultexpired'));
 239      }
 240  
 241      /**
 242       * Ensure that a user with a lastaccess in the past and expired enrolments.
 243       */
 244      public function test_flag_user_past_lastaccess_unexpired_past_enrolment() {
 245          $this->resetAfterTest();
 246  
 247          $this->setup_basics('PT1H', 'PT1H', 'P1Y');
 248  
 249          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 250          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
 251          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
 252  
 253          $otheruser = $this->getDataGenerator()->create_user();
 254          $this->getDataGenerator()->enrol_user($otheruser->id, $course->id, 'student');
 255  
 256          $this->setUser($user);
 257          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 258          $context = \context_block::instance($block->instance->id);
 259          $this->setUser();
 260  
 261          // Flag all expired contexts.
 262          $manager = new \tool_dataprivacy\expired_contexts_manager();
 263          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 264  
 265          $this->assertEquals(0, $flaggedcourses);
 266          $this->assertEquals(0, $flaggedusers);
 267      }
 268  
 269      /**
 270       * Ensure that a user with a lastaccess in the past and expired enrolments.
 271       */
 272      public function test_flag_user_past_override_role() {
 273          global $DB;
 274          $this->resetAfterTest();
 275  
 276          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 277  
 278          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 279          $usercontext = \context_user::instance($user->id);
 280          $systemcontext = \context_system::instance();
 281  
 282          $role = $DB->get_record('role', ['shortname' => 'manager']);
 283  
 284          $override = new purpose_override(0, (object) [
 285                  'purposeid' => $purposes->user->get('id'),
 286                  'roleid' => $role->id,
 287                  'retentionperiod' => 'P5Y',
 288              ]);
 289          $override->save();
 290          role_assign($role->id, $user->id, $systemcontext->id);
 291  
 292          // Flag all expired contexts.
 293          $manager = new \tool_dataprivacy\expired_contexts_manager();
 294          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 295  
 296          $this->assertEquals(0, $flaggedcourses);
 297          $this->assertEquals(0, $flaggedusers);
 298  
 299          $expiredrecord = expired_context::get_record(['contextid' => $usercontext->id]);
 300          $this->assertFalse($expiredrecord);
 301      }
 302  
 303      /**
 304       * Ensure that a user with a lastaccess in the past and expired enrolments.
 305       */
 306      public function test_flag_user_past_lastaccess_expired_enrolled() {
 307          $this->resetAfterTest();
 308  
 309          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 310  
 311          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 312          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
 313          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
 314  
 315          $otheruser = $this->getDataGenerator()->create_user();
 316          $this->getDataGenerator()->enrol_user($otheruser->id, $course->id, 'student');
 317  
 318          $this->setUser($user);
 319          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 320          $context = \context_block::instance($block->instance->id);
 321          $this->setUser();
 322  
 323          // Flag all expired contexts.
 324          $manager = new \tool_dataprivacy\expired_contexts_manager();
 325          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 326  
 327          $this->assertEquals(1, $flaggedcourses);
 328          $this->assertEquals(1, $flaggedusers);
 329      }
 330  
 331      /**
 332       * Ensure that a user with a lastaccess in the past and enrolments without a course end date are respected
 333       * correctly.
 334       */
 335      public function test_flag_user_past_lastaccess_missing_enddate_required() {
 336          $this->resetAfterTest();
 337  
 338          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 339  
 340          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 341          $course = $this->getDataGenerator()->create_course();
 342          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
 343  
 344          $otheruser = $this->getDataGenerator()->create_user();
 345          $this->getDataGenerator()->enrol_user($otheruser->id, $course->id, 'student');
 346  
 347          $this->setUser($user);
 348          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 349          $context = \context_block::instance($block->instance->id);
 350          $this->setUser();
 351  
 352          // Ensure that course end dates are not required.
 353          set_config('requireallenddatesforuserdeletion', 1, 'tool_dataprivacy');
 354  
 355          // Flag all expired contexts.
 356          $manager = new \tool_dataprivacy\expired_contexts_manager();
 357          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 358  
 359          $this->assertEquals(0, $flaggedcourses);
 360          $this->assertEquals(0, $flaggedusers);
 361      }
 362  
 363      /**
 364       * Ensure that a user with a lastaccess in the past and enrolments without a course end date are respected
 365       * correctly when the end date is not required.
 366       */
 367      public function test_flag_user_past_lastaccess_missing_enddate_not_required() {
 368          $this->resetAfterTest();
 369  
 370          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 371  
 372          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 373          $course = $this->getDataGenerator()->create_course();
 374          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
 375  
 376          $otheruser = $this->getDataGenerator()->create_user();
 377          $this->getDataGenerator()->enrol_user($otheruser->id, $course->id, 'student');
 378  
 379          $this->setUser($user);
 380          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 381          $context = \context_block::instance($block->instance->id);
 382          $this->setUser();
 383  
 384          // Ensure that course end dates are required.
 385          set_config('requireallenddatesforuserdeletion', 0, 'tool_dataprivacy');
 386  
 387          // Flag all expired contexts.
 388          $manager = new \tool_dataprivacy\expired_contexts_manager();
 389          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 390  
 391          $this->assertEquals(0, $flaggedcourses);
 392          $this->assertEquals(1, $flaggedusers);
 393      }
 394  
 395      /**
 396       * Ensure that a user with a recent lastaccess is not flagged for deletion.
 397       */
 398      public function test_flag_user_recent_lastaccess_existing_record() {
 399          $this->resetAfterTest();
 400  
 401          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 402  
 403          $user = $this->getDataGenerator()->create_user(['lastaccess' => time()]);
 404          $usercontext = \context_user::instance($user->id);
 405  
 406          // Create an existing expired_context.
 407          $expiredcontext = new expired_context(0, (object) [
 408                  'contextid' => $usercontext->id,
 409                  'status' => expired_context::STATUS_EXPIRED,
 410              ]);
 411          $expiredcontext->save();
 412  
 413          $this->setUser($user);
 414          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 415          $context = \context_block::instance($block->instance->id);
 416          $this->setUser();
 417  
 418          // Flag all expired contexts.
 419          $manager = new \tool_dataprivacy\expired_contexts_manager();
 420          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 421  
 422          $this->assertEquals(0, $flaggedcourses);
 423          $this->assertEquals(0, $flaggedusers);
 424  
 425          $this->expectException('dml_missing_record_exception');
 426          new expired_context($expiredcontext->get('id'));
 427      }
 428  
 429      /**
 430       * Ensure that a user with a recent lastaccess is not flagged for deletion.
 431       */
 432      public function test_flag_user_retention_changed() {
 433          $this->resetAfterTest();
 434  
 435          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 436  
 437          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - DAYSECS]);
 438          $usercontext = \context_user::instance($user->id);
 439  
 440          $this->setUser($user);
 441          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 442          $context = \context_block::instance($block->instance->id);
 443          $this->setUser();
 444  
 445          // Flag all expired contexts.
 446          $manager = new \tool_dataprivacy\expired_contexts_manager();
 447          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 448  
 449          $this->assertEquals(0, $flaggedcourses);
 450          $this->assertEquals(1, $flaggedusers);
 451  
 452          $expiredcontext = expired_context::get_record(['contextid' => $usercontext->id]);
 453          $this->assertNotFalse($expiredcontext);
 454  
 455          // Increase the retention period to 5 years.
 456          $purposes->user->set('retentionperiod', 'P5Y');
 457          $purposes->user->save();
 458  
 459          // Re-run the expiry job - the previously flagged user will be removed because the retention period has been increased.
 460          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 461          $this->assertEquals(0, $flaggedcourses);
 462          $this->assertEquals(0, $flaggedusers);
 463  
 464          // The expiry record will now have been removed.
 465          $this->expectException('dml_missing_record_exception');
 466          new expired_context($expiredcontext->get('id'));
 467      }
 468  
 469      /**
 470       * Ensure that a user with a historically expired expired block record child is cleaned up.
 471       */
 472      public function test_flag_user_historic_block_unapproved() {
 473          $this->resetAfterTest();
 474  
 475          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 476  
 477          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - DAYSECS]);
 478          $usercontext = \context_user::instance($user->id);
 479  
 480          $this->setUser($user);
 481          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 482          $blockcontext = \context_block::instance($block->instance->id);
 483          $this->setUser();
 484  
 485          // Create an existing expired_context which has not been approved for the block.
 486          $expiredcontext = new expired_context(0, (object) [
 487                  'contextid' => $blockcontext->id,
 488                  'status' => expired_context::STATUS_EXPIRED,
 489              ]);
 490          $expiredcontext->save();
 491  
 492          // Flag all expired contexts.
 493          $manager = new \tool_dataprivacy\expired_contexts_manager();
 494          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 495  
 496          $this->assertEquals(0, $flaggedcourses);
 497          $this->assertEquals(1, $flaggedusers);
 498  
 499          $expiredblockcontext = expired_context::get_record(['contextid' => $blockcontext->id]);
 500          $this->assertFalse($expiredblockcontext);
 501  
 502          $expiredusercontext = expired_context::get_record(['contextid' => $usercontext->id]);
 503          $this->assertNotFalse($expiredusercontext);
 504      }
 505  
 506      /**
 507       * Ensure that a user with a block which has a default retention period which has not expired, is still expired.
 508       */
 509      public function test_flag_user_historic_unexpired_child() {
 510          $this->resetAfterTest();
 511  
 512          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 513          $this->create_and_set_purpose_for_contextlevel('P5Y', CONTEXT_BLOCK);
 514  
 515          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - DAYSECS]);
 516          $usercontext = \context_user::instance($user->id);
 517  
 518          $this->setUser($user);
 519          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
 520          $blockcontext = \context_block::instance($block->instance->id);
 521          $this->setUser();
 522  
 523          // Flag all expired contexts.
 524          $manager = new \tool_dataprivacy\expired_contexts_manager();
 525          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 526  
 527          $this->assertEquals(0, $flaggedcourses);
 528          $this->assertEquals(1, $flaggedusers);
 529  
 530          $expiredcontext = expired_context::get_record(['contextid' => $usercontext->id]);
 531          $this->assertNotFalse($expiredcontext);
 532      }
 533  
 534      /**
 535       * Ensure that a course with no end date is not flagged.
 536       */
 537      public function test_flag_course_no_enddate() {
 538          $this->resetAfterTest();
 539  
 540          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
 541  
 542          $course = $this->getDataGenerator()->create_course();
 543          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 544  
 545          // Flag all expired contexts.
 546          $manager = new \tool_dataprivacy\expired_contexts_manager();
 547          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 548  
 549          $this->assertEquals(0, $flaggedcourses);
 550          $this->assertEquals(0, $flaggedusers);
 551      }
 552  
 553      /**
 554       * Ensure that a course with an end date in the distant past, but a child which is unexpired is not flagged.
 555       */
 556      public function test_flag_course_past_enddate_future_child() {
 557          $this->resetAfterTest();
 558  
 559          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'P5Y');
 560  
 561          $course = $this->getDataGenerator()->create_course([
 562                  'startdate' => time() - (2 * YEARSECS),
 563                  'enddate' => time() - YEARSECS,
 564              ]);
 565          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 566  
 567          // Flag all expired contexts.
 568          $manager = new \tool_dataprivacy\expired_contexts_manager();
 569          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 570  
 571          $this->assertEquals(0, $flaggedcourses);
 572          $this->assertEquals(0, $flaggedusers);
 573      }
 574  
 575      /**
 576       * Ensure that a course with an end date in the distant past is flagged.
 577       */
 578      public function test_flag_course_past_enddate() {
 579          $this->resetAfterTest();
 580  
 581          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
 582  
 583          $course = $this->getDataGenerator()->create_course([
 584                  'startdate' => time() - (2 * YEARSECS),
 585                  'enddate' => time() - YEARSECS,
 586              ]);
 587          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 588  
 589          // Flag all expired contexts.
 590          $manager = new \tool_dataprivacy\expired_contexts_manager();
 591          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 592  
 593          $this->assertEquals(2, $flaggedcourses);
 594          $this->assertEquals(0, $flaggedusers);
 595      }
 596  
 597      /**
 598       * Ensure that a course with an end date in the distant past is flagged.
 599       */
 600      public function test_flag_course_past_enddate_multiple() {
 601          $this->resetAfterTest();
 602  
 603          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
 604  
 605          $course1 = $this->getDataGenerator()->create_course([
 606                  'startdate' => time() - (2 * YEARSECS),
 607                  'enddate' => time() - YEARSECS,
 608              ]);
 609          $forum1 = $this->getDataGenerator()->create_module('forum', ['course' => $course1->id]);
 610  
 611          $course2 = $this->getDataGenerator()->create_course([
 612                  'startdate' => time() - (2 * YEARSECS),
 613                  'enddate' => time() - YEARSECS,
 614              ]);
 615          $forum2 = $this->getDataGenerator()->create_module('forum', ['course' => $course2->id]);
 616  
 617          // Flag all expired contexts.
 618          $manager = new \tool_dataprivacy\expired_contexts_manager();
 619          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 620  
 621          $this->assertEquals(4, $flaggedcourses);
 622          $this->assertEquals(0, $flaggedusers);
 623      }
 624  
 625      /**
 626       * Ensure that a course with an end date in the future is not flagged.
 627       */
 628      public function test_flag_course_future_enddate() {
 629          $this->resetAfterTest();
 630  
 631          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
 632  
 633          $course = $this->getDataGenerator()->create_course(['enddate' => time() + YEARSECS]);
 634          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 635  
 636          // Flag all expired contexts.
 637          $manager = new \tool_dataprivacy\expired_contexts_manager();
 638          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 639  
 640          $this->assertEquals(0, $flaggedcourses);
 641          $this->assertEquals(0, $flaggedusers);
 642      }
 643  
 644      /**
 645       * Ensure that a course with an end date in the future is not flagged.
 646       */
 647      public function test_flag_course_recent_unexpired_enddate() {
 648          $this->resetAfterTest();
 649  
 650          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
 651  
 652          $course = $this->getDataGenerator()->create_course(['enddate' => time() - 1]);
 653  
 654          // Flag all expired contexts.
 655          $manager = new \tool_dataprivacy\expired_contexts_manager();
 656          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 657  
 658          $this->assertEquals(0, $flaggedcourses);
 659          $this->assertEquals(0, $flaggedusers);
 660      }
 661  
 662      /**
 663       * Ensure that a course with an end date in the distant past is flagged, taking into account any purpose override
 664       */
 665      public function test_flag_course_past_enddate_with_override_unexpired_role() {
 666          global $DB;
 667          $this->resetAfterTest();
 668  
 669          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 670  
 671          $role = $DB->get_record('role', ['shortname' => 'editingteacher']);
 672  
 673          $override = new purpose_override(0, (object) [
 674                  'purposeid' => $purposes->course->get('id'),
 675                  'roleid' => $role->id,
 676                  'retentionperiod' => 'P5Y',
 677              ]);
 678          $override->save();
 679  
 680          $course = $this->getDataGenerator()->create_course([
 681                  'startdate' => time() - (2 * DAYSECS),
 682                  'enddate' => time() - DAYSECS,
 683              ]);
 684          $coursecontext = \context_course::instance($course->id);
 685  
 686          // Flag all expired contexts.
 687          $manager = new \tool_dataprivacy\expired_contexts_manager();
 688          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 689  
 690          $this->assertEquals(1, $flaggedcourses);
 691          $this->assertEquals(0, $flaggedusers);
 692  
 693          $expiredrecord = expired_context::get_record(['contextid' => $coursecontext->id]);
 694          $this->assertEmpty($expiredrecord->get('expiredroles'));
 695  
 696          $unexpiredroles = $expiredrecord->get('unexpiredroles');
 697          $this->assertCount(1, $unexpiredroles);
 698          $this->assertContains($role->id, $unexpiredroles);
 699      }
 700  
 701      /**
 702       * Ensure that a course with an end date in the distant past is flagged, and any expired role is ignored.
 703       */
 704      public function test_flag_course_past_enddate_with_override_expired_role() {
 705          global $DB;
 706          $this->resetAfterTest();
 707  
 708          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 709  
 710          $role = $DB->get_record('role', ['shortname' => 'student']);
 711  
 712          // The role has a much shorter retention, but both should match.
 713          $override = new purpose_override(0, (object) [
 714                  'purposeid' => $purposes->course->get('id'),
 715                  'roleid' => $role->id,
 716                  'retentionperiod' => 'PT1M',
 717              ]);
 718          $override->save();
 719  
 720          $course = $this->getDataGenerator()->create_course([
 721                  'startdate' => time() - (2 * DAYSECS),
 722                  'enddate' => time() - DAYSECS,
 723              ]);
 724          $coursecontext = \context_course::instance($course->id);
 725  
 726          // Flag all expired contexts.
 727          $manager = new \tool_dataprivacy\expired_contexts_manager();
 728          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 729  
 730          $this->assertEquals(1, $flaggedcourses);
 731          $this->assertEquals(0, $flaggedusers);
 732  
 733          $expiredrecord = expired_context::get_record(['contextid' => $coursecontext->id]);
 734          $this->assertEmpty($expiredrecord->get('expiredroles'));
 735          $this->assertEmpty($expiredrecord->get('unexpiredroles'));
 736          $this->assertTrue((bool) $expiredrecord->get('defaultexpired'));
 737      }
 738  
 739      /**
 740       * Ensure that where a course has explicitly expired one role, but that role is explicitly not expired in a child
 741       * context, does not have the parent context role expired.
 742       */
 743      public function test_flag_course_override_expiredwith_override_unexpired_on_child() {
 744          global $DB;
 745          $this->resetAfterTest();
 746  
 747          $purposes = $this->setup_basics('P1Y', 'P1Y', 'P1Y');
 748  
 749          $role = $DB->get_record('role', ['shortname' => 'editingteacher']);
 750  
 751          (new purpose_override(0, (object) [
 752                  'purposeid' => $purposes->course->get('id'),
 753                  'roleid' => $role->id,
 754                  'retentionperiod' => 'PT1S',
 755              ]))->save();
 756  
 757          $modpurpose = new purpose(0, (object) [
 758              'name' => 'Module purpose',
 759              'retentionperiod' => 'PT1S',
 760              'lawfulbases' => 'gdpr_art_6_1_a',
 761          ]);
 762          $modpurpose->create();
 763  
 764          (new purpose_override(0, (object) [
 765                  'purposeid' => $modpurpose->get('id'),
 766                  'roleid' => $role->id,
 767                  'retentionperiod' => 'P5Y',
 768              ]))->save();
 769  
 770          $course = $this->getDataGenerator()->create_course([
 771                  'startdate' => time() - (2 * DAYSECS),
 772                  'enddate' => time() - DAYSECS,
 773              ]);
 774          $coursecontext = \context_course::instance($course->id);
 775  
 776          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 777          $cm = get_coursemodule_from_instance('forum', $forum->id);
 778          $forumcontext = \context_module::instance($cm->id);
 779  
 780          api::set_context_instance((object) [
 781                  'contextid' => $forumcontext->id,
 782                  'purposeid' => $modpurpose->get('id'),
 783                  'categoryid' => 0,
 784              ]);
 785  
 786          // Flag all expired contexts.
 787          $manager = new \tool_dataprivacy\expired_contexts_manager();
 788          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
 789  
 790          $this->assertEquals(1, $flaggedcourses);
 791          $this->assertEquals(0, $flaggedusers);
 792  
 793          // The course will not be expired as the default expiry has not passed, and the explicit role override has been
 794          // removed due to the child non-expiry.
 795          $expiredrecord = expired_context::get_record(['contextid' => $coursecontext->id]);
 796          $this->assertFalse($expiredrecord);
 797  
 798          // The forum will have an expiry for all _but_ the overridden role.
 799          $expiredrecord = expired_context::get_record(['contextid' => $forumcontext->id]);
 800          $this->assertEmpty($expiredrecord->get('expiredroles'));
 801  
 802          // The teacher is not expired.
 803          $unexpiredroles = $expiredrecord->get('unexpiredroles');
 804          $this->assertCount(1, $unexpiredroles);
 805          $this->assertContains($role->id, $unexpiredroles);
 806          $this->assertTrue((bool) $expiredrecord->get('defaultexpired'));
 807      }
 808  
 809      /**
 810       * Ensure that a user context previously flagged as approved is not removed if the user has any unexpired roles.
 811       */
 812      public function test_process_user_context_with_override_unexpired_role() {
 813          global $DB;
 814          $this->resetAfterTest();
 815  
 816          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 817  
 818          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
 819          $usercontext = \context_user::instance($user->id);
 820          $systemcontext = \context_system::instance();
 821  
 822          $role = $DB->get_record('role', ['shortname' => 'manager']);
 823  
 824          $override = new purpose_override(0, (object) [
 825                  'purposeid' => $purposes->user->get('id'),
 826                  'roleid' => $role->id,
 827                  'retentionperiod' => 'P5Y',
 828              ]);
 829          $override->save();
 830          role_assign($role->id, $user->id, $systemcontext->id);
 831  
 832          // Create an existing expired_context.
 833          $expiredcontext = new expired_context(0, (object) [
 834                  'contextid' => $usercontext->id,
 835                  'defaultexpired' => 1,
 836                  'status' => expired_context::STATUS_APPROVED,
 837              ]);
 838          $expiredcontext->add_unexpiredroles([$role->id]);
 839          $expiredcontext->save();
 840  
 841          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
 842              ->onlyMethods([
 843                  'delete_data_for_user',
 844                  'delete_data_for_users_in_context',
 845                  'delete_data_for_all_users_in_context',
 846              ])
 847              ->getMock();
 848          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
 849          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
 850          $mockprivacymanager->expects($this->never())->method('delete_data_for_users_in_context');
 851  
 852          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
 853              ->onlyMethods(['get_privacy_manager'])
 854              ->getMock();
 855  
 856          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
 857          $manager->set_progress(new \null_progress_trace());
 858          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
 859  
 860          $this->assertEquals(0, $processedcourses);
 861          $this->assertEquals(0, $processedusers);
 862  
 863          $this->expectException('dml_missing_record_exception');
 864          $updatedcontext = new expired_context($expiredcontext->get('id'));
 865      }
 866  
 867      /**
 868       * Ensure that a module context previously flagged as approved is removed with appropriate unexpiredroles kept.
 869       */
 870      public function test_process_course_context_with_override_unexpired_role() {
 871          global $DB;
 872          $this->resetAfterTest();
 873  
 874          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
 875  
 876          $role = $DB->get_record('role', ['shortname' => 'editingteacher']);
 877  
 878          $override = new purpose_override(0, (object) [
 879                  'purposeid' => $purposes->course->get('id'),
 880                  'roleid' => $role->id,
 881                  'retentionperiod' => 'P5Y',
 882              ]);
 883          $override->save();
 884  
 885          $course = $this->getDataGenerator()->create_course([
 886                  'startdate' => time() - (2 * YEARSECS),
 887                  'enddate' => time() - YEARSECS,
 888              ]);
 889          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 890          $cm = get_coursemodule_from_instance('forum', $forum->id);
 891          $forumcontext = \context_module::instance($cm->id);
 892          $generator = $this->getDataGenerator()->get_plugin_generator('mod_forum');
 893  
 894          $student = $this->getDataGenerator()->create_user();
 895          $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');
 896          $generator->create_discussion((object) [
 897              'course' => $forum->course,
 898              'forum' => $forum->id,
 899              'userid' => $student->id,
 900          ]);
 901  
 902          $teacher = $this->getDataGenerator()->create_user();
 903          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'editingteacher');
 904          $generator->create_discussion((object) [
 905              'course' => $forum->course,
 906              'forum' => $forum->id,
 907              'userid' => $teacher->id,
 908          ]);
 909  
 910          // Create an existing expired_context.
 911          $expiredcontext = new expired_context(0, (object) [
 912                  'contextid' => $forumcontext->id,
 913                  'defaultexpired' => 1,
 914                  'status' => expired_context::STATUS_APPROVED,
 915              ]);
 916          $expiredcontext->add_unexpiredroles([$role->id]);
 917          $expiredcontext->save();
 918  
 919          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
 920              ->onlyMethods([
 921                  'delete_data_for_user',
 922                  'delete_data_for_users_in_context',
 923                  'delete_data_for_all_users_in_context',
 924              ])
 925              ->getMock();
 926          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
 927          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
 928          $mockprivacymanager
 929              ->expects($this->once())
 930              ->method('delete_data_for_users_in_context')
 931              ->with($this->callback(function($userlist) use ($student, $teacher) {
 932                  $forumlist = $userlist->get_userlist_for_component('mod_forum');
 933                  $userids = $forumlist->get_userids();
 934                  $this->assertCount(1, $userids);
 935                  $this->assertContainsEquals($student->id, $userids);
 936                  $this->assertNotContainsEquals($teacher->id, $userids);
 937                  return true;
 938              }));
 939  
 940          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
 941              ->onlyMethods(['get_privacy_manager'])
 942              ->getMock();
 943  
 944          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
 945          $manager->set_progress(new \null_progress_trace());
 946          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
 947  
 948          $this->assertEquals(1, $processedcourses);
 949          $this->assertEquals(0, $processedusers);
 950  
 951          $updatedcontext = new expired_context($expiredcontext->get('id'));
 952          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
 953      }
 954  
 955      /**
 956       * Ensure that a module context previously flagged as approved is removed with appropriate expiredroles kept.
 957       */
 958      public function test_process_course_context_with_override_expired_role() {
 959          global $DB;
 960          $this->resetAfterTest();
 961  
 962          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P5Y');
 963  
 964          $role = $DB->get_record('role', ['shortname' => 'student']);
 965  
 966          $override = new purpose_override(0, (object) [
 967                  'purposeid' => $purposes->course->get('id'),
 968                  'roleid' => $role->id,
 969                  'retentionperiod' => 'PT1M',
 970              ]);
 971          $override->save();
 972  
 973          $course = $this->getDataGenerator()->create_course([
 974                  'startdate' => time() - (2 * YEARSECS),
 975                  'enddate' => time() - YEARSECS,
 976              ]);
 977          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
 978          $cm = get_coursemodule_from_instance('forum', $forum->id);
 979          $forumcontext = \context_module::instance($cm->id);
 980          $generator = $this->getDataGenerator()->get_plugin_generator('mod_forum');
 981  
 982          $student = $this->getDataGenerator()->create_user();
 983          $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');
 984          $generator->create_discussion((object) [
 985              'course' => $forum->course,
 986              'forum' => $forum->id,
 987              'userid' => $student->id,
 988          ]);
 989  
 990          $teacher = $this->getDataGenerator()->create_user();
 991          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'editingteacher');
 992          $generator->create_discussion((object) [
 993              'course' => $forum->course,
 994              'forum' => $forum->id,
 995              'userid' => $teacher->id,
 996          ]);
 997  
 998          // Create an existing expired_context.
 999          $expiredcontext = new expired_context(0, (object) [
1000                  'contextid' => $forumcontext->id,
1001                  'defaultexpired' => 0,
1002                  'status' => expired_context::STATUS_APPROVED,
1003              ]);
1004          $expiredcontext->add_expiredroles([$role->id]);
1005          $expiredcontext->save();
1006  
1007          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1008              ->onlyMethods([
1009                  'delete_data_for_user',
1010                  'delete_data_for_users_in_context',
1011                  'delete_data_for_all_users_in_context',
1012              ])
1013              ->getMock();
1014          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1015          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1016          $mockprivacymanager
1017              ->expects($this->once())
1018              ->method('delete_data_for_users_in_context')
1019              ->with($this->callback(function($userlist) use ($student, $teacher) {
1020                  $forumlist = $userlist->get_userlist_for_component('mod_forum');
1021                  $userids = $forumlist->get_userids();
1022                  $this->assertCount(1, $userids);
1023                  $this->assertContainsEquals($student->id, $userids);
1024                  $this->assertNotContainsEquals($teacher->id, $userids);
1025                  return true;
1026              }));
1027  
1028          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1029              ->onlyMethods(['get_privacy_manager'])
1030              ->getMock();
1031  
1032          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1033          $manager->set_progress(new \null_progress_trace());
1034          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1035  
1036          $this->assertEquals(1, $processedcourses);
1037          $this->assertEquals(0, $processedusers);
1038  
1039          $updatedcontext = new expired_context($expiredcontext->get('id'));
1040          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1041      }
1042  
1043      /**
1044       * Ensure that a module context previously flagged as approved is removed with appropriate expiredroles kept.
1045       */
1046      public function test_process_course_context_with_user_in_both_lists() {
1047          global $DB;
1048          $this->resetAfterTest();
1049  
1050          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P5Y');
1051  
1052          $role = $DB->get_record('role', ['shortname' => 'student']);
1053  
1054          $override = new purpose_override(0, (object) [
1055                  'purposeid' => $purposes->course->get('id'),
1056                  'roleid' => $role->id,
1057                  'retentionperiod' => 'PT1M',
1058              ]);
1059          $override->save();
1060  
1061          $course = $this->getDataGenerator()->create_course([
1062                  'startdate' => time() - (2 * YEARSECS),
1063                  'enddate' => time() - YEARSECS,
1064              ]);
1065          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1066          $cm = get_coursemodule_from_instance('forum', $forum->id);
1067          $forumcontext = \context_module::instance($cm->id);
1068          $generator = $this->getDataGenerator()->get_plugin_generator('mod_forum');
1069  
1070          $teacher = $this->getDataGenerator()->create_user();
1071          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'editingteacher');
1072          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'student');
1073          $generator->create_discussion((object) [
1074              'course' => $forum->course,
1075              'forum' => $forum->id,
1076              'userid' => $teacher->id,
1077          ]);
1078  
1079          $student = $this->getDataGenerator()->create_user();
1080          $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');
1081          $generator->create_discussion((object) [
1082              'course' => $forum->course,
1083              'forum' => $forum->id,
1084              'userid' => $student->id,
1085          ]);
1086  
1087          // Create an existing expired_context.
1088          $expiredcontext = new expired_context(0, (object) [
1089                  'contextid' => $forumcontext->id,
1090                  'defaultexpired' => 0,
1091                  'status' => expired_context::STATUS_APPROVED,
1092              ]);
1093          $expiredcontext->add_expiredroles([$role->id]);
1094          $expiredcontext->save();
1095  
1096          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1097              ->onlyMethods([
1098                  'delete_data_for_user',
1099                  'delete_data_for_users_in_context',
1100                  'delete_data_for_all_users_in_context',
1101              ])
1102              ->getMock();
1103          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1104          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1105          $mockprivacymanager
1106              ->expects($this->once())
1107              ->method('delete_data_for_users_in_context')
1108              ->with($this->callback(function($userlist) use ($student, $teacher) {
1109                  $forumlist = $userlist->get_userlist_for_component('mod_forum');
1110                  $userids = $forumlist->get_userids();
1111                  $this->assertCount(1, $userids);
1112                  $this->assertContainsEquals($student->id, $userids);
1113                  $this->assertNotContainsEquals($teacher->id, $userids);
1114                  return true;
1115              }));
1116  
1117          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1118              ->onlyMethods(['get_privacy_manager'])
1119              ->getMock();
1120  
1121          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1122          $manager->set_progress(new \null_progress_trace());
1123          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1124  
1125          $this->assertEquals(1, $processedcourses);
1126          $this->assertEquals(0, $processedusers);
1127  
1128          $updatedcontext = new expired_context($expiredcontext->get('id'));
1129          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1130      }
1131  
1132      /**
1133       * Ensure that a module context previously flagged as approved is removed with appropriate expiredroles kept.
1134       */
1135      public function test_process_course_context_with_user_in_both_lists_expired() {
1136          global $DB;
1137          $this->resetAfterTest();
1138  
1139          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P5Y');
1140  
1141          $studentrole = $DB->get_record('role', ['shortname' => 'student']);
1142          $override = new purpose_override(0, (object) [
1143                  'purposeid' => $purposes->course->get('id'),
1144                  'roleid' => $studentrole->id,
1145                  'retentionperiod' => 'PT1M',
1146              ]);
1147          $override->save();
1148  
1149          $teacherrole = $DB->get_record('role', ['shortname' => 'editingteacher']);
1150          $override = new purpose_override(0, (object) [
1151                  'purposeid' => $purposes->course->get('id'),
1152                  'roleid' => $teacherrole->id,
1153                  'retentionperiod' => 'PT1M',
1154              ]);
1155          $override->save();
1156  
1157          $course = $this->getDataGenerator()->create_course([
1158                  'startdate' => time() - (2 * YEARSECS),
1159                  'enddate' => time() - YEARSECS,
1160              ]);
1161          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1162          $cm = get_coursemodule_from_instance('forum', $forum->id);
1163          $forumcontext = \context_module::instance($cm->id);
1164          $generator = $this->getDataGenerator()->get_plugin_generator('mod_forum');
1165  
1166          $teacher = $this->getDataGenerator()->create_user();
1167          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'editingteacher');
1168          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'student');
1169          $generator->create_discussion((object) [
1170              'course' => $forum->course,
1171              'forum' => $forum->id,
1172              'userid' => $teacher->id,
1173          ]);
1174  
1175          $student = $this->getDataGenerator()->create_user();
1176          $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');
1177          $generator->create_discussion((object) [
1178              'course' => $forum->course,
1179              'forum' => $forum->id,
1180              'userid' => $student->id,
1181          ]);
1182  
1183          // Create an existing expired_context.
1184          $expiredcontext = new expired_context(0, (object) [
1185                  'contextid' => $forumcontext->id,
1186                  'defaultexpired' => 0,
1187                  'status' => expired_context::STATUS_APPROVED,
1188              ]);
1189          $expiredcontext->add_expiredroles([$studentrole->id, $teacherrole->id]);
1190          $expiredcontext->save();
1191  
1192          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1193              ->onlyMethods([
1194                  'delete_data_for_user',
1195                  'delete_data_for_users_in_context',
1196                  'delete_data_for_all_users_in_context',
1197              ])
1198              ->getMock();
1199          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1200          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1201          $mockprivacymanager
1202              ->expects($this->once())
1203              ->method('delete_data_for_users_in_context')
1204              ->with($this->callback(function($userlist) use ($student, $teacher) {
1205                  $forumlist = $userlist->get_userlist_for_component('mod_forum');
1206                  $userids = $forumlist->get_userids();
1207                  $this->assertCount(2, $userids);
1208                  $this->assertContainsEquals($student->id, $userids);
1209                  $this->assertContainsEquals($teacher->id, $userids);
1210                  return true;
1211              }));
1212  
1213          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1214              ->onlyMethods(['get_privacy_manager'])
1215              ->getMock();
1216  
1217          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1218          $manager->set_progress(new \null_progress_trace());
1219          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1220  
1221          $this->assertEquals(1, $processedcourses);
1222          $this->assertEquals(0, $processedusers);
1223  
1224          $updatedcontext = new expired_context($expiredcontext->get('id'));
1225          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1226      }
1227  
1228      /**
1229       * Ensure that a site not setup will not process anything.
1230       */
1231      public function test_process_not_setup() {
1232          $this->resetAfterTest();
1233  
1234          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
1235          $usercontext = \context_user::instance($user->id);
1236  
1237          // Create an existing expired_context.
1238          $expiredcontext = new expired_context(0, (object) [
1239                  'contextid' => $usercontext->id,
1240                  'status' => expired_context::STATUS_EXPIRED,
1241              ]);
1242          $expiredcontext->save();
1243  
1244          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1245              ->onlyMethods([
1246                  'delete_data_for_user',
1247                  'delete_data_for_all_users_in_context',
1248              ])
1249              ->getMock();
1250          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1251          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1252  
1253          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1254              ->onlyMethods(['get_privacy_manager'])
1255              ->getMock();
1256          $manager->set_progress(new \null_progress_trace());
1257  
1258          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1259          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1260  
1261          $this->assertEquals(0, $processedcourses);
1262          $this->assertEquals(0, $processedusers);
1263      }
1264  
1265      /**
1266       * Ensure that a user with no lastaccess is not flagged for deletion.
1267       */
1268      public function test_process_none_approved() {
1269          $this->resetAfterTest();
1270  
1271          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1272  
1273          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
1274          $usercontext = \context_user::instance($user->id);
1275  
1276          // Create an existing expired_context.
1277          $expiredcontext = new expired_context(0, (object) [
1278                  'contextid' => $usercontext->id,
1279                  'status' => expired_context::STATUS_EXPIRED,
1280              ]);
1281          $expiredcontext->save();
1282  
1283          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1284              ->onlyMethods([
1285                  'delete_data_for_user',
1286                  'delete_data_for_all_users_in_context',
1287              ])
1288              ->getMock();
1289          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1290          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1291  
1292          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1293              ->onlyMethods(['get_privacy_manager'])
1294              ->getMock();
1295          $manager->set_progress(new \null_progress_trace());
1296  
1297          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1298          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1299  
1300          $this->assertEquals(0, $processedcourses);
1301          $this->assertEquals(0, $processedusers);
1302      }
1303  
1304      /**
1305       * Ensure that a user with no lastaccess is not flagged for deletion.
1306       */
1307      public function test_process_no_context() {
1308          $this->resetAfterTest();
1309  
1310          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1311  
1312          // Create an existing expired_context.
1313          $expiredcontext = new expired_context(0, (object) [
1314                  'contextid' => -1,
1315                  'status' => expired_context::STATUS_APPROVED,
1316              ]);
1317          $expiredcontext->save();
1318  
1319          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1320              ->onlyMethods([
1321                  'delete_data_for_user',
1322                  'delete_data_for_all_users_in_context',
1323              ])
1324              ->getMock();
1325          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1326          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1327  
1328          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1329              ->onlyMethods(['get_privacy_manager'])
1330              ->getMock();
1331          $manager->set_progress(new \null_progress_trace());
1332  
1333          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1334          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1335  
1336          $this->assertEquals(0, $processedcourses);
1337          $this->assertEquals(0, $processedusers);
1338  
1339          $this->expectException('dml_missing_record_exception');
1340          new expired_context($expiredcontext->get('id'));
1341      }
1342  
1343      /**
1344       * Ensure that a user context previously flagged as approved is removed.
1345       */
1346      public function test_process_user_context() {
1347          $this->resetAfterTest();
1348  
1349          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
1350  
1351          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
1352          $usercontext = \context_user::instance($user->id);
1353  
1354          $this->setUser($user);
1355          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
1356          $blockcontext = \context_block::instance($block->instance->id);
1357          $this->setUser();
1358  
1359          // Create an existing expired_context.
1360          $expiredcontext = new expired_context(0, (object) [
1361                  'contextid' => $usercontext->id,
1362                  'status' => expired_context::STATUS_APPROVED,
1363              ]);
1364          $expiredcontext->save();
1365  
1366          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1367              ->onlyMethods([
1368                  'delete_data_for_user',
1369                  'delete_data_for_all_users_in_context',
1370              ])
1371              ->getMock();
1372          $mockprivacymanager->expects($this->atLeastOnce())->method('delete_data_for_user');
1373          $mockprivacymanager->expects($this->exactly(2))
1374              ->method('delete_data_for_all_users_in_context')
1375              ->withConsecutive(
1376                  [$blockcontext],
1377                  [$usercontext]
1378              );
1379  
1380          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1381              ->onlyMethods(['get_privacy_manager'])
1382              ->getMock();
1383          $manager->set_progress(new \null_progress_trace());
1384  
1385          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1386          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1387  
1388          $this->assertEquals(0, $processedcourses);
1389          $this->assertEquals(1, $processedusers);
1390  
1391          $updatedcontext = new expired_context($expiredcontext->get('id'));
1392          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1393  
1394          // Flag all expired contexts again.
1395          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
1396  
1397          $this->assertEquals(0, $flaggedcourses);
1398          $this->assertEquals(0, $flaggedusers);
1399  
1400          // Ensure that the deleted context record is still present.
1401          $updatedcontext = new expired_context($expiredcontext->get('id'));
1402          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1403      }
1404  
1405      /**
1406       * Ensure that a course context previously flagged as approved is removed.
1407       */
1408      public function test_process_course_context() {
1409          $this->resetAfterTest();
1410  
1411          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1412  
1413          $course = $this->getDataGenerator()->create_course([
1414                  'startdate' => time() - (2 * YEARSECS),
1415                  'enddate' => time() - YEARSECS,
1416              ]);
1417          $coursecontext = \context_course::instance($course->id);
1418  
1419          // Create an existing expired_context.
1420          $expiredcontext = new expired_context(0, (object) [
1421                  'contextid' => $coursecontext->id,
1422                  'status' => expired_context::STATUS_APPROVED,
1423              ]);
1424          $expiredcontext->save();
1425  
1426          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1427              ->onlyMethods([
1428                  'delete_data_for_user',
1429                  'delete_data_for_all_users_in_context',
1430              ])
1431              ->getMock();
1432          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1433          $mockprivacymanager->expects($this->once())->method('delete_data_for_all_users_in_context');
1434  
1435          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1436              ->onlyMethods(['get_privacy_manager'])
1437              ->getMock();
1438          $manager->set_progress(new \null_progress_trace());
1439  
1440          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1441          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1442  
1443          $this->assertEquals(1, $processedcourses);
1444          $this->assertEquals(0, $processedusers);
1445  
1446          $updatedcontext = new expired_context($expiredcontext->get('id'));
1447          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1448      }
1449  
1450      /**
1451       * Ensure that a user context previously flagged as approved is not removed if the user then logs in.
1452       */
1453      public function test_process_user_context_logged_in_after_approval() {
1454          $this->resetAfterTest();
1455  
1456          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
1457  
1458          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
1459          $usercontext = \context_user::instance($user->id);
1460  
1461          $this->setUser($user);
1462          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
1463          $context = \context_block::instance($block->instance->id);
1464          $this->setUser();
1465  
1466          // Create an existing expired_context.
1467          $expiredcontext = new expired_context(0, (object) [
1468                  'contextid' => $usercontext->id,
1469                  'status' => expired_context::STATUS_APPROVED,
1470              ]);
1471          $expiredcontext->save();
1472  
1473          // Now bump the user's last login time.
1474          $this->setUser($user);
1475          user_accesstime_log();
1476          $this->setUser();
1477  
1478          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1479              ->onlyMethods([
1480                  'delete_data_for_user',
1481                  'delete_data_for_all_users_in_context',
1482              ])
1483              ->getMock();
1484          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1485          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1486  
1487          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1488              ->onlyMethods(['get_privacy_manager'])
1489              ->getMock();
1490          $manager->set_progress(new \null_progress_trace());
1491  
1492          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1493          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1494  
1495          $this->assertEquals(0, $processedcourses);
1496          $this->assertEquals(0, $processedusers);
1497  
1498          $this->expectException('dml_missing_record_exception');
1499          new expired_context($expiredcontext->get('id'));
1500      }
1501  
1502      /**
1503       * Ensure that a user context previously flagged as approved is not removed if the purpose has changed.
1504       */
1505      public function test_process_user_context_changed_after_approved() {
1506          $this->resetAfterTest();
1507  
1508          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
1509  
1510          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
1511          $usercontext = \context_user::instance($user->id);
1512  
1513          $this->setUser($user);
1514          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
1515          $context = \context_block::instance($block->instance->id);
1516          $this->setUser();
1517  
1518          // Create an existing expired_context.
1519          $expiredcontext = new expired_context(0, (object) [
1520                  'contextid' => $usercontext->id,
1521                  'status' => expired_context::STATUS_APPROVED,
1522              ]);
1523          $expiredcontext->save();
1524  
1525          // Now make the user a site admin.
1526          $admins = explode(',', get_config('moodle', 'siteadmins'));
1527          $admins[] = $user->id;
1528          set_config('siteadmins', implode(',', $admins));
1529  
1530          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1531              ->onlyMethods([
1532                  'delete_data_for_user',
1533                  'delete_data_for_all_users_in_context',
1534              ])
1535              ->getMock();
1536          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1537          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1538  
1539          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1540              ->onlyMethods(['get_privacy_manager'])
1541              ->getMock();
1542          $manager->set_progress(new \null_progress_trace());
1543  
1544          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1545          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1546  
1547          $this->assertEquals(0, $processedcourses);
1548          $this->assertEquals(0, $processedusers);
1549  
1550          $this->expectException('dml_missing_record_exception');
1551          new expired_context($expiredcontext->get('id'));
1552      }
1553  
1554      /**
1555       * Ensure that a user with a historically expired expired block record child is cleaned up.
1556       */
1557      public function test_process_user_historic_block_unapproved() {
1558          $this->resetAfterTest();
1559  
1560          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
1561  
1562          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - DAYSECS]);
1563          $usercontext = \context_user::instance($user->id);
1564  
1565          $this->setUser($user);
1566          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
1567          $blockcontext = \context_block::instance($block->instance->id);
1568          $this->setUser();
1569  
1570          // Create an expired_context for the user.
1571          $expiredusercontext = new expired_context(0, (object) [
1572                  'contextid' => $usercontext->id,
1573                  'status' => expired_context::STATUS_APPROVED,
1574              ]);
1575          $expiredusercontext->save();
1576  
1577          // Create an existing expired_context which has not been approved for the block.
1578          $expiredblockcontext = new expired_context(0, (object) [
1579                  'contextid' => $blockcontext->id,
1580                  'status' => expired_context::STATUS_EXPIRED,
1581              ]);
1582          $expiredblockcontext->save();
1583  
1584          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1585              ->onlyMethods([
1586                  'delete_data_for_user',
1587                  'delete_data_for_all_users_in_context',
1588              ])
1589              ->getMock();
1590          $mockprivacymanager->expects($this->atLeastOnce())->method('delete_data_for_user');
1591          $mockprivacymanager->expects($this->exactly(2))
1592              ->method('delete_data_for_all_users_in_context')
1593              ->withConsecutive(
1594                  [$blockcontext],
1595                  [$usercontext]
1596              );
1597  
1598          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1599              ->onlyMethods(['get_privacy_manager'])
1600              ->getMock();
1601          $manager->set_progress(new \null_progress_trace());
1602  
1603          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1604          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1605  
1606          $this->assertEquals(0, $processedcourses);
1607          $this->assertEquals(1, $processedusers);
1608  
1609          $updatedcontext = new expired_context($expiredusercontext->get('id'));
1610          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1611      }
1612  
1613      /**
1614       * Ensure that a user with a block which has a default retention period which has not expired, is still expired.
1615       */
1616      public function test_process_user_historic_unexpired_child() {
1617          $this->resetAfterTest();
1618  
1619          $this->setup_basics('PT1H', 'PT1H', 'PT1H');
1620          $this->create_and_set_purpose_for_contextlevel('P5Y', CONTEXT_BLOCK);
1621  
1622          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - DAYSECS]);
1623          $usercontext = \context_user::instance($user->id);
1624  
1625          $this->setUser($user);
1626          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
1627          $blockcontext = \context_block::instance($block->instance->id);
1628          $this->setUser();
1629  
1630          // Create an expired_context for the user.
1631          $expiredusercontext = new expired_context(0, (object) [
1632                  'contextid' => $usercontext->id,
1633                  'status' => expired_context::STATUS_APPROVED,
1634              ]);
1635          $expiredusercontext->save();
1636  
1637          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1638              ->onlyMethods([
1639                  'delete_data_for_user',
1640                  'delete_data_for_all_users_in_context',
1641              ])
1642              ->getMock();
1643          $mockprivacymanager->expects($this->atLeastOnce())->method('delete_data_for_user');
1644          $mockprivacymanager->expects($this->exactly(2))
1645              ->method('delete_data_for_all_users_in_context')
1646              ->withConsecutive(
1647                  [$blockcontext],
1648                  [$usercontext]
1649              );
1650  
1651          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1652              ->onlyMethods(['get_privacy_manager'])
1653              ->getMock();
1654          $manager->set_progress(new \null_progress_trace());
1655  
1656          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1657          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1658  
1659          $this->assertEquals(0, $processedcourses);
1660          $this->assertEquals(1, $processedusers);
1661  
1662          $updatedcontext = new expired_context($expiredusercontext->get('id'));
1663          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1664      }
1665  
1666      /**
1667       * Ensure that a course context previously flagged as approved for deletion which now has an unflagged child, is
1668       * updated.
1669       */
1670      public function test_process_course_context_updated() {
1671          $this->resetAfterTest();
1672  
1673          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1674  
1675          $course = $this->getDataGenerator()->create_course([
1676                  'startdate' => time() - (2 * YEARSECS),
1677                  'enddate' => time() - YEARSECS,
1678              ]);
1679          $coursecontext = \context_course::instance($course->id);
1680          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1681  
1682          // Create an existing expired_context.
1683          $expiredcontext = new expired_context(0, (object) [
1684                  'contextid' => $coursecontext->id,
1685                  'status' => expired_context::STATUS_APPROVED,
1686              ]);
1687          $expiredcontext->save();
1688  
1689          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1690              ->onlyMethods([
1691                  'delete_data_for_user',
1692                  'delete_data_for_all_users_in_context',
1693              ])
1694              ->getMock();
1695          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1696          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1697  
1698          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1699              ->onlyMethods(['get_privacy_manager'])
1700              ->getMock();
1701          $manager->set_progress(new \null_progress_trace());
1702          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1703  
1704          // Changing the retention period to a longer period will remove the expired_context record.
1705          $purposes->activity->set('retentionperiod', 'P5Y');
1706          $purposes->activity->save();
1707  
1708          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1709  
1710          $this->assertEquals(0, $processedcourses);
1711          $this->assertEquals(0, $processedusers);
1712  
1713          $this->expectException('dml_missing_record_exception');
1714          $updatedcontext = new expired_context($expiredcontext->get('id'));
1715      }
1716  
1717      /**
1718       * Ensure that a course context previously flagged as approved for deletion which now has an unflagged child, is
1719       * updated.
1720       */
1721      public function test_process_course_context_outstanding_children() {
1722          $this->resetAfterTest();
1723  
1724          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1725  
1726          $course = $this->getDataGenerator()->create_course([
1727                  'startdate' => time() - (2 * YEARSECS),
1728                  'enddate' => time() - YEARSECS,
1729              ]);
1730          $coursecontext = \context_course::instance($course->id);
1731          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1732  
1733          // Create an existing expired_context.
1734          $expiredcontext = new expired_context(0, (object) [
1735                  'contextid' => $coursecontext->id,
1736                  'status' => expired_context::STATUS_APPROVED,
1737              ]);
1738          $expiredcontext->save();
1739  
1740          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1741              ->onlyMethods([
1742                  'delete_data_for_user',
1743                  'delete_data_for_all_users_in_context',
1744              ])
1745              ->getMock();
1746          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1747          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1748  
1749          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1750              ->onlyMethods(['get_privacy_manager'])
1751              ->getMock();
1752          $manager->set_progress(new \null_progress_trace());
1753  
1754          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1755          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1756  
1757          $this->assertEquals(0, $processedcourses);
1758          $this->assertEquals(0, $processedusers);
1759  
1760          $updatedcontext = new expired_context($expiredcontext->get('id'));
1761  
1762          // No change - we just can't process it until the children have finished.
1763          $this->assertEquals(expired_context::STATUS_APPROVED, $updatedcontext->get('status'));
1764      }
1765  
1766      /**
1767       * Ensure that a course context previously flagged as approved for deletion which now has an unflagged child, is
1768       * updated.
1769       */
1770      public function test_process_course_context_pending_children() {
1771          $this->resetAfterTest();
1772  
1773          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1774  
1775          $course = $this->getDataGenerator()->create_course([
1776                  'startdate' => time() - (2 * YEARSECS),
1777                  'enddate' => time() - YEARSECS,
1778              ]);
1779          $coursecontext = \context_course::instance($course->id);
1780          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1781          $cm = get_coursemodule_from_instance('forum', $forum->id);
1782          $forumcontext = \context_module::instance($cm->id);
1783  
1784          // Create an existing expired_context for the course.
1785          $expiredcoursecontext = new expired_context(0, (object) [
1786                  'contextid' => $coursecontext->id,
1787                  'status' => expired_context::STATUS_APPROVED,
1788              ]);
1789          $expiredcoursecontext->save();
1790  
1791          // And for the forum.
1792          $expiredforumcontext = new expired_context(0, (object) [
1793                  'contextid' => $forumcontext->id,
1794                  'status' => expired_context::STATUS_EXPIRED,
1795              ]);
1796          $expiredforumcontext->save();
1797  
1798          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1799              ->onlyMethods([
1800                  'delete_data_for_user',
1801                  'delete_data_for_all_users_in_context',
1802              ])
1803              ->getMock();
1804          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1805          $mockprivacymanager->expects($this->never())->method('delete_data_for_all_users_in_context');
1806  
1807          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1808              ->onlyMethods(['get_privacy_manager'])
1809              ->getMock();
1810          $manager->set_progress(new \null_progress_trace());
1811  
1812          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1813          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1814  
1815          $this->assertEquals(0, $processedcourses);
1816          $this->assertEquals(0, $processedusers);
1817  
1818          $updatedcontext = new expired_context($expiredcoursecontext->get('id'));
1819  
1820          // No change - we just can't process it until the children have finished.
1821          $this->assertEquals(expired_context::STATUS_APPROVED, $updatedcontext->get('status'));
1822      }
1823  
1824      /**
1825       * Ensure that a course context previously flagged as approved for deletion which now has an unflagged child, is
1826       * updated.
1827       */
1828      public function test_process_course_context_approved_children() {
1829          $this->resetAfterTest();
1830  
1831          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
1832  
1833          $course = $this->getDataGenerator()->create_course([
1834                  'startdate' => time() - (2 * YEARSECS),
1835                  'enddate' => time() - YEARSECS,
1836              ]);
1837          $coursecontext = \context_course::instance($course->id);
1838          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
1839          $cm = get_coursemodule_from_instance('forum', $forum->id);
1840          $forumcontext = \context_module::instance($cm->id);
1841  
1842          // Create an existing expired_context for the course.
1843          $expiredcoursecontext = new expired_context(0, (object) [
1844                  'contextid' => $coursecontext->id,
1845                  'status' => expired_context::STATUS_APPROVED,
1846              ]);
1847          $expiredcoursecontext->save();
1848  
1849          // And for the forum.
1850          $expiredforumcontext = new expired_context(0, (object) [
1851                  'contextid' => $forumcontext->id,
1852                  'status' => expired_context::STATUS_APPROVED,
1853              ]);
1854          $expiredforumcontext->save();
1855  
1856          $mockprivacymanager = $this->getMockBuilder(\core_privacy\manager::class)
1857              ->onlyMethods([
1858                  'delete_data_for_user',
1859                  'delete_data_for_all_users_in_context',
1860              ])
1861              ->getMock();
1862          $mockprivacymanager->expects($this->never())->method('delete_data_for_user');
1863          $mockprivacymanager->expects($this->exactly(2))
1864              ->method('delete_data_for_all_users_in_context')
1865              ->withConsecutive(
1866                  [$forumcontext],
1867                  [$coursecontext]
1868              );
1869  
1870          $manager = $this->getMockBuilder(\tool_dataprivacy\expired_contexts_manager::class)
1871              ->onlyMethods(['get_privacy_manager'])
1872              ->getMock();
1873          $manager->set_progress(new \null_progress_trace());
1874  
1875          $manager->method('get_privacy_manager')->willReturn($mockprivacymanager);
1876  
1877          // Initially only the forum will be processed.
1878          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1879  
1880          $this->assertEquals(1, $processedcourses);
1881          $this->assertEquals(0, $processedusers);
1882  
1883          $updatedcontext = new expired_context($expiredforumcontext->get('id'));
1884          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1885  
1886          // The course won't have been processed yet.
1887          $updatedcontext = new expired_context($expiredcoursecontext->get('id'));
1888          $this->assertEquals(expired_context::STATUS_APPROVED, $updatedcontext->get('status'));
1889  
1890          // A subsequent run will cause the course to processed as it is no longer dependent upon the child contexts.
1891          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
1892  
1893          $this->assertEquals(1, $processedcourses);
1894          $this->assertEquals(0, $processedusers);
1895          $updatedcontext = new expired_context($expiredcoursecontext->get('id'));
1896          $this->assertEquals(expired_context::STATUS_CLEANED, $updatedcontext->get('status'));
1897      }
1898  
1899      /**
1900       * Test that the can_process_deletion function returns expected results.
1901       *
1902       * @dataProvider    can_process_deletion_provider
1903       * @param       int     $status
1904       * @param       bool    $expected
1905       */
1906      public function test_can_process_deletion($status, $expected) {
1907          $purpose = new expired_context(0, (object) [
1908              'status' => $status,
1909  
1910              'contextid' => \context_system::instance()->id,
1911          ]);
1912  
1913          $this->assertEquals($expected, $purpose->can_process_deletion());
1914      }
1915  
1916      /**
1917       * Data provider for the can_process_deletion tests.
1918       *
1919       * @return  array
1920       */
1921      public function can_process_deletion_provider() : array {
1922          return [
1923              'Pending' => [
1924                  expired_context::STATUS_EXPIRED,
1925                  false,
1926              ],
1927              'Approved' => [
1928                  expired_context::STATUS_APPROVED,
1929                  true,
1930              ],
1931              'Complete' => [
1932                  expired_context::STATUS_CLEANED,
1933                  false,
1934              ],
1935          ];
1936      }
1937  
1938      /**
1939       * Test that the is_complete function returns expected results.
1940       *
1941       * @dataProvider        is_complete_provider
1942       * @param       int     $status
1943       * @param       bool    $expected
1944       */
1945      public function test_is_complete($status, $expected) {
1946          $purpose = new expired_context(0, (object) [
1947              'status' => $status,
1948              'contextid' => \context_system::instance()->id,
1949          ]);
1950  
1951          $this->assertEquals($expected, $purpose->is_complete());
1952      }
1953  
1954      /**
1955       * Data provider for the is_complete tests.
1956       *
1957       * @return  array
1958       */
1959      public function is_complete_provider() : array {
1960          return [
1961              'Pending' => [
1962                  expired_context::STATUS_EXPIRED,
1963                  false,
1964              ],
1965              'Approved' => [
1966                  expired_context::STATUS_APPROVED,
1967                  false,
1968              ],
1969              'Complete' => [
1970                  expired_context::STATUS_CLEANED,
1971                  true,
1972              ],
1973          ];
1974      }
1975  
1976      /**
1977       * Test that the is_fully_expired function returns expected results.
1978       *
1979       * @dataProvider        is_fully_expired_provider
1980       * @param       array   $record
1981       * @param       bool    $expected
1982       */
1983      public function test_is_fully_expired($record, $expected) {
1984          $purpose = new expired_context(0, (object) $record);
1985  
1986          $this->assertEquals($expected, $purpose->is_fully_expired());
1987      }
1988  
1989      /**
1990       * Data provider for the is_fully_expired tests.
1991       *
1992       * @return  array
1993       */
1994      public function is_fully_expired_provider() : array {
1995          return [
1996              'Fully expired' => [
1997                  [
1998                      'status' => expired_context::STATUS_APPROVED,
1999                      'defaultexpired' => 1,
2000                  ],
2001                  true,
2002              ],
2003              'Unexpired roles present' => [
2004                  [
2005                      'status' => expired_context::STATUS_APPROVED,
2006                      'defaultexpired' => 1,
2007                      'unexpiredroles' => json_encode([1]),
2008                  ],
2009                  false,
2010              ],
2011              'Only some expired roles present' => [
2012                  [
2013                      'status' => expired_context::STATUS_APPROVED,
2014                      'defaultexpired' => 0,
2015                      'expiredroles' => json_encode([1]),
2016                  ],
2017                  false,
2018              ],
2019          ];
2020      }
2021  
2022      /**
2023       * Ensure that any orphaned records are removed once the context has been removed.
2024       */
2025      public function test_orphaned_records_are_cleared() {
2026          $this->resetAfterTest();
2027  
2028          $this->setup_basics('PT1H', 'PT1H', 'PT1H', 'PT1H');
2029  
2030          $course = $this->getDataGenerator()->create_course([
2031                  'startdate' => time() - (2 * YEARSECS),
2032                  'enddate' => time() - YEARSECS,
2033              ]);
2034          $context = \context_course::instance($course->id);
2035  
2036          // Flag all expired contexts.
2037          $manager = new \tool_dataprivacy\expired_contexts_manager();
2038          $manager->set_progress(new \null_progress_trace());
2039          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
2040  
2041          $this->assertEquals(1, $flaggedcourses);
2042          $this->assertEquals(0, $flaggedusers);
2043  
2044          // Ensure that the record currently exists.
2045          $expiredcontext = expired_context::get_record(['contextid' => $context->id]);
2046          $this->assertNotFalse($expiredcontext);
2047  
2048          // Approve it.
2049          $expiredcontext->set('status', expired_context::STATUS_APPROVED)->save();
2050  
2051          // Process deletions.
2052          list($processedcourses, $processedusers) = $manager->process_approved_deletions();
2053  
2054          $this->assertEquals(1, $processedcourses);
2055          $this->assertEquals(0, $processedusers);
2056  
2057          // Ensure that the record still exists.
2058          $expiredcontext = expired_context::get_record(['contextid' => $context->id]);
2059          $this->assertNotFalse($expiredcontext);
2060  
2061          // Remove the actual course.
2062          delete_course($course->id, false);
2063  
2064          // The record will still exist until we flag it again.
2065          $expiredcontext = expired_context::get_record(['contextid' => $context->id]);
2066          $this->assertNotFalse($expiredcontext);
2067  
2068          list($flaggedcourses, $flaggedusers) = $manager->flag_expired_contexts();
2069          $expiredcontext = expired_context::get_record(['contextid' => $context->id]);
2070          $this->assertFalse($expiredcontext);
2071      }
2072  
2073      /**
2074       * Ensure that the progres tracer works as expected out of the box.
2075       */
2076      public function test_progress_tracer_default() {
2077          $manager = new \tool_dataprivacy\expired_contexts_manager();
2078  
2079          $rc = new \ReflectionClass(\tool_dataprivacy\expired_contexts_manager::class);
2080          $rcm = $rc->getMethod('get_progress');
2081  
2082          $rcm->setAccessible(true);
2083          $this->assertInstanceOf(\text_progress_trace::class, $rcm->invoke($manager));
2084      }
2085  
2086      /**
2087       * Ensure that the progres tracer works as expected when given a specific traer.
2088       */
2089      public function test_progress_tracer_set() {
2090          $manager = new \tool_dataprivacy\expired_contexts_manager();
2091          $mytrace = new \null_progress_trace();
2092          $manager->set_progress($mytrace);
2093  
2094          $rc = new \ReflectionClass(\tool_dataprivacy\expired_contexts_manager::class);
2095          $rcm = $rc->getMethod('get_progress');
2096  
2097          $rcm->setAccessible(true);
2098          $this->assertSame($mytrace, $rcm->invoke($manager));
2099      }
2100  
2101      /**
2102       * Creates an HTML block on a user.
2103       *
2104       * @param   string  $title
2105       * @param   string  $body
2106       * @param   string  $format
2107       * @return  \block_instance
2108       */
2109      protected function create_user_block($title, $body, $format) {
2110          global $USER;
2111  
2112          $configdata = (object) [
2113              'title' => $title,
2114              'text' => [
2115                  'itemid' => 19,
2116                  'text' => $body,
2117                  'format' => $format,
2118              ],
2119          ];
2120  
2121          $this->create_block($this->construct_user_page($USER));
2122          $block = $this->get_last_block_on_page($this->construct_user_page($USER));
2123          $block = block_instance('html', $block->instance);
2124          $block->instance_config_save((object) $configdata);
2125  
2126          return $block;
2127      }
2128  
2129      /**
2130       * Creates an HTML block on a page.
2131       *
2132       * @param \page $page Page
2133       */
2134      protected function create_block($page) {
2135          $page->blocks->add_block_at_end_of_default_region('html');
2136      }
2137  
2138      /**
2139       * Constructs a Page object for the User Dashboard.
2140       *
2141       * @param   \stdClass       $user User to create Dashboard for.
2142       * @return  \moodle_page
2143       */
2144      protected function construct_user_page(\stdClass $user) {
2145          $page = new \moodle_page();
2146          $page->set_context(\context_user::instance($user->id));
2147          $page->set_pagelayout('mydashboard');
2148          $page->set_pagetype('my-index');
2149          $page->blocks->load_blocks();
2150          return $page;
2151      }
2152  
2153      /**
2154       * Get the last block on the page.
2155       *
2156       * @param \page $page Page
2157       * @return \block_html Block instance object
2158       */
2159      protected function get_last_block_on_page($page) {
2160          $blocks = $page->blocks->get_blocks_for_region($page->blocks->get_default_region());
2161          $block = end($blocks);
2162  
2163          return $block;
2164      }
2165  
2166      /**
2167       * Test the is_context_expired functions when supplied with the system context.
2168       */
2169      public function test_is_context_expired_system() {
2170          $this->resetAfterTest();
2171          $this->setup_basics('PT1H', 'PT1H', 'P1D');
2172          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2173  
2174          $this->assertFalse(expired_contexts_manager::is_context_expired(\context_system::instance()));
2175          $this->assertFalse(
2176                  expired_contexts_manager::is_context_expired_or_unprotected_for_user(\context_system::instance(), $user));
2177      }
2178  
2179      /**
2180       * Test the is_context_expired functions when supplied with a block in the user context.
2181       *
2182       * Children of a user context always follow the user expiry rather than any context level defaults (e.g. at the
2183       * block level.
2184       */
2185      public function test_is_context_expired_user_block() {
2186          $this->resetAfterTest();
2187  
2188          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P1D');
2189          $purposes->block = $this->create_and_set_purpose_for_contextlevel('P5Y', CONTEXT_BLOCK);
2190  
2191          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2192          $this->setUser($user);
2193          $block = $this->create_user_block('Title', 'Content', FORMAT_PLAIN);
2194          $blockcontext = \context_block::instance($block->instance->id);
2195          $this->setUser();
2196  
2197          // Protected flags have no bearing on expiry of user subcontexts.
2198          $this->assertTrue(expired_contexts_manager::is_context_expired($blockcontext));
2199  
2200          $purposes->block->set('protected', 1)->save();
2201          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($blockcontext, $user));
2202  
2203          $purposes->block->set('protected', 0)->save();
2204          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($blockcontext, $user));
2205      }
2206  
2207      /**
2208       * Test the is_context_expired functions when supplied with the front page course.
2209       */
2210      public function test_is_context_expired_frontpage() {
2211          $this->resetAfterTest();
2212  
2213          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P1D');
2214  
2215          $frontcourse = get_site();
2216          $frontcoursecontext = \context_course::instance($frontcourse->id);
2217  
2218          $sitenews = $this->getDataGenerator()->create_module('forum', ['course' => $frontcourse->id]);
2219          $cm = get_coursemodule_from_instance('forum', $sitenews->id);
2220          $sitenewscontext = \context_module::instance($cm->id);
2221  
2222          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2223  
2224          $this->assertFalse(expired_contexts_manager::is_context_expired($frontcoursecontext));
2225          $this->assertFalse(expired_contexts_manager::is_context_expired($sitenewscontext));
2226  
2227          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($frontcoursecontext, $user));
2228          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($sitenewscontext, $user));
2229  
2230          // Protecting the course contextlevel does not impact the front page.
2231          $purposes->course->set('protected', 1)->save();
2232          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($frontcoursecontext, $user));
2233          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($sitenewscontext, $user));
2234  
2235          // Protecting the system contextlevel affects the front page, too.
2236          $purposes->system->set('protected', 1)->save();
2237          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($frontcoursecontext, $user));
2238          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($sitenewscontext, $user));
2239      }
2240  
2241      /**
2242       * Test the is_context_expired functions when supplied with an expired course.
2243       */
2244      public function test_is_context_expired_course_expired() {
2245          $this->resetAfterTest();
2246  
2247          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P1D');
2248  
2249          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2250          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time()]);
2251          $coursecontext = \context_course::instance($course->id);
2252  
2253          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2254  
2255          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2256  
2257          $purposes->course->set('protected', 1)->save();
2258          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2259  
2260          $purposes->course->set('protected', 0)->save();
2261          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2262      }
2263  
2264      /**
2265       * Test the is_context_expired functions when supplied with an unexpired course.
2266       */
2267      public function test_is_context_expired_course_unexpired() {
2268          $this->resetAfterTest();
2269  
2270          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P1D');
2271  
2272          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2273          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2274          $coursecontext = \context_course::instance($course->id);
2275  
2276          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2277  
2278          $this->assertTrue(expired_contexts_manager::is_context_expired($coursecontext));
2279  
2280          $purposes->course->set('protected', 1)->save();
2281          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2282  
2283          $purposes->course->set('protected', 0)->save();
2284          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2285      }
2286  
2287      /**
2288       * Test the is_context_expired functions when supplied with an unexpired course and a child context in the course which is protected.
2289       *
2290       * When a child context has a specific purpose set, then that purpose should be respected with respect to the
2291       * course.
2292       *
2293       * If the course is still within the expiry period for the child context, then that child's protected flag should be
2294       * respected, even when the course may have expired.
2295       */
2296      public function test_is_child_context_expired_course_unexpired_with_child() {
2297          $this->resetAfterTest();
2298  
2299          $purposes = $this->setup_basics('PT1H', 'PT1H', 'P1D', 'P1D');
2300          $purposes->course->set('protected', 0)->save();
2301          $purposes->activity->set('protected', 1)->save();
2302  
2303          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2304          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() + WEEKSECS]);
2305          $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course->id]);
2306  
2307          $coursecontext = \context_course::instance($course->id);
2308          $cm = get_coursemodule_from_instance('forum', $forum->id);
2309          $forumcontext = \context_module::instance($cm->id);
2310  
2311          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2312  
2313          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2314          $this->assertFalse(expired_contexts_manager::is_context_expired($forumcontext));
2315  
2316          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2317          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($forumcontext, $user));
2318  
2319          $purposes->activity->set('protected', 0)->save();
2320          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($forumcontext, $user));
2321      }
2322  
2323      /**
2324       * Test the is_context_expired functions when supplied with an expired course which has role overrides.
2325       */
2326      public function test_is_context_expired_course_expired_override() {
2327          global $DB;
2328  
2329          $this->resetAfterTest();
2330  
2331          $purposes = $this->setup_basics('PT1H', 'PT1H', 'PT1H');
2332  
2333          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2334          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2335          $coursecontext = \context_course::instance($course->id);
2336          $systemcontext = \context_system::instance();
2337  
2338          $role = $DB->get_record('role', ['shortname' => 'manager']);
2339          $override = new purpose_override(0, (object) [
2340                  'purposeid' => $purposes->course->get('id'),
2341                  'roleid' => $role->id,
2342                  'retentionperiod' => 'P5Y',
2343              ]);
2344          $override->save();
2345          role_assign($role->id, $user->id, $systemcontext->id);
2346  
2347          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2348  
2349          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2350  
2351          $purposes->course->set('protected', 1)->save();
2352          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2353  
2354          $purposes->course->set('protected', 0)->save();
2355          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2356      }
2357  
2358      /**
2359       * Test the is_context_expired functions when supplied with an expired course which has role overrides.
2360       */
2361      public function test_is_context_expired_course_expired_override_parent() {
2362          global $DB;
2363  
2364          $this->resetAfterTest();
2365  
2366          $purposes = $this->setup_basics('PT1H', 'PT1H');
2367  
2368          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2369          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2370          $coursecontext = \context_course::instance($course->id);
2371          $systemcontext = \context_system::instance();
2372  
2373          $role = $DB->get_record('role', ['shortname' => 'manager']);
2374          $override = new purpose_override(0, (object) [
2375                  'purposeid' => $purposes->system->get('id'),
2376                  'roleid' => $role->id,
2377                  'retentionperiod' => 'P5Y',
2378              ]);
2379          $override->save();
2380          role_assign($role->id, $user->id, $systemcontext->id);
2381  
2382          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2383  
2384          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2385  
2386          // The user override applies to this user. THIs means that the default expiry has no effect.
2387          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2388  
2389          $purposes->system->set('protected', 1)->save();
2390          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2391  
2392          $purposes->system->set('protected', 0)->save();
2393          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2394  
2395          $override->set('protected', 1)->save();
2396          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2397  
2398          $purposes->system->set('protected', 1)->save();
2399          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2400  
2401          $purposes->system->set('protected', 0)->save();
2402          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $user));
2403  
2404      }
2405  
2406      /**
2407       * Test the is_context_expired functions when supplied with an expired course which has role overrides but the user
2408       * does not hold the role.
2409       */
2410      public function test_is_context_expired_course_expired_override_parent_no_role() {
2411          global $DB;
2412  
2413          $this->resetAfterTest();
2414  
2415          $purposes = $this->setup_basics('PT1H', 'PT1H');
2416  
2417          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2418          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2419          $coursecontext = \context_course::instance($course->id);
2420          $systemcontext = \context_system::instance();
2421  
2422          $role = $DB->get_record('role', ['shortname' => 'manager']);
2423          $override = new purpose_override(0, (object) [
2424                  'purposeid' => $purposes->system->get('id'),
2425                  'roleid' => $role->id,
2426                  'retentionperiod' => 'P5Y',
2427              ]);
2428          $override->save();
2429  
2430          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2431  
2432          // This context is not _fully _ expired.
2433          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2434      }
2435  
2436      /**
2437       * Test the is_context_expired functions when supplied with an unexpired course which has role overrides.
2438       */
2439      public function test_is_context_expired_course_expired_override_inverse() {
2440          global $DB;
2441  
2442          $this->resetAfterTest();
2443  
2444          $purposes = $this->setup_basics('P1Y', 'P1Y');
2445  
2446          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2447          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2448          $coursecontext = \context_course::instance($course->id);
2449          $systemcontext = \context_system::instance();
2450  
2451          $role = $DB->get_record('role', ['shortname' => 'student']);
2452          $override = new purpose_override(0, (object) [
2453                  'purposeid' => $purposes->system->get('id'),
2454                  'roleid' => $role->id,
2455                  'retentionperiod' => 'PT1S',
2456              ]);
2457          $override->save();
2458  
2459          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2460  
2461          // This context is not _fully _ expired.
2462          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2463      }
2464  
2465      /**
2466       * Test the is_context_expired functions when supplied with an unexpired course which has role overrides.
2467       */
2468      public function test_is_context_expired_course_expired_override_inverse_parent() {
2469          global $DB;
2470  
2471          $this->resetAfterTest();
2472  
2473          $purposes = $this->setup_basics('P1Y', 'P1Y');
2474  
2475          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2476          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2477          $coursecontext = \context_course::instance($course->id);
2478          $systemcontext = \context_system::instance();
2479  
2480          $role = $DB->get_record('role', ['shortname' => 'manager']);
2481          $override = new purpose_override(0, (object) [
2482                  'purposeid' => $purposes->system->get('id'),
2483                  'roleid' => $role->id,
2484                  'retentionperiod' => 'PT1S',
2485              ]);
2486          $override->save();
2487  
2488          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2489          role_assign($role->id, $user->id, $systemcontext->id);
2490  
2491          $studentrole = $DB->get_record('role', ['shortname' => 'student']);
2492          role_unassign($studentrole->id, $user->id, $coursecontext->id);
2493  
2494          // This context is not _fully _ expired.
2495          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2496      }
2497  
2498      /**
2499       * Test the is_context_expired functions when supplied with an unexpired course which has role overrides.
2500       */
2501      public function test_is_context_expired_course_expired_override_inverse_parent_not_assigned() {
2502          global $DB;
2503  
2504          $this->resetAfterTest();
2505  
2506          $purposes = $this->setup_basics('P1Y', 'P1Y');
2507  
2508          $user = $this->getDataGenerator()->create_user(['lastaccess' => time() - YEARSECS]);
2509          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - WEEKSECS]);
2510          $coursecontext = \context_course::instance($course->id);
2511          $systemcontext = \context_system::instance();
2512  
2513          $role = $DB->get_record('role', ['shortname' => 'manager']);
2514          $override = new purpose_override(0, (object) [
2515                  'purposeid' => $purposes->system->get('id'),
2516                  'roleid' => $role->id,
2517                  'retentionperiod' => 'PT1S',
2518              ]);
2519          $override->save();
2520  
2521          // Enrol the user in the course without any role.
2522          $this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
2523          $studentrole = $DB->get_record('role', ['shortname' => 'student']);
2524          role_unassign($studentrole->id, $user->id, $coursecontext->id);
2525  
2526          // This context is not _fully _ expired.
2527          $this->assertFalse(expired_contexts_manager::is_context_expired($coursecontext));
2528      }
2529  
2530      /**
2531       * Ensure that context expired checks for a specific user taken into account roles.
2532       */
2533      public function test_is_context_expired_or_unprotected_for_user_role_mixtures_protected() {
2534          global $DB;
2535  
2536          $this->resetAfterTest();
2537  
2538          $purposes = $this->setup_basics('PT1S', 'PT1S', 'PT1S');
2539  
2540          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - DAYSECS]);
2541          $coursecontext = \context_course::instance($course->id);
2542          $systemcontext = \context_system::instance();
2543  
2544          $roles = $DB->get_records_menu('role', [], 'id', 'shortname, id');
2545          $override = new purpose_override(0, (object) [
2546                  'purposeid' => $purposes->course->get('id'),
2547                  'roleid' => $roles['manager'],
2548                  'retentionperiod' => 'P1W',
2549                  'protected' => 1,
2550              ]);
2551          $override->save();
2552  
2553          $s = $this->getDataGenerator()->create_user();
2554          $this->getDataGenerator()->enrol_user($s->id, $course->id, 'student');
2555  
2556          $t = $this->getDataGenerator()->create_user();
2557          $this->getDataGenerator()->enrol_user($t->id, $course->id, 'teacher');
2558  
2559          $sm = $this->getDataGenerator()->create_user();
2560          $this->getDataGenerator()->enrol_user($sm->id, $course->id, 'student');
2561          role_assign($roles['manager'], $sm->id, $coursecontext->id);
2562  
2563          $m = $this->getDataGenerator()->create_user();
2564          role_assign($roles['manager'], $m->id, $coursecontext->id);
2565  
2566          $tm = $this->getDataGenerator()->create_user();
2567          $this->getDataGenerator()->enrol_user($t->id, $course->id, 'teacher');
2568          role_assign($roles['manager'], $tm->id, $coursecontext->id);
2569  
2570          // The context should only be expired for users who are not a manager.
2571          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $s));
2572          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $t));
2573          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $sm));
2574          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $tm));
2575          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $m));
2576  
2577          $override->set('protected', 0)->save();
2578          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $s));
2579          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $t));
2580          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $sm));
2581          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $tm));
2582          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $m));
2583      }
2584  
2585      /**
2586       * Ensure that context expired checks for a specific user taken into account roles when retention is inversed.
2587       */
2588      public function test_is_context_expired_or_unprotected_for_user_role_mixtures_protected_inverse() {
2589          global $DB;
2590  
2591          $this->resetAfterTest();
2592  
2593          $purposes = $this->setup_basics('P5Y', 'P5Y', 'P5Y');
2594  
2595          $course = $this->getDataGenerator()->create_course(['startdate' => time() - YEARSECS, 'enddate' => time() - DAYSECS]);
2596          $coursecontext = \context_course::instance($course->id);
2597          $systemcontext = \context_system::instance();
2598  
2599          $roles = $DB->get_records_menu('role', [], 'id', 'shortname, id');
2600          $override = new purpose_override(0, (object) [
2601                  'purposeid' => $purposes->course->get('id'),
2602                  'roleid' => $roles['student'],
2603                  'retentionperiod' => 'PT1S',
2604              ]);
2605          $override->save();
2606  
2607          $s = $this->getDataGenerator()->create_user();
2608          $this->getDataGenerator()->enrol_user($s->id, $course->id, 'student');
2609  
2610          $t = $this->getDataGenerator()->create_user();
2611          $this->getDataGenerator()->enrol_user($t->id, $course->id, 'teacher');
2612  
2613          $sm = $this->getDataGenerator()->create_user();
2614          $this->getDataGenerator()->enrol_user($sm->id, $course->id, 'student');
2615          role_assign($roles['manager'], $sm->id, $coursecontext->id);
2616  
2617          $m = $this->getDataGenerator()->create_user();
2618          role_assign($roles['manager'], $m->id, $coursecontext->id);
2619  
2620          $tm = $this->getDataGenerator()->create_user();
2621          $this->getDataGenerator()->enrol_user($t->id, $course->id, 'teacher');
2622          role_assign($roles['manager'], $tm->id, $coursecontext->id);
2623  
2624          // The context should only be expired for users who are only a student.
2625          $purposes->course->set('protected', 1)->save();
2626          $override->set('protected', 1)->save();
2627          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $s));
2628          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $t));
2629          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $sm));
2630          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $tm));
2631          $this->assertFalse(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $m));
2632  
2633          $purposes->course->set('protected', 0)->save();
2634          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $s));
2635          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $t));
2636          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $sm));
2637          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $tm));
2638          $this->assertTrue(expired_contexts_manager::is_context_expired_or_unprotected_for_user($coursecontext, $m));
2639      }
2640  }