blog/tests/external_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Unit tests for blog external API.
  19  *
  20  * @package    core_blog
  21  * @copyright  2018 Juan Leyva
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 global $CFG;
  28 require_once($CFG->dirroot . '/blog/locallib.php');
  29 require_once($CFG->dirroot . '/blog/lib.php');
  30
  31 /**
  32  * Unit tests for blog external API.
  33  *
  34  * @package    core_blog
  35  * @copyright  2018 Juan Leyva
  36  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37  */
  38 class core_blog_external_testcase extends advanced_testcase {
  39
  40     private $courseid;
  41     private $cmid;
  42     private $userid;
  43     private $groupid;
  44     private $tagid;
  45     private $postid;
  46
  47     protected function setUp() {
  48         global $DB, $CFG;
  49         parent::setUp();
  50
  51         $this->resetAfterTest();
  52
  53         // Create default course.
  54         $course = $this->getDataGenerator()->create_course(array('category' => 1, 'shortname' => 'ANON'));
  55         $this->assertNotEmpty($course);
  56         $page = $this->getDataGenerator()->create_module('page', array('course' => $course->id));
  57         $this->assertNotEmpty($page);
  58
  59         // Create default user.
  60         $user = $this->getDataGenerator()->create_user(array(
  61                 'username' => 'testuser',
  62                 'firstname' => 'Jimmy',
  63                 'lastname' => 'Kinnon'
  64         ));
  65         // Enrol user.
  66         $this->getDataGenerator()->enrol_user($user->id, $course->id);
  67
  68         $group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
  69         $this->getDataGenerator()->create_group_member(array('groupid' => $group->id, 'userid' => $user->id));
  70
  71         // Create default post.
  72         $post = new stdClass();
  73         $post->userid = $user->id;
  74         $post->courseid = $course->id;
  75         $post->groupid = $group->id;
  76         $post->content = 'test post content text';
  77         $post->module = 'blog';
  78         $post->id = $DB->insert_record('post', $post);
  79
  80         core_tag_tag::set_item_tags('core', 'post', $post->id, context_user::instance($user->id), array('tag1'));
  81         $tagid = $DB->get_field('tag', 'id', array('name' => 'tag1'));
  82
  83         // Grab important ids.
  84         $this->courseid = $course->id;
  85         $this->cmid = $page->cmid;
  86         $this->userid  = $user->id;
  87         $this->groupid  = $group->id;
  88         $this->tagid  = $tagid;
  89         $this->postid = $post->id;
  90         $this->publishstate = 'site';   // To be override in tests.
  91
  92         // Set default blog level.
  93         $CFG->bloglevel = BLOG_SITE_LEVEL;
  94     }
  95
  96     /**
  97      * Get global public entries even for not authenticated users.
  98      * We get the entry since is public.
  99      */
 100     public function test_get_public_entries_global_level_by_non_logged_users() {
 101         global $CFG, $DB;
 102
 103         $CFG->bloglevel = BLOG_GLOBAL_LEVEL;
 104         $CFG->forcelogin = 0;
 105         // Set current entry global.
 106         $DB->set_field('post', 'publishstate', 'public', array('id' => $this->postid));
 107
 108         $result = core_blog\external::get_entries();
 109         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 110         $this->assertCount(1, $result['entries']);
 111         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 112     }
 113
 114     /**
 115      * Get global public entries even for not authenticated users in closed site.
 116      */
 117     public function test_get_public_entries_global_level_by_non_logged_users_closed_site() {
 118         global $CFG, $DB;
 119
 120         $CFG->bloglevel = BLOG_GLOBAL_LEVEL;
 121         $CFG->forcelogin = 1;
 122         // Set current entry global.
 123         $DB->set_field('post', 'publishstate', 'public', array('id' => $this->postid));
 124
 125         $this->expectException('moodle_exception');
 126         core_blog\external::get_entries();
 127     }
 128
 129     /**
 130      * Get global public entries for guest users.
 131      * We get the entry since is public.
 132      */
 133     public function test_get_public_entries_global_level_by_guest_users() {
 134         global $CFG, $DB;
 135
 136         $CFG->bloglevel = BLOG_GLOBAL_LEVEL;
 137         // Set current entry global.
 138         $DB->set_field('post', 'publishstate', 'public', array('id' => $this->postid));
 139
 140         $this->setGuestUser();
 141         $result = core_blog\external::get_entries();
 142         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 143         $this->assertCount(1, $result['entries']);
 144         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 145     }
 146
 147     /**
 148      * Get global not public entries even for not authenticated users withouth being authenticated.
 149      * We don't get any because they are not public (restricted to site users).
 150      */
 151     public function test_get_not_public_entries_global_level_by_non_logged_users() {
 152         global $CFG;
 153
 154         $CFG->bloglevel = BLOG_GLOBAL_LEVEL;
 155
 156         $result = core_blog\external::get_entries();
 157         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 158         $this->assertCount(0, $result['entries']);
 159     }
 160
 161     /**
 162      * Get global not public entries users being guest.
 163      * We don't get any because they are not public (restricted to real site users).
 164      */
 165     public function test_get_not_public_entries_global_level_by_guest_user() {
 166         global $CFG;
 167
 168         $CFG->bloglevel = BLOG_GLOBAL_LEVEL;
 169
 170         $this->setGuestUser();
 171         $result = core_blog\external::get_entries();
 172         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 173         $this->assertCount(0, $result['entries']);
 174     }
 175
 176     /**
 177      * Get site not public entries for not authenticated users.
 178      * We don't get any because they are not public (restricted to real site users).
 179      */
 180     public function test_get_not_public_entries_site_level_by_non_logged_users() {
 181         $this->expectException('require_login_exception'); // In this case we get a security exception.
 182         $result = core_blog\external::get_entries();
 183     }
 184
 185     /**
 186      * Get site not public entries for guest users.
 187      * We don't get any because they are not public (restricted to real site users).
 188      */
 189     public function test_get_not_public_entries_site_level_by_guest_users() {
 190
 191         $this->setGuestUser();
 192         $result = core_blog\external::get_entries();
 193         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 194         $this->assertCount(0, $result['entries']);
 195     }
 196
 197     /**
 198      * Get site entries at site level by system users.
 199      */
 200     public function test_get_site_entries_site_level_by_normal_users() {
 201
 202         $this->setUser($this->userid);
 203         $result = core_blog\external::get_entries();
 204         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 205         $this->assertCount(1, $result['entries']);
 206         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 207     }
 208
 209     /**
 210      * Get draft site entries by authors.
 211      */
 212     public function test_get_draft_entries_site_level_by_author_users() {
 213         global $DB;
 214
 215         // Set current entry global.
 216         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 217
 218         $this->setUser($this->userid);
 219         $result = core_blog\external::get_entries();
 220         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 221         $this->assertCount(1, $result['entries']);
 222         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 223     }
 224
 225     /**
 226      * Get draft site entries by not authors.
 227      */
 228     public function test_get_draft_entries_site_level_by_not_author_users() {
 229         global $DB;
 230
 231         // Set current entry global.
 232         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 233         $user = $this->getDataGenerator()->create_user();
 234
 235         $this->setUser($user);
 236         $result = core_blog\external::get_entries();
 237         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 238         $this->assertCount(0, $result['entries']);
 239     }
 240
 241     /**
 242      * Get draft site entries by admin.
 243      */
 244     public function test_get_draft_entries_site_level_by_admin_users() {
 245         global $DB;
 246
 247         // Set current entry global.
 248         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 249         $user = $this->getDataGenerator()->create_user();
 250
 251         $this->setAdminUser();
 252         $result = core_blog\external::get_entries();
 253         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 254         $this->assertCount(1, $result['entries']);
 255         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 256     }
 257
 258     /**
 259      * Get draft user entries by authors.
 260      */
 261     public function test_get_draft_entries_user_level_by_author_users() {
 262         global $CFG, $DB;
 263
 264         $CFG->bloglevel = BLOG_USER_LEVEL;
 265         // Set current entry global.
 266         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 267
 268         $this->setUser($this->userid);
 269         $result = core_blog\external::get_entries();
 270         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 271         $this->assertCount(1, $result['entries']);
 272         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 273     }
 274
 275     /**
 276      * Get draft user entries by not authors.
 277      */
 278     public function test_get_draft_entries_user_level_by_not_author_users() {
 279         global $CFG, $DB;
 280
 281         $CFG->bloglevel = BLOG_USER_LEVEL;
 282         // Set current entry global.
 283         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 284         $user = $this->getDataGenerator()->create_user();
 285
 286         $this->setUser($user);
 287         $result = core_blog\external::get_entries();
 288         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 289         $this->assertCount(0, $result['entries']);
 290     }
 291
 292     /**
 293      * Get draft user entries by admin.
 294      */
 295     public function test_get_draft_entries_user_level_by_admin_users() {
 296         global $CFG, $DB;
 297
 298         $CFG->bloglevel = BLOG_USER_LEVEL;
 299         // Set current entry global.
 300         $DB->set_field('post', 'publishstate', 'draft', array('id' => $this->postid));
 301         $user = $this->getDataGenerator()->create_user();
 302
 303         $this->setAdminUser();
 304         $result = core_blog\external::get_entries();
 305         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 306         $this->assertCount(1, $result['entries']);
 307         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 308     }
 309
 310     /**
 311      * Test get all entries including testing pagination.
 312      */
 313     public function test_get_all_entries_including_pagination() {
 314         global $DB, $USER;
 315
 316         $DB->set_field('post', 'publishstate', 'site', array('id' => $this->postid));
 317
 318         // Create another entry.
 319         $this->setAdminUser();
 320         $newpost = new stdClass();
 321         $newpost->userid = $USER->id;
 322         $newpost->content = 'test post content text';
 323         $newpost->module = 'blog';
 324         $newpost->publishstate = 'site';
 325         $newpost->created = time() + HOURSECS;
 326         $newpost->lastmodified = time() + HOURSECS;
 327         $newpost->id = $DB->insert_record('post', $newpost);
 328
 329         $this->setUser($this->userid);
 330         $result = core_blog\external::get_entries();
 331         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 332         $this->assertCount(2, $result['entries']);
 333         $this->assertEquals(2, $result['totalentries']);
 334
 335         $result = core_blog\external::get_entries(array(), 0, 1);
 336         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 337         $this->assertCount(1, $result['entries']);
 338         $this->assertEquals(2, $result['totalentries']);
 339         $this->assertEquals($newpost->id, $result['entries'][0]['id']);
 340
 341         $result = core_blog\external::get_entries(array(), 1, 1);
 342         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 343         $this->assertCount(1, $result['entries']);
 344         $this->assertEquals(2, $result['totalentries']);
 345         $this->assertEquals($this->postid, $result['entries'][0]['id']);
 346     }
 347
 348     /**
 349      * Test get entries filtering by course.
 350      */
 351     public function test_get_entries_filtering_by_course() {
 352         global $CFG, $DB;
 353
 354         $DB->set_field('post', 'publishstate', 'site', array('id' => $this->postid));
 355
 356         $this->setAdminUser();
 357         $coursecontext = context_course::instance($this->courseid);
 358         $anothercourse = $this->getDataGenerator()->create_course();
 359
 360         // Add blog associations with a course.
 361         $blog = new blog_entry($this->postid);
 362         $blog->add_association($coursecontext->id);
 363
 364         // There is one entry associated with a course.
 365         $result = core_blog\external::get_entries(array(array('name' => 'courseid', 'value' => $this->courseid)));
 366         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 367         $this->assertCount(1, $result['entries']);
 368
 369         // There is no entry associated with a wrong course.
 370         $result = core_blog\external::get_entries(array(array('name' => 'courseid', 'value' => $anothercourse->id)));
 371         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 372         $this->assertCount(0, $result['entries']);
 373
 374         // There is no entry associated with a module.
 375         $result = core_blog\external::get_entries(array(array('name' => 'cmid', 'value' => $this->cmid)));
 376         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 377         $this->assertCount(0, $result['entries']);
 378     }
 379
 380     /**
 381      * Test get entries filtering by module.
 382      */
 383     public function test_get_entries_filtering_by_module() {
 384         global $CFG, $DB;
 385
 386         $DB->set_field('post', 'publishstate', 'site', array('id' => $this->postid));
 387
 388         $this->setAdminUser();
 389         $coursecontext = context_course::instance($this->courseid);
 390         $contextmodule = context_module::instance($this->cmid);
 391         $anothermodule = $this->getDataGenerator()->create_module('page', array('course' => $this->courseid));
 392
 393         // Add blog associations with a module.
 394         $blog = new blog_entry($this->postid);
 395         $blog->add_association($contextmodule->id);
 396
 397         // There is no entry associated with a course.
 398         $result = core_blog\external::get_entries(array(array('name' => 'courseid', 'value' => $this->courseid)));
 399         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 400         $this->assertCount(0, $result['entries']);
 401
 402         // There is one entry associated with a module.
 403         $result = core_blog\external::get_entries(array(array('name' => 'cmid', 'value' => $this->cmid)));
 404         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 405         $this->assertCount(1, $result['entries']);
 406
 407         // There is no entry associated with a wrong module.
 408         $result = core_blog\external::get_entries(array(array('name' => 'cmid', 'value' => $anothermodule->cmid)));
 409         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 410         $this->assertCount(0, $result['entries']);
 411     }
 412
 413     /**
 414      * Test get entries filtering by author.
 415      */
 416     public function test_get_entries_filtering_by_author() {
 417         $this->setAdminUser();
 418         // Filter by author.
 419         $result = core_blog\external::get_entries(array(array('name' => 'userid', 'value' => $this->userid)));
 420         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 421         $this->assertCount(1, $result['entries']);
 422         // No author.
 423         $anotheruser = $this->getDataGenerator()->create_user();
 424         $result = core_blog\external::get_entries(array(array('name' => 'userid', 'value' => $anotheruser->id)));
 425         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 426         $this->assertCount(0, $result['entries']);
 427     }
 428
 429     /**
 430      * Test get entries filtering by entry.
 431      */
 432     public function test_get_entries_filtering_by_entry() {
 433         $this->setAdminUser();
 434         // Filter by correct entry.
 435         $result = core_blog\external::get_entries(array(array('name' => 'entryid', 'value' => $this->postid)));
 436         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 437         $this->assertCount(1, $result['entries']);
 438         // Non-existent entry.
 439         $this->expectException('moodle_exception');
 440         $result = core_blog\external::get_entries(array(array('name' => 'entryid', 'value' => -1)));
 441     }
 442
 443     /**
 444      * Test get entries filtering by search.
 445      */
 446     public function test_get_entries_filtering_by_search() {
 447         $this->setAdminUser();
 448         // Filter by correct search.
 449         $result = core_blog\external::get_entries(array(array('name' => 'search', 'value' => 'test')));
 450         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 451         $this->assertCount(1, $result['entries']);
 452         // Non-existent search.
 453         $result = core_blog\external::get_entries(array(array('name' => 'search', 'value' => 'abc')));
 454         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 455         $this->assertCount(0, $result['entries']);
 456     }
 457
 458     /**
 459      * Test get entries filtering by tag.
 460      */
 461     public function test_get_entries_filtering_by_tag() {
 462         $this->setAdminUser();
 463         // Filter by correct tag.
 464         $result = core_blog\external::get_entries(array(array('name' => 'tag', 'value' => 'tag1')));
 465         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 466         $this->assertCount(1, $result['entries']);
 467         // Create tag.
 468         $tag = $this->getDataGenerator()->create_tag(array('userid' => $this->userid, 'name' => 'tag2',
 469             'isstandard' => 1));
 470
 471         $result = core_blog\external::get_entries(array(array('name' => 'tag', 'value' => 'tag2')));
 472         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 473         $this->assertCount(0, $result['entries']);
 474     }
 475
 476     /**
 477      * Test get entries filtering by tag id.
 478      */
 479     public function test_get_entries_filtering_by_tagid() {
 480         $this->setAdminUser();
 481         // Filter by correct tag.
 482         $result = core_blog\external::get_entries(array(array('name' => 'tagid', 'value' => $this->tagid)));
 483         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 484         $this->assertCount(1, $result['entries']);
 485         // Non-existent tag.
 486
 487         // Create tag.
 488         $tag = $this->getDataGenerator()->create_tag(array('userid' => $this->userid, 'name' => 'tag2',
 489             'isstandard' => 1));
 490
 491         $result = core_blog\external::get_entries(array(array('name' => 'tagid', 'value' => $tag->id)));
 492         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 493         $this->assertCount(0, $result['entries']);
 494     }
 495
 496     /**
 497      * Test get entries filtering by group.
 498      */
 499     public function test_get_entries_filtering_by_group() {
 500         $this->setAdminUser();
 501         // Add blog associations with a course.
 502         $coursecontext = context_course::instance($this->courseid);
 503         $blog = new blog_entry($this->postid);
 504         $blog->add_association($coursecontext->id);
 505
 506         // Filter by correct group.
 507         $result = core_blog\external::get_entries(array(array('name' => 'groupid', 'value' => $this->groupid)));
 508         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 509         $this->assertCount(1, $result['entries']);
 510         // Non-existent group.
 511         $anotheruser = $this->getDataGenerator()->create_user();
 512         $this->expectException('moodle_exception');
 513         core_blog\external::get_entries(array(array('name' => 'groupid', 'value' => -1)));
 514     }
 515
 516     /**
 517      * Test get entries multiple filter.
 518      */
 519     public function test_get_entries_multiple_filter() {
 520         $this->setAdminUser();
 521         // Add blog associations with a course.
 522         $coursecontext = context_course::instance($this->courseid);
 523         $blog = new blog_entry($this->postid);
 524         $blog->add_association($coursecontext->id);
 525
 526         $result = core_blog\external::get_entries(array(
 527             array('name' => 'tagid', 'value' => $this->tagid),
 528             array('name' => 'userid', 'value' => $this->userid),
 529         ));
 530         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 531         $this->assertCount(1, $result['entries']);
 532
 533         // Non-existent multiple filter.
 534         $result = core_blog\external::get_entries(array(
 535             array('name' => 'search', 'value' => 'www'),
 536             array('name' => 'userid', 'value' => $this->userid),
 537         ));
 538         $result = external_api::clean_returnvalue(core_blog\external::get_entries_returns(), $result);
 539         $this->assertCount(0, $result['entries']);
 540     }
 541
 542     /**
 543      * Test get entries filtering by invalid_filter.
 544      */
 545     public function test_get_entries_filtering_by_invalid_filter() {
 546         $this->setAdminUser();
 547         // Filter by incorrect filter.
 548         $this->expectException('moodle_exception');
 549         $result = core_blog\external::get_entries(array(array('name' => 'zzZZzz', 'value' => 'wwWWww')));
 550     }
 551
 552     /**
 553      * Test get entries when blog is disabled.
 554      */
 555     public function test_get_entries_blog_disabled() {
 556         global $CFG;
 557
 558         $this->setAdminUser();
 559         $CFG->enableblogs = 0;
 560         // Filter by incorrect filter.
 561         $this->expectException('moodle_exception');
 562         $result = core_blog\external::get_entries(array(array('name' => 'zzZZzz', 'value' => 'wwWWww')));
 563     }
 564
 565     /**
 566      * Test view_blog_entries without filter.
 567      */
 568     public function test_view_blog_entries_without_filtering() {
 569         // Test user with full capabilities.
 570         $this->setUser($this->userid);
 571         // Trigger and capture the event.
 572         $sink = $this->redirectEvents();
 573         $result = core_blog\external::view_entries();
 574         $result = external_api::clean_returnvalue(core_blog\external::view_entries_returns(), $result);
 575
 576         $events = $sink->get_events();
 577         $this->assertCount(1, $events);
 578         $event = array_shift($events);
 579         // Checking that the event contains the expected values (empty, no filtering done).
 580         $this->assertInstanceOf('\core\event\blog_entries_viewed', $event);
 581         $this->assertEmpty($event->get_data()['relateduserid']);
 582         $this->assertEmpty($event->get_data()['other']['entryid']);
 583         $this->assertEmpty($event->get_data()['other']['tagid']);
 584         $this->assertEmpty($event->get_data()['other']['userid']);
 585         $this->assertEmpty($event->get_data()['other']['modid']);
 586         $this->assertEmpty($event->get_data()['other']['groupid']);
 587         $this->assertEmpty($event->get_data()['other']['search']);
 588         $this->assertEmpty($event->get_data()['other']['courseid']);
 589         $this->assertEventContextNotUsed($event);
 590         $this->assertNotEmpty($event->get_name());
 591     }
 592
 593     /**
 594      * Test view_blog_entries doing filtering.
 595      */
 596     public function test_view_blog_entries_with_filtering() {
 597         // Test user with full capabilities.
 598         $this->setUser($this->userid);
 599         // Trigger and capture the event.
 600         $sink = $this->redirectEvents();
 601         $result = core_blog\external::view_entries(array(
 602             array('name' => 'tagid', 'value' => $this->tagid),
 603             array('name' => 'userid', 'value' => $this->userid),
 604         ));
 605         $result = external_api::clean_returnvalue(core_blog\external::view_entries_returns(), $result);
 606
 607         $events = $sink->get_events();
 608         $this->assertCount(1, $events);
 609         $event = array_shift($events);
 610         // Checking that the event contains the expected values (filter by user and tag).
 611         $this->assertInstanceOf('\core\event\blog_entries_viewed', $event);
 612         $this->assertEquals($this->userid, $event->get_data()['relateduserid']);
 613         $this->assertEmpty($event->get_data()['other']['entryid']);
 614         $this->assertEquals($this->tagid, $event->get_data()['other']['tagid']);
 615         $this->assertEquals($this->userid, $event->get_data()['other']['userid']);
 616         $this->assertEmpty($event->get_data()['other']['modid']);
 617         $this->assertEmpty($event->get_data()['other']['groupid']);
 618         $this->assertEmpty($event->get_data()['other']['search']);
 619         $this->assertEmpty($event->get_data()['other']['courseid']);
 620         $this->assertEventContextNotUsed($event);
 621         $this->assertNotEmpty($event->get_name());
 622     }
 623 }
 624