comment/tests/privacy_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16 /**
  17  * Privacy tests for core_comment.
  18  *
  19  * @package    core_comment
  20  * @category   test
  21  * @copyright  2018 Adrian Greeve <adrian@moodle.com>
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26 global $CFG;
  27
  28 require_once($CFG->dirroot . '/comment/locallib.php');
  29 require_once($CFG->dirroot . '/comment/lib.php');
  30
  31 use \core_privacy\tests\provider_testcase;
  32
  33 /**
  34  * Unit tests for comment/classes/privacy/policy
  35  *
  36  * @copyright  2018 Adrian Greeve <adrian@moodle.com>
  37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38  */
  39 class core_comment_privacy_testcase extends provider_testcase {
  40
  41     protected function setUp(): void {
  42         $this->resetAfterTest();
  43     }
  44
  45     /**
  46      * Check the exporting of comments for a user id in a context.
  47      */
  48     public function test_export_comments() {
  49         $course = $this->getDataGenerator()->create_course();
  50         $context = context_course::instance($course->id);
  51
  52         $comment = $this->get_comment_object($context, $course);
  53
  54         $user1 = $this->getDataGenerator()->create_user();
  55         $user2 = $this->getDataGenerator()->create_user();
  56
  57         // Add comments.
  58         $comments = [];
  59         $firstcomment = 'This is the first comment';
  60         $this->setUser($user1);
  61         $comment->add($firstcomment);
  62         $comments[$user1->id] = $firstcomment;
  63
  64         $secondcomment = 'From the second user';
  65         $this->setUser($user2);
  66         $comment->add($secondcomment);
  67         $comments[$user2->id] = $secondcomment;
  68
  69         // Retrieve comments only for user1.
  70         $this->setUser($user1);
  71         $writer = \core_privacy\local\request\writer::with_context($context);
  72         \core_comment\privacy\provider::export_comments($context, 'block_comments', 'page_comments', 0, []);
  73
  74         $data = $writer->get_data([get_string('commentsubcontext', 'core_comment')]);
  75         $exportedcomments = $data->comments;
  76
  77         // There is only one comment made by this user.
  78         $this->assertCount(1, $exportedcomments);
  79         $comment = reset($exportedcomments);
  80         $this->assertEquals($comments[$user1->id], format_string($comment->content, FORMAT_PLAIN));
  81
  82         // Retrieve comments from any user.
  83         \core_comment\privacy\provider::export_comments($context, 'block_comments', 'page_comments', 0, [], false);
  84
  85         $data = $writer->get_data([get_string('commentsubcontext', 'core_comment')]);
  86         $exportedcomments = $data->comments;
  87
  88         // The whole conversation is two comments.
  89         $this->assertCount(2, $exportedcomments);
  90         foreach ($exportedcomments as $comment) {
  91             $this->assertEquals($comments[$comment->userid], format_string($comment->content, FORMAT_PLAIN));
  92         }
  93     }
  94
  95     /**
  96      * Tests the deletion of all comments in a context.
  97      */
  98     public function test_delete_comments_for_all_users() {
  99         global $DB;
 100
 101         $course1 = $this->getDataGenerator()->create_course();
 102         $course2 = $this->getDataGenerator()->create_course();
 103
 104         $coursecontext1 = context_course::instance($course1->id);
 105         $coursecontext2 = context_course::instance($course2->id);
 106
 107         $user1 = $this->getDataGenerator()->create_user();
 108         $user2 = $this->getDataGenerator()->create_user();
 109
 110         $comment1 = $this->get_comment_object($coursecontext1, $course1);
 111         $comment2 = $this->get_comment_object($coursecontext2, $course2);
 112
 113         $this->setUser($user1);
 114         $comment1->add('First comment for user 1 on comment 1');
 115         $comment2->add('First comment for user 1 on comment 2');
 116         $this->setUser($user2);
 117         $comment1->add('First comment for user 2 on comment 1');
 118         $comment2->add('First comment for user 2 on comment 2');
 119
 120         // Because of the way things are set up with validation, creating an entry with the same context in a different component
 121         // or comment area is a huge pain. We're just going to jam entries into the table instead.
 122         $record = (object) [
 123             'contextid' => $coursecontext1->id,
 124             'component' => 'block_comments',
 125             'commentarea' => 'other_comments',
 126             'itemid' => 2,
 127             'content' => 'Comment user 1 different comment area',
 128             'format' => 0,
 129             'userid' => $user1->id,
 130             'timecreated' => time()
 131         ];
 132         $DB->insert_record('comments', $record);
 133         $record = (object) [
 134             'contextid' => $coursecontext1->id,
 135             'component' => 'tool_dataprivacy',
 136             'commentarea' => 'page_comments',
 137             'itemid' => 2,
 138             'content' => 'Comment user 1 different component',
 139             'format' => 0,
 140             'userid' => $user1->id,
 141             'timecreated' => time()
 142         ];
 143         $DB->insert_record('comments', $record);
 144
 145         // Delete only for the first context. All records in the comments table for this context should be removed.
 146         \core_comment\privacy\provider::delete_comments_for_all_users($coursecontext1, 'block_comments', 'page_comments', 0);
 147         // No records left here.
 148         $this->assertCount(0, $comment1->get_comments());
 149         // All of the records are left intact here.
 150         $this->assertCount(2, $comment2->get_comments());
 151         // Check the other comment area.
 152         $result = $DB->get_records('comments', ['commentarea' => 'other_comments']);
 153         $this->assertCount(1, $result);
 154         $data = array_shift($result);
 155         $this->assertEquals('other_comments', $data->commentarea);
 156         // Check the different component, same commentarea.
 157         $result = $DB->get_records('comments', ['component' => 'tool_dataprivacy']);
 158         $this->assertCount(1, $result);
 159         $data = array_shift($result);
 160         $this->assertEquals('tool_dataprivacy', $data->component);
 161     }
 162
 163     /**
 164      * Tests the deletion of all comments in a context.
 165      */
 166     public function test_delete_comments_for_all_users_select() {
 167         global $DB;
 168
 169         $course1 = $this->getDataGenerator()->create_course();
 170         $course2 = $this->getDataGenerator()->create_course();
 171
 172         $coursecontext1 = context_course::instance($course1->id);
 173         $coursecontext2 = context_course::instance($course2->id);
 174
 175         $user1 = $this->getDataGenerator()->create_user();
 176         $user2 = $this->getDataGenerator()->create_user();
 177
 178         $comment1 = $this->get_comment_object($coursecontext1, $course1);
 179         $comment2 = $this->get_comment_object($coursecontext2, $course2);
 180
 181         $this->setUser($user1);
 182         $comment1->add('First comment for user 1 on comment 1');
 183         $comment2->add('First comment for user 1 on comment 2');
 184         $this->setUser($user2);
 185         $comment1->add('First comment for user 2 on comment 1');
 186         $comment2->add('First comment for user 2 on comment 2');
 187
 188         // Because of the way things are set up with validation, creating an entry with the same context in a different component
 189         // or comment area is a huge pain. We're just going to jam entries into the table instead.
 190         $record = (object) [
 191             'contextid' => $coursecontext1->id,
 192             'component' => 'block_comments',
 193             'commentarea' => 'other_comments',
 194             'itemid' => 2,
 195             'content' => 'Comment user 1 different comment area',
 196             'format' => 0,
 197             'userid' => $user1->id,
 198             'timecreated' => time()
 199         ];
 200         $DB->insert_record('comments', $record);
 201         $record = (object) [
 202             'contextid' => $coursecontext1->id,
 203             'component' => 'tool_dataprivacy',
 204             'commentarea' => 'page_comments',
 205             'itemid' => 2,
 206             'content' => 'Comment user 1 different component',
 207             'format' => 0,
 208             'userid' => $user1->id,
 209             'timecreated' => time()
 210         ];
 211         $DB->insert_record('comments', $record);
 212
 213         // Delete only for the first context. All records in the comments table for this context should be removed.
 214         list($sql, $params) = $DB->get_in_or_equal([0, 1, 2, 3], SQL_PARAMS_NAMED);
 215         \core_comment\privacy\provider::delete_comments_for_all_users_select($coursecontext1,
 216             'block_comments', 'page_comments', $sql, $params);
 217         // No records left here.
 218         $this->assertCount(0, $comment1->get_comments());
 219         // All of the records are left intact here.
 220         $this->assertCount(2, $comment2->get_comments());
 221         // Check the other comment area.
 222         $result = $DB->get_records('comments', ['commentarea' => 'other_comments']);
 223         $this->assertCount(1, $result);
 224         $data = array_shift($result);
 225         $this->assertEquals('other_comments', $data->commentarea);
 226         // Check the different component, same commentarea.
 227         $result = $DB->get_records('comments', ['component' => 'tool_dataprivacy']);
 228         $this->assertCount(1, $result);
 229         $data = array_shift($result);
 230         $this->assertEquals('tool_dataprivacy', $data->component);
 231     }
 232
 233     /**
 234      * Tests deletion of comments for a specified user and contexts.
 235      */
 236     public function test_delete_comments_for_user() {
 237         global $DB;
 238
 239         $course1 = $this->getDataGenerator()->create_course();
 240         $course2 = $this->getDataGenerator()->create_course();
 241         $course3 = $this->getDataGenerator()->create_course();
 242
 243         $coursecontext1 = context_course::instance($course1->id);
 244         $coursecontext2 = context_course::instance($course2->id);
 245         $coursecontext3 = context_course::instance($course3->id);
 246
 247         $user1 = $this->getDataGenerator()->create_user();
 248         $user2 = $this->getDataGenerator()->create_user();
 249
 250         $comment1 = $this->get_comment_object($coursecontext1, $course1);
 251         $comment2 = $this->get_comment_object($coursecontext2, $course2);
 252         $comment3 = $this->get_comment_object($coursecontext3, $course3);
 253
 254         $this->setUser($user1);
 255         $comment1->add('First comment for user 1');
 256         $comment2->add('User 1 comment in second comment');
 257
 258         $this->setUser($user2);
 259         $comment2->add('User two replied in comment two');
 260         $comment3->add('Comment three for user 2.');
 261
 262         // Because of the way things are set up with validation, creating an entry with the same context in a different component
 263         // or comment area is a huge pain. We're just going to jam entries into the table instead.
 264         $record = (object) [
 265             'contextid' => $coursecontext1->id,
 266             'component' => 'block_comments',
 267             'commentarea' => 'other_comments',
 268             'itemid' => 2,
 269             'content' => 'Comment user 1 different comment area',
 270             'format' => 0,
 271             'userid' => $user1->id,
 272             'timecreated' => time()
 273         ];
 274         $DB->insert_record('comments', $record);
 275         $record = (object) [
 276             'contextid' => $coursecontext1->id,
 277             'component' => 'tool_dataprivacy',
 278             'commentarea' => 'page_comments',
 279             'itemid' => 2,
 280             'content' => 'Comment user 1 different component',
 281             'format' => 0,
 282             'userid' => $user1->id,
 283             'timecreated' => time()
 284         ];
 285         $DB->insert_record('comments', $record);
 286
 287         // Delete the comments for user 1.
 288         $approvedcontextlist = new core_privacy\tests\request\approved_contextlist($user1, 'block_comments',
 289                 [$coursecontext1->id, $coursecontext2->id]);
 290         \core_comment\privacy\provider::delete_comments_for_user($approvedcontextlist, 'block_comments', 'page_comments', 0);
 291
 292         // No comments left in comments 1 as only user 1 commented there.
 293         $this->assertCount(0, $comment1->get_comments());
 294         // Only user 2 comments left in comments 2.
 295         $comment2comments = $comment2->get_comments();
 296         $this->assertCount(1, $comment2comments);
 297         $data = array_shift($comment2comments);
 298         $this->assertEquals($user2->id, $data->userid);
 299         // Nothing changed here as user 1 did not leave a comment.
 300         $comment3comments = $comment3->get_comments();
 301         $this->assertCount(1, $comment3comments);
 302         $data = array_shift($comment3comments);
 303         $this->assertEquals($user2->id, $data->userid);
 304         // Check the other comment area.
 305         $result = $DB->get_records('comments', ['commentarea' => 'other_comments']);
 306         $this->assertCount(1, $result);
 307         $data = array_shift($result);
 308         $this->assertEquals('other_comments', $data->commentarea);
 309         // Check the different component, same commentarea.
 310         $result = $DB->get_records('comments', ['component' => 'tool_dataprivacy']);
 311         $this->assertCount(1, $result);
 312         $data = array_shift($result);
 313         $this->assertEquals('tool_dataprivacy', $data->component);
 314     }
 315
 316     /**
 317      * Tests deletion of comments for a specified userlist and context.
 318      */
 319     public function test_delete_comments_for_users() {
 320         global $DB;
 321
 322         $course1 = $this->getDataGenerator()->create_course();
 323         $course2 = $this->getDataGenerator()->create_course();
 324         $course3 = $this->getDataGenerator()->create_course();
 325
 326         $coursecontext1 = context_course::instance($course1->id);
 327         $coursecontext2 = context_course::instance($course2->id);
 328         $coursecontext3 = context_course::instance($course3->id);
 329
 330         $user1 = $this->getDataGenerator()->create_user();
 331         $user2 = $this->getDataGenerator()->create_user();
 332         $user3 = $this->getDataGenerator()->create_user();
 333
 334         $comment1 = $this->get_comment_object($coursecontext1, $course1);
 335         $comment2 = $this->get_comment_object($coursecontext2, $course2);
 336         $comment3 = $this->get_comment_object($coursecontext3, $course3);
 337
 338         $this->setUser($user1);
 339         $comment1->add('First comment for user 1');
 340         $comment2->add('User 1 comment in second comment');
 341
 342         $this->setUser($user2);
 343         $comment2->add('User two replied in comment two');
 344
 345         $this->setUser($user3);
 346         $comment2->add('User 3 also writing on comment 2, but will not be deleted');
 347         $comment3->add('Only user 3 commenting in comment 3.');
 348
 349         // Because of the way things are set up with validation, creating an entry with the same context in a different component
 350         // or comment area is a huge pain. We're just going to jam entries into the table instead.
 351         $record = (object) [
 352             'contextid' => $coursecontext1->id,
 353             'component' => 'block_comments',
 354             'commentarea' => 'other_comments',
 355             'itemid' => 2,
 356             'content' => 'Comment user 1 different comment area',
 357             'format' => 0,
 358             'userid' => $user1->id,
 359             'timecreated' => time()
 360         ];
 361         $DB->insert_record('comments', $record);
 362         $record = (object) [
 363             'contextid' => $coursecontext1->id,
 364             'component' => 'tool_dataprivacy',
 365             'commentarea' => 'page_comments',
 366             'itemid' => 2,
 367             'content' => 'Comment user 1 different component',
 368             'format' => 0,
 369             'userid' => $user1->id,
 370             'timecreated' => time()
 371         ];
 372         $DB->insert_record('comments', $record);
 373
 374         // Delete the comments for users 1 and 2 in all 3 contexts.
 375         $approvedusers = [$user1->id, $user2->id];
 376
 377         $approveduserlist = new core_privacy\local\request\approved_userlist($coursecontext1, 'block_comments', $approvedusers);
 378         \core_comment\privacy\provider::delete_comments_for_users($approveduserlist, 'block_comments', 'page_comments');
 379
 380         $approveduserlist = new core_privacy\local\request\approved_userlist($coursecontext2, 'block_comments', $approvedusers);
 381         \core_comment\privacy\provider::delete_comments_for_users($approveduserlist, 'block_comments', 'page_comments');
 382
 383         $approveduserlist = new core_privacy\local\request\approved_userlist($coursecontext3, 'block_comments', $approvedusers);
 384         \core_comment\privacy\provider::delete_comments_for_users($approveduserlist, 'block_comments', 'page_comments');
 385
 386         // No comments left in comments 1 as only user 1 commented there.
 387         $this->assertCount(0, $comment1->get_comments());
 388
 389         // Only user 3's comment left in comments 2 as user 1 and 2 were approved for deletion.
 390         $comment2comments = $comment2->get_comments();
 391         $this->assertCount(1, $comment2comments);
 392         $comment2comment = array_shift($comment2comments);
 393         $this->assertEquals($user3->id, $comment2comment->userid);
 394
 395         // Nothing changed here as user 1 and 2 did not leave a comment.
 396         $comment3comments = $comment3->get_comments();
 397         $this->assertCount(1, $comment3comments);
 398         $data = array_shift($comment3comments);
 399         $this->assertEquals($user3->id, $data->userid);
 400
 401         // Check the other comment area.
 402         $result = $DB->get_records('comments', ['commentarea' => 'other_comments']);
 403         $this->assertCount(1, $result);
 404         $data = array_shift($result);
 405         $this->assertEquals('other_comments', $data->commentarea);
 406
 407         // Check the different component, same commentarea.
 408         $result = $DB->get_records('comments', ['component' => 'tool_dataprivacy']);
 409         $this->assertCount(1, $result);
 410         $data = array_shift($result);
 411         $this->assertEquals('tool_dataprivacy', $data->component);
 412     }
 413
 414     /**
 415      * Creates a comment object
 416      *
 417      * @param  context $context A context object.
 418      * @param  stdClass $course A course object.
 419      * @return comment The comment object.
 420      */
 421     protected function get_comment_object($context, $course) {
 422         // Comment on course page.
 423         $args = new stdClass;
 424         $args->context = $context;
 425         $args->course = $course;
 426         $args->area = 'page_comments';
 427         $args->itemid = 0;
 428         $args->component = 'block_comments';
 429         $comment = new comment($args);
 430         $comment->set_post_permission(true);
 431         return $comment;
 432     }
 433 }