Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.

Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402]

   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 core_search;
  18  
  19  defined('MOODLE_INTERNAL') || die();
  20  
  21  require_once (__DIR__ . '/fixtures/testable_core_search.php');
  22  require_once (__DIR__ . '/fixtures/mock_search_area.php');
  23  
  24  /**
  25   * Unit tests for search manager.
  26   *
  27   * @package     core_search
  28   * @category    phpunit
  29   * @copyright   2015 David Monllao {@link http://www.davidmonllao.com}
  30   * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  31   */
  32  class manager_test extends \advanced_testcase {
  33  
  34      /**
  35       * Forum area id.
  36       *
  37       * @var string
  38       */
  39  
  40      protected $forumpostareaid = null;
  41  
  42      /**
  43       * Courses area id.
  44       *
  45       * @var string
  46       */
  47      protected $coursesareaid = null;
  48  
  49      public function setUp(): void {
  50          $this->forumpostareaid = \core_search\manager::generate_areaid('mod_forum', 'post');
  51          $this->coursesareaid = \core_search\manager::generate_areaid('core_course', 'course');
  52      }
  53  
  54      protected function tearDown(): void {
  55          // Stop it from faking time in the search manager (if set by test).
  56          \testable_core_search::fake_current_time();
  57          parent::tearDown();
  58      }
  59  
  60      public function test_search_enabled() {
  61  
  62          $this->resetAfterTest();
  63  
  64          // Disabled by default.
  65          $this->assertFalse(\core_search\manager::is_global_search_enabled());
  66  
  67          set_config('enableglobalsearch', true);
  68          $this->assertTrue(\core_search\manager::is_global_search_enabled());
  69  
  70          set_config('enableglobalsearch', false);
  71          $this->assertFalse(\core_search\manager::is_global_search_enabled());
  72      }
  73  
  74      /**
  75       * Tests the course search url is correct.
  76       *
  77       * @param bool|null $gsenabled Enable global search (null to leave as the default).
  78       * @param bool|null $allcourses Enable searching all courses (null to leave as the default).
  79       * @param bool|null $enablearea Enable the course search area (null to leave as the default).
  80       * @param string $expected The expected course search url.
  81       * @dataProvider data_course_search_url
  82       */
  83      public function test_course_search_url(?bool $gsenabled, ?bool $allcourses, ?bool $enablearea, string $expected) {
  84          $this->resetAfterTest();
  85  
  86          if (!is_null($gsenabled)) {
  87              set_config('enableglobalsearch', $gsenabled);
  88          }
  89  
  90          if (!is_null($allcourses)) {
  91              set_config('searchincludeallcourses', $allcourses);
  92          }
  93  
  94          if (!is_null($enablearea)) {
  95              // Setup the course search area.
  96              $areaid = \core_search\manager::generate_areaid('core_course', 'course');
  97              $area = \core_search\manager::get_search_area($areaid);
  98              $area->set_enabled($enablearea);
  99          }
 100  
 101          $this->assertEquals(new \moodle_url($expected), \core_search\manager::get_course_search_url());
 102      }
 103  
 104      /**
 105       * Data for the test_course_search_url test.
 106       *
 107       * @return array[]
 108       */
 109      public function data_course_search_url(): array {
 110          return [
 111              'defaults' => [null, null, null, '/course/search.php'],
 112              'enabled' => [true, true, true, '/search/index.php'],
 113              'no all courses, no search area' => [true, false, false, '/course/search.php'],
 114              'no search area' => [true, true, false, '/course/search.php'],
 115              'no all courses' => [true, false, true, '/course/search.php'],
 116              'disabled' => [false, false, false, '/course/search.php'],
 117              'no global search' => [false, true, false, '/course/search.php'],
 118              'no global search, no all courses' => [false, false, true, '/course/search.php'],
 119              'no global search, no search area' => [false, true, false, '/course/search.php'],
 120          ];
 121      }
 122  
 123      /**
 124       * Tests that we detect that global search can replace frontpage course search.
 125       *
 126       * @param bool|null $gsenabled Enable global search (null to leave as the default).
 127       * @param bool|null $allcourses Enable searching all courses (null to leave as the default).
 128       * @param bool|null $enablearea Enable the course search area (null to leave as the default).
 129       * @param bool $expected The expected result.
 130       * @dataProvider data_can_replace_course_search
 131       */
 132      public function test_can_replace_course_search(?bool $gsenabled, ?bool $allcourses, ?bool $enablearea, bool $expected) {
 133          $this->resetAfterTest();
 134  
 135          if (!is_null($gsenabled)) {
 136              set_config('enableglobalsearch', $gsenabled);
 137          }
 138  
 139          if (!is_null($allcourses)) {
 140              set_config('searchincludeallcourses', $allcourses);
 141          }
 142  
 143          if (!is_null($enablearea)) {
 144              // Setup the course search area.
 145              $areaid = \core_search\manager::generate_areaid('core_course', 'course');
 146              $area = \core_search\manager::get_search_area($areaid);
 147              $area->set_enabled($enablearea);
 148          }
 149  
 150          $this->assertEquals($expected, \core_search\manager::can_replace_course_search());
 151      }
 152  
 153      /**
 154       * Data for the test_can_replace_course_search test.
 155       *
 156       * @return array[]
 157       */
 158      public function data_can_replace_course_search(): array {
 159          return [
 160              'defaults' => [null, null, null, false],
 161              'enabled' => [true, true, true, true],
 162              'no all courses, no search area' => [true, false, false, false],
 163              'no search area' => [true, true, false, false],
 164              'no all courses' => [true, false, true, false],
 165              'disabled' => [false, false, false, false],
 166              'no global search' => [false, true, false, false],
 167              'no global search, no all courses' => [false, false, true, false],
 168              'no global search, no search area' => [false, true, false, false],
 169          ];
 170      }
 171  
 172      public function test_search_areas() {
 173          global $CFG;
 174  
 175          $this->resetAfterTest();
 176  
 177          set_config('enableglobalsearch', true);
 178  
 179          $fakeareaid = \core_search\manager::generate_areaid('mod_unexisting', 'chihuaquita');
 180  
 181          $searcharea = \core_search\manager::get_search_area($this->forumpostareaid);
 182          $this->assertInstanceOf('\core_search\base', $searcharea);
 183  
 184          $this->assertFalse(\core_search\manager::get_search_area($fakeareaid));
 185  
 186          $this->assertArrayHasKey($this->forumpostareaid, \core_search\manager::get_search_areas_list());
 187          $this->assertArrayNotHasKey($fakeareaid, \core_search\manager::get_search_areas_list());
 188  
 189          // Enabled by default once global search is enabled.
 190          $this->assertArrayHasKey($this->forumpostareaid, \core_search\manager::get_search_areas_list(true));
 191  
 192          list($componentname, $varname) = $searcharea->get_config_var_name();
 193          set_config($varname . '_enabled', 0, $componentname);
 194          \core_search\manager::clear_static();
 195  
 196          $this->assertArrayNotHasKey('mod_forum', \core_search\manager::get_search_areas_list(true));
 197  
 198          set_config($varname . '_enabled', 1, $componentname);
 199  
 200          // Although the result is wrong, we want to check that \core_search\manager::get_search_areas_list returns cached results.
 201          $this->assertArrayNotHasKey($this->forumpostareaid, \core_search\manager::get_search_areas_list(true));
 202  
 203          // Now we check the real result.
 204          \core_search\manager::clear_static();
 205          $this->assertArrayHasKey($this->forumpostareaid, \core_search\manager::get_search_areas_list(true));
 206      }
 207  
 208      public function test_search_config() {
 209  
 210          $this->resetAfterTest();
 211  
 212          $search = \testable_core_search::instance();
 213  
 214          // We should test both plugin types and core subsystems. No core subsystems available yet.
 215          $searcharea = $search->get_search_area($this->forumpostareaid);
 216  
 217          list($componentname, $varname) = $searcharea->get_config_var_name();
 218  
 219          // Just with a couple of vars should be enough.
 220          $start = time() - 100;
 221          $end = time();
 222          set_config($varname . '_indexingstart', $start, $componentname);
 223          set_config($varname . '_indexingend', $end, $componentname);
 224  
 225          $configs = $search->get_areas_config(array($this->forumpostareaid => $searcharea));
 226          $this->assertEquals($start, $configs[$this->forumpostareaid]->indexingstart);
 227          $this->assertEquals($end, $configs[$this->forumpostareaid]->indexingend);
 228          $this->assertEquals(false, $configs[$this->forumpostareaid]->partial);
 229  
 230          try {
 231              $fakeareaid = \core_search\manager::generate_areaid('mod_unexisting', 'chihuaquita');
 232              $search->reset_config($fakeareaid);
 233              $this->fail('An exception should be triggered if the provided search area does not exist.');
 234          } catch (\moodle_exception $ex) {
 235              $this->assertStringContainsString($fakeareaid . ' search area is not available.', $ex->getMessage());
 236          }
 237  
 238          // We clean it all but enabled components.
 239          $search->reset_config($this->forumpostareaid);
 240          $config = $searcharea->get_config();
 241          $this->assertEquals(1, $config[$varname . '_enabled']);
 242          $this->assertEquals(0, $config[$varname . '_indexingstart']);
 243          $this->assertEquals(0, $config[$varname . '_indexingend']);
 244          $this->assertEquals(0, $config[$varname . '_lastindexrun']);
 245          $this->assertEquals(0, $config[$varname . '_partial']);
 246          // No caching.
 247          $configs = $search->get_areas_config(array($this->forumpostareaid => $searcharea));
 248          $this->assertEquals(0, $configs[$this->forumpostareaid]->indexingstart);
 249          $this->assertEquals(0, $configs[$this->forumpostareaid]->indexingend);
 250  
 251          set_config($varname . '_indexingstart', $start, $componentname);
 252          set_config($varname . '_indexingend', $end, $componentname);
 253  
 254          // All components config should be reset.
 255          $search->reset_config();
 256          $this->assertEquals(0, get_config($componentname, $varname . '_indexingstart'));
 257          $this->assertEquals(0, get_config($componentname, $varname . '_indexingend'));
 258          $this->assertEquals(0, get_config($componentname, $varname . '_lastindexrun'));
 259          // No caching.
 260          $configs = $search->get_areas_config(array($this->forumpostareaid => $searcharea));
 261          $this->assertEquals(0, $configs[$this->forumpostareaid]->indexingstart);
 262          $this->assertEquals(0, $configs[$this->forumpostareaid]->indexingend);
 263      }
 264  
 265      /**
 266       * Tests the get_last_indexing_duration method in the base area class.
 267       */
 268      public function test_get_last_indexing_duration() {
 269          $this->resetAfterTest();
 270  
 271          $search = \testable_core_search::instance();
 272  
 273          $searcharea = $search->get_search_area($this->forumpostareaid);
 274  
 275          // When never indexed, the duration is false.
 276          $this->assertSame(false, $searcharea->get_last_indexing_duration());
 277  
 278          // Set the start/end times.
 279          list($componentname, $varname) = $searcharea->get_config_var_name();
 280          $start = time() - 100;
 281          $end = time();
 282          set_config($varname . '_indexingstart', $start, $componentname);
 283          set_config($varname . '_indexingend', $end, $componentname);
 284  
 285          // The duration should now be 100.
 286          $this->assertSame(100, $searcharea->get_last_indexing_duration());
 287      }
 288  
 289      /**
 290       * Tests that partial indexing works correctly.
 291       */
 292      public function test_partial_indexing() {
 293          global $USER;
 294  
 295          $this->resetAfterTest();
 296          $this->setAdminUser();
 297  
 298          // Create a course and a forum.
 299          $generator = $this->getDataGenerator();
 300          $course = $generator->create_course();
 301          $forum = $generator->create_module('forum', ['course' => $course->id]);
 302  
 303          // Index everything up to current. Ensure the course is older than current second so it
 304          // definitely doesn't get indexed again next time.
 305          $this->waitForSecond();
 306          $search = \testable_core_search::instance();
 307          $search->index(false, 0);
 308  
 309          $searcharea = $search->get_search_area($this->forumpostareaid);
 310          list($componentname, $varname) = $searcharea->get_config_var_name();
 311          $this->assertFalse(get_config($componentname, $varname . '_partial'));
 312  
 313          // Add 3 discussions to the forum.
 314          $now = time();
 315          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 316                  'forum' => $forum->id, 'userid' => $USER->id, 'timemodified' => $now,
 317                  'name' => 'Frog']);
 318          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 319                  'forum' => $forum->id, 'userid' => $USER->id, 'timemodified' => $now + 1,
 320                  'name' => 'Toad']);
 321          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 322                  'forum' => $forum->id, 'userid' => $USER->id, 'timemodified' => $now + 2,
 323                  'name' => 'Zombie']);
 324          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 325                  'forum' => $forum->id, 'userid' => $USER->id, 'timemodified' => $now + 2,
 326                  'name' => 'Werewolf']);
 327          time_sleep_until($now + 3);
 328  
 329          // Clear the count of added documents.
 330          $search->get_engine()->get_and_clear_added_documents();
 331  
 332          // Make the search engine delay while indexing each document.
 333          $search->get_engine()->set_add_delay(1.2);
 334  
 335          // Use fake time, starting from now.
 336          \testable_core_search::fake_current_time(time());
 337  
 338          // Index with a limit of 2 seconds - it should index 2 of the documents (after the second
 339          // one, it will have taken 2.4 seconds so it will stop).
 340          $search->index(false, 2);
 341          $added = $search->get_engine()->get_and_clear_added_documents();
 342          $this->assertCount(2, $added);
 343          $this->assertEquals('Frog', $added[0]->get('title'));
 344          $this->assertEquals('Toad', $added[1]->get('title'));
 345          $this->assertEquals(1, get_config($componentname, $varname . '_partial'));
 346          // Whilst 2.4 seconds of "time" have elapsed, the indexing duration is
 347          // measured in seconds, so should be 2.
 348          $this->assertEquals(2, $searcharea->get_last_indexing_duration());
 349  
 350          // Add a label.
 351          $generator->create_module('label', ['course' => $course->id, 'intro' => 'Vampire']);
 352  
 353          // Wait to next second (so as to not reindex the label more than once, as it will now
 354          // be timed before the indexing run).
 355          $this->waitForSecond();
 356          \testable_core_search::fake_current_time(time());
 357  
 358          // Next index with 1 second limit should do the label and not the forum - the logic is,
 359          // if it spent ages indexing an area last time, do that one last on next run.
 360          $search->index(false, 1);
 361          $added = $search->get_engine()->get_and_clear_added_documents();
 362          $this->assertCount(1, $added);
 363          $this->assertEquals('Vampire', $added[0]->get('title'));
 364  
 365          // Index again with a 3 second limit - it will redo last post for safety (because of other
 366          // things possibly having the same time second), and then do the remaining one. (Note:
 367          // because it always does more than one second worth of items, it would actually index 2
 368          // posts even if the limit were less than 2, we are testing it does 3 posts to make sure
 369          // the time limiting is actually working with the specified time.)
 370          $search->index(false, 3);
 371          $added = $search->get_engine()->get_and_clear_added_documents();
 372          $this->assertCount(3, $added);
 373          $this->assertEquals('Toad', $added[0]->get('title'));
 374          $remainingtitles = [$added[1]->get('title'), $added[2]->get('title')];
 375          sort($remainingtitles);
 376          $this->assertEquals(['Werewolf', 'Zombie'], $remainingtitles);
 377          $this->assertFalse(get_config($componentname, $varname . '_partial'));
 378  
 379          // Index again - there should be nothing to index this time.
 380          $search->index(false, 2);
 381          $added = $search->get_engine()->get_and_clear_added_documents();
 382          $this->assertCount(0, $added);
 383          $this->assertFalse(get_config($componentname, $varname . '_partial'));
 384      }
 385  
 386      /**
 387       * Tests the progress display while indexing.
 388       *
 389       * This tests the different logic about displaying progress for slow/fast and
 390       * complete/incomplete processing.
 391       */
 392      public function test_index_progress() {
 393          $this->resetAfterTest();
 394          $generator = $this->getDataGenerator();
 395  
 396          // Set up the fake search area.
 397          $search = \testable_core_search::instance();
 398          $area = new \core_mocksearch\search\mock_search_area();
 399          $search->add_search_area('whatever', $area);
 400          $searchgenerator = $generator->get_plugin_generator('core_search');
 401          $searchgenerator->setUp();
 402  
 403          // Add records with specific time modified values.
 404          $time = strtotime('2017-11-01 01:00');
 405          for ($i = 0; $i < 8; $i ++) {
 406              $searchgenerator->create_record((object)['timemodified' => $time]);
 407              $time += 60;
 408          }
 409  
 410          // Simulate slow progress on indexing and initial query.
 411          $now = strtotime('2017-11-11 01:00');
 412          \testable_core_search::fake_current_time($now);
 413          $area->set_indexing_delay(10.123);
 414          $search->get_engine()->set_add_delay(15.789);
 415  
 416          // Run search indexing and check output.
 417          $progress = new \progress_trace_buffer(new \text_progress_trace(), false);
 418          $search->index(false, 75, $progress);
 419          $out = $progress->get_buffer();
 420          $progress->reset_buffer();
 421  
 422          // Check for the standard text.
 423          $this->assertStringContainsString('Processing area: Mock search area', $out);
 424          $this->assertStringContainsString('Stopping indexing due to time limit', $out);
 425  
 426          // Check for initial query performance indication.
 427          $this->assertStringContainsString('Initial query took 10.1 seconds.', $out);
 428  
 429          // Check for the two (approximately) every-30-seconds messages.
 430          $this->assertStringContainsString('01:00:41: Done to 1/11/17, 01:01', $out);
 431          $this->assertStringContainsString('01:01:13: Done to 1/11/17, 01:03', $out);
 432  
 433          // Check for the 'not complete' indicator showing when it was done until.
 434          $this->assertStringContainsString('Processed 5 records containing 5 documents, in 89.1 seconds ' .
 435                  '(not complete; done to 1/11/17, 01:04)', $out);
 436  
 437          // Make the initial query delay less than 5 seconds, so it won't appear. Make the documents
 438          // quicker, so that the 30-second delay won't be needed.
 439          $area->set_indexing_delay(4.9);
 440          $search->get_engine()->set_add_delay(1);
 441  
 442          // Run search indexing (still partial) and check output.
 443          $progress = new \progress_trace_buffer(new \text_progress_trace(), false);
 444          $search->index(false, 5, $progress);
 445          $out = $progress->get_buffer();
 446          $progress->reset_buffer();
 447  
 448          $this->assertStringContainsString('Processing area: Mock search area', $out);
 449          $this->assertStringContainsString('Stopping indexing due to time limit', $out);
 450          $this->assertStringNotContainsString('Initial query took', $out);
 451          $this->assertStringNotContainsString(': Done to', $out);
 452          $this->assertStringContainsString('Processed 2 records containing 2 documents, in 6.9 seconds ' .
 453                  '(not complete; done to 1/11/17, 01:05).', $out);
 454  
 455          // Run the remaining items to complete it.
 456          $progress = new \progress_trace_buffer(new \text_progress_trace(), false);
 457          $search->index(false, 100, $progress);
 458          $out = $progress->get_buffer();
 459          $progress->reset_buffer();
 460  
 461          $this->assertStringContainsString('Processing area: Mock search area', $out);
 462          $this->assertStringNotContainsString('Stopping indexing due to time limit', $out);
 463          $this->assertStringNotContainsString('Initial query took', $out);
 464          $this->assertStringNotContainsString(': Done to', $out);
 465          $this->assertStringContainsString('Processed 3 records containing 3 documents, in 7.9 seconds.', $out);
 466  
 467          $searchgenerator->tearDown();
 468      }
 469  
 470      /**
 471       * Tests that documents with modified time in the future are NOT indexed (as this would cause
 472       * a problem by preventing it from indexing other documents modified between now and the future
 473       * date).
 474       */
 475      public function test_future_documents() {
 476          $this->resetAfterTest();
 477  
 478          // Create a course and a forum.
 479          $generator = $this->getDataGenerator();
 480          $course = $generator->create_course();
 481          $forum = $generator->create_module('forum', ['course' => $course->id]);
 482  
 483          // Index everything up to current. Ensure the course is older than current second so it
 484          // definitely doesn't get indexed again next time.
 485          $this->waitForSecond();
 486          $search = \testable_core_search::instance();
 487          $search->index(false, 0);
 488          $search->get_engine()->get_and_clear_added_documents();
 489  
 490          // Add 2 discussions to the forum, one of which happend just now, but the other is
 491          // incorrectly set to the future.
 492          $now = time();
 493          $userid = get_admin()->id;
 494          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 495                  'forum' => $forum->id, 'userid' => $userid, 'timemodified' => $now,
 496                  'name' => 'Frog']);
 497          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 498                  'forum' => $forum->id, 'userid' => $userid, 'timemodified' => $now + 100,
 499                  'name' => 'Toad']);
 500  
 501          // Wait for a second so we're not actually on the same second as the forum post (there's a
 502          // 1 second overlap between indexing; it would get indexed in both checks below otherwise).
 503          $this->waitForSecond();
 504  
 505          // Index.
 506          $search->index(false);
 507          $added = $search->get_engine()->get_and_clear_added_documents();
 508          $this->assertCount(1, $added);
 509          $this->assertEquals('Frog', $added[0]->get('title'));
 510  
 511          // Check latest time - it should be the same as $now, not the + 100.
 512          $searcharea = $search->get_search_area($this->forumpostareaid);
 513          list($componentname, $varname) = $searcharea->get_config_var_name();
 514          $this->assertEquals($now, get_config($componentname, $varname . '_lastindexrun'));
 515  
 516          // Index again - there should be nothing to index this time.
 517          $search->index(false);
 518          $added = $search->get_engine()->get_and_clear_added_documents();
 519          $this->assertCount(0, $added);
 520      }
 521  
 522      /**
 523       * Tests that indexing a specified context works correctly.
 524       */
 525      public function test_context_indexing() {
 526          global $USER;
 527  
 528          $this->resetAfterTest();
 529          $this->setAdminUser();
 530  
 531          // Create a course and two forums and a page.
 532          $generator = $this->getDataGenerator();
 533          $course = $generator->create_course();
 534          $now = time();
 535          $forum1 = $generator->create_module('forum', ['course' => $course->id]);
 536          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 537                  'forum' => $forum1->id, 'userid' => $USER->id, 'timemodified' => $now,
 538                  'name' => 'Frog']);
 539          $this->waitForSecond();
 540          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 541                  'forum' => $forum1->id, 'userid' => $USER->id, 'timemodified' => $now + 2,
 542                  'name' => 'Zombie']);
 543          $forum2 = $generator->create_module('forum', ['course' => $course->id]);
 544          $this->waitForSecond();
 545          $generator->get_plugin_generator('mod_forum')->create_discussion(['course' => $course->id,
 546                  'forum' => $forum2->id, 'userid' => $USER->id, 'timemodified' => $now + 1,
 547                  'name' => 'Toad']);
 548          $generator->create_module('page', ['course' => $course->id]);
 549          $generator->create_module('forum', ['course' => $course->id]);
 550  
 551          // Index forum 1 only.
 552          $search = \testable_core_search::instance();
 553          $buffer = new \progress_trace_buffer(new \text_progress_trace(), false);
 554          $result = $search->index_context(\context_module::instance($forum1->cmid), '', 0, $buffer);
 555          $this->assertTrue($result->complete);
 556          $log = $buffer->get_buffer();
 557          $buffer->reset_buffer();
 558  
 559          // Confirm that output only processed 1 forum activity and 2 posts.
 560          $this->assertNotFalse(strpos($log, "area: Forum - activity information\n  Processed 1 "));
 561          $this->assertNotFalse(strpos($log, "area: Forum - posts\n  Processed 2 "));
 562  
 563          // Confirm that some areas for different types of context were skipped.
 564          $this->assertNotFalse(strpos($log, "area: Users\n  Skipping"));
 565          $this->assertNotFalse(strpos($log, "area: Courses\n  Skipping"));
 566  
 567          // Confirm that another module area had no results.
 568          $this->assertNotFalse(strpos($log, "area: Page\n  No documents"));
 569  
 570          // Index whole course.
 571          $result = $search->index_context(\context_course::instance($course->id), '', 0, $buffer);
 572          $this->assertTrue($result->complete);
 573          $log = $buffer->get_buffer();
 574          $buffer->reset_buffer();
 575  
 576          // Confirm that output processed 3 forum activities and 3 posts.
 577          $this->assertNotFalse(strpos($log, "area: Forum - activity information\n  Processed 3 "));
 578          $this->assertNotFalse(strpos($log, "area: Forum - posts\n  Processed 3 "));
 579  
 580          // The course area was also included this time.
 581          $this->assertNotFalse(strpos($log, "area: Courses\n  Processed 1 "));
 582  
 583          // Confirm that another module area had results too.
 584          $this->assertNotFalse(strpos($log, "area: Page\n  Processed 1 "));
 585  
 586          // Index whole course, but only forum posts.
 587          $result = $search->index_context(\context_course::instance($course->id), 'mod_forum-post',
 588                  0, $buffer);
 589          $this->assertTrue($result->complete);
 590          $log = $buffer->get_buffer();
 591          $buffer->reset_buffer();
 592  
 593          // Confirm that output processed 3 posts but not forum activities.
 594          $this->assertFalse(strpos($log, "area: Forum - activity information"));
 595          $this->assertNotFalse(strpos($log, "area: Forum - posts\n  Processed 3 "));
 596  
 597          // Set time limit and retry index of whole course, taking 3 tries to complete it.
 598          $search->get_engine()->set_add_delay(0.4);
 599          $result = $search->index_context(\context_course::instance($course->id), '', 1, $buffer);
 600          $log = $buffer->get_buffer();
 601          $buffer->reset_buffer();
 602          $this->assertFalse($result->complete);
 603          $this->assertNotFalse(strpos($log, "area: Forum - activity information\n  Processed 2 "));
 604  
 605          $result = $search->index_context(\context_course::instance($course->id), '', 1, $buffer,
 606                  $result->startfromarea, $result->startfromtime);
 607          $log = $buffer->get_buffer();
 608          $buffer->reset_buffer();
 609          $this->assertNotFalse(strpos($log, "area: Forum - activity information\n  Processed 2 "));
 610          $this->assertNotFalse(strpos($log, "area: Forum - posts\n  Processed 2 "));
 611          $this->assertFalse($result->complete);
 612  
 613          $result = $search->index_context(\context_course::instance($course->id), '', 1, $buffer,
 614                  $result->startfromarea, $result->startfromtime);
 615          $log = $buffer->get_buffer();
 616          $buffer->reset_buffer();
 617          $this->assertNotFalse(strpos($log, "area: Forum - posts\n  Processed 2 "));
 618          $this->assertTrue($result->complete);
 619      }
 620  
 621      /**
 622       * Adding this test here as get_areas_user_accesses process is the same, results just depend on the context level.
 623       *
 624       * @return void
 625       */
 626      public function test_search_user_accesses() {
 627          global $DB;
 628  
 629          $this->resetAfterTest();
 630  
 631          $frontpage = $DB->get_record('course', array('id' => SITEID));
 632          $frontpagectx = \context_course::instance($frontpage->id);
 633          $course1 = $this->getDataGenerator()->create_course();
 634          $course1ctx = \context_course::instance($course1->id);
 635          $course2 = $this->getDataGenerator()->create_course();
 636          $course2ctx = \context_course::instance($course2->id);
 637          $course3 = $this->getDataGenerator()->create_course();
 638          $course3ctx = \context_course::instance($course3->id);
 639          $teacher = $this->getDataGenerator()->create_user();
 640          $teacherctx = \context_user::instance($teacher->id);
 641          $student = $this->getDataGenerator()->create_user();
 642          $studentctx = \context_user::instance($student->id);
 643          $noaccess = $this->getDataGenerator()->create_user();
 644          $noaccessctx = \context_user::instance($noaccess->id);
 645          $this->getDataGenerator()->enrol_user($teacher->id, $course1->id, 'teacher');
 646          $this->getDataGenerator()->enrol_user($student->id, $course1->id, 'student');
 647  
 648          $frontpageforum = $this->getDataGenerator()->create_module('forum', array('course' => $frontpage->id));
 649          $forum1 = $this->getDataGenerator()->create_module('forum', array('course' => $course1->id));
 650          $forum2 = $this->getDataGenerator()->create_module('forum', array('course' => $course1->id));
 651          $forum3 = $this->getDataGenerator()->create_module('forum', array('course' => $course2->id));
 652          $frontpageforumcontext = \context_module::instance($frontpageforum->cmid);
 653          $context1 = \context_module::instance($forum1->cmid);
 654          $context2 = \context_module::instance($forum2->cmid);
 655          $context3 = \context_module::instance($forum3->cmid);
 656          $forum4 = $this->getDataGenerator()->create_module('forum', array('course' => $course3->id));
 657          $context4 = \context_module::instance($forum4->cmid);
 658  
 659          $search = \testable_core_search::instance();
 660          $mockareaid = \core_search\manager::generate_areaid('core_mocksearch', 'mock_search_area');
 661          $search->add_core_search_areas();
 662          $search->add_search_area($mockareaid, new \core_mocksearch\search\mock_search_area());
 663  
 664          $this->setAdminUser();
 665          $this->assertEquals((object)['everything' => true], $search->get_areas_user_accesses());
 666  
 667          $sitectx = \context_course::instance(SITEID);
 668  
 669          // Can access the frontpage ones.
 670          $this->setUser($noaccess);
 671          $contexts = $search->get_areas_user_accesses()->usercontexts;
 672          $this->assertEquals(array($frontpageforumcontext->id => $frontpageforumcontext->id), $contexts[$this->forumpostareaid]);
 673          $this->assertEquals(array($sitectx->id => $sitectx->id), $contexts[$this->coursesareaid]);
 674          $mockctxs = array($noaccessctx->id => $noaccessctx->id, $frontpagectx->id => $frontpagectx->id);
 675          $this->assertEquals($mockctxs, $contexts[$mockareaid]);
 676  
 677          $this->setUser($teacher);
 678          $contexts = $search->get_areas_user_accesses()->usercontexts;
 679          $frontpageandcourse1 = array($frontpageforumcontext->id => $frontpageforumcontext->id, $context1->id => $context1->id,
 680              $context2->id => $context2->id);
 681          $this->assertEquals($frontpageandcourse1, $contexts[$this->forumpostareaid]);
 682          $this->assertEquals(array($sitectx->id => $sitectx->id, $course1ctx->id => $course1ctx->id),
 683              $contexts[$this->coursesareaid]);
 684          $mockctxs = array($teacherctx->id => $teacherctx->id,
 685                  $frontpagectx->id => $frontpagectx->id, $course1ctx->id => $course1ctx->id);
 686          $this->assertEquals($mockctxs, $contexts[$mockareaid]);
 687  
 688          $this->setUser($student);
 689          $contexts = $search->get_areas_user_accesses()->usercontexts;
 690          $this->assertEquals($frontpageandcourse1, $contexts[$this->forumpostareaid]);
 691          $this->assertEquals(array($sitectx->id => $sitectx->id, $course1ctx->id => $course1ctx->id),
 692              $contexts[$this->coursesareaid]);
 693          $mockctxs = array($studentctx->id => $studentctx->id,
 694                  $frontpagectx->id => $frontpagectx->id, $course1ctx->id => $course1ctx->id);
 695          $this->assertEquals($mockctxs, $contexts[$mockareaid]);
 696  
 697          // Hide the activity.
 698          set_coursemodule_visible($forum2->cmid, 0);
 699          $contexts = $search->get_areas_user_accesses()->usercontexts;
 700          $this->assertEquals(array($frontpageforumcontext->id => $frontpageforumcontext->id, $context1->id => $context1->id),
 701              $contexts[$this->forumpostareaid]);
 702  
 703          // Now test course limited searches.
 704          set_coursemodule_visible($forum2->cmid, 1);
 705          $this->getDataGenerator()->enrol_user($student->id, $course2->id, 'student');
 706          $contexts = $search->get_areas_user_accesses()->usercontexts;
 707          $allcontexts = array($frontpageforumcontext->id => $frontpageforumcontext->id, $context1->id => $context1->id,
 708              $context2->id => $context2->id, $context3->id => $context3->id);
 709          $this->assertEquals($allcontexts, $contexts[$this->forumpostareaid]);
 710          $this->assertEquals(array($sitectx->id => $sitectx->id, $course1ctx->id => $course1ctx->id,
 711              $course2ctx->id => $course2ctx->id), $contexts[$this->coursesareaid]);
 712  
 713          $contexts = $search->get_areas_user_accesses(array($course1->id, $course2->id))->usercontexts;
 714          $allcontexts = array($context1->id => $context1->id, $context2->id => $context2->id, $context3->id => $context3->id);
 715          $this->assertEquals($allcontexts, $contexts[$this->forumpostareaid]);
 716          $this->assertEquals(array($course1ctx->id => $course1ctx->id,
 717              $course2ctx->id => $course2ctx->id), $contexts[$this->coursesareaid]);
 718  
 719          $contexts = $search->get_areas_user_accesses(array($course2->id))->usercontexts;
 720          $allcontexts = array($context3->id => $context3->id);
 721          $this->assertEquals($allcontexts, $contexts[$this->forumpostareaid]);
 722          $this->assertEquals(array($course2ctx->id => $course2ctx->id), $contexts[$this->coursesareaid]);
 723  
 724          $contexts = $search->get_areas_user_accesses(array($course1->id))->usercontexts;
 725          $allcontexts = array($context1->id => $context1->id, $context2->id => $context2->id);
 726          $this->assertEquals($allcontexts, $contexts[$this->forumpostareaid]);
 727          $this->assertEquals(array($course1ctx->id => $course1ctx->id), $contexts[$this->coursesareaid]);
 728  
 729          // Test context limited search with no course limit.
 730          $contexts = $search->get_areas_user_accesses(false,
 731                  [$frontpageforumcontext->id, $course2ctx->id])->usercontexts;
 732          $this->assertEquals([$frontpageforumcontext->id => $frontpageforumcontext->id],
 733                  $contexts[$this->forumpostareaid]);
 734          $this->assertEquals([$course2ctx->id => $course2ctx->id],
 735                  $contexts[$this->coursesareaid]);
 736  
 737          // Test context limited search with course limit.
 738          $contexts = $search->get_areas_user_accesses([$course1->id, $course2->id],
 739                  [$frontpageforumcontext->id, $course2ctx->id])->usercontexts;
 740          $this->assertArrayNotHasKey($this->forumpostareaid, $contexts);
 741          $this->assertEquals([$course2ctx->id => $course2ctx->id],
 742                  $contexts[$this->coursesareaid]);
 743  
 744          // Single context and course.
 745          $contexts = $search->get_areas_user_accesses([$course1->id], [$context1->id])->usercontexts;
 746          $this->assertEquals([$context1->id => $context1->id], $contexts[$this->forumpostareaid]);
 747          $this->assertArrayNotHasKey($this->coursesareaid, $contexts);
 748  
 749          // Enable "Include all visible courses" feature.
 750          set_config('searchincludeallcourses', 1);
 751          $contexts = $search->get_areas_user_accesses()->usercontexts;
 752          $expected = [
 753              $sitectx->id => $sitectx->id,
 754              $course1ctx->id => $course1ctx->id,
 755              $course2ctx->id => $course2ctx->id,
 756              $course3ctx->id => $course3ctx->id
 757          ];
 758          // Check that a student has assess to all courses data when "searchincludeallcourses" is enabled.
 759          $this->assertEquals($expected, $contexts[$this->coursesareaid]);
 760          // But at the same time doesn't have access to activities in the courses that the student can't access.
 761          $this->assertFalse(key_exists($context4->id, $contexts[$this->forumpostareaid]));
 762  
 763          // For admins, this is still limited only if we specify the things, so it should be same.
 764          $this->setAdminUser();
 765          $contexts = $search->get_areas_user_accesses([$course1->id], [$context1->id])->usercontexts;
 766          $this->assertEquals([$context1->id => $context1->id], $contexts[$this->forumpostareaid]);
 767          $this->assertArrayNotHasKey($this->coursesareaid, $contexts);
 768      }
 769  
 770      /**
 771       * Tests the block support in get_search_user_accesses.
 772       *
 773       * @return void
 774       */
 775      public function test_search_user_accesses_blocks() {
 776          global $DB;
 777  
 778          $this->resetAfterTest();
 779          $this->setAdminUser();
 780  
 781          // Create course and add HTML block.
 782          $generator = $this->getDataGenerator();
 783          $course1 = $generator->create_course();
 784          $context1 = \context_course::instance($course1->id);
 785          $page = new \moodle_page();
 786          $page->set_context($context1);
 787          $page->set_course($course1);
 788          $page->set_pagelayout('standard');
 789          $page->set_pagetype('course-view');
 790          $page->blocks->load_blocks();
 791          $page->blocks->add_block_at_end_of_default_region('html');
 792  
 793          // Create another course with HTML blocks only in some weird page or a module page (not
 794          // yet supported, so both these blocks will be ignored).
 795          $course2 = $generator->create_course();
 796          $context2 = \context_course::instance($course2->id);
 797          $page = new \moodle_page();
 798          $page->set_context($context2);
 799          $page->set_course($course2);
 800          $page->set_pagelayout('standard');
 801          $page->set_pagetype('bogus-page');
 802          $page->blocks->load_blocks();
 803          $page->blocks->add_block_at_end_of_default_region('html');
 804  
 805          $forum = $this->getDataGenerator()->create_module('forum', array('course' => $course2->id));
 806          $forumcontext = \context_module::instance($forum->cmid);
 807          $page = new \moodle_page();
 808          $page->set_context($forumcontext);
 809          $page->set_course($course2);
 810          $page->set_pagelayout('standard');
 811          $page->set_pagetype('mod-forum-view');
 812          $page->blocks->load_blocks();
 813          $page->blocks->add_block_at_end_of_default_region('html');
 814  
 815          // The third course has 2 HTML blocks.
 816          $course3 = $generator->create_course();
 817          $context3 = \context_course::instance($course3->id);
 818          $page = new \moodle_page();
 819          $page->set_context($context3);
 820          $page->set_course($course3);
 821          $page->set_pagelayout('standard');
 822          $page->set_pagetype('course-view');
 823          $page->blocks->load_blocks();
 824          $page->blocks->add_block_at_end_of_default_region('html');
 825          $page->blocks->add_block_at_end_of_default_region('html');
 826  
 827          // Student 1 belongs to all 3 courses.
 828          $student1 = $generator->create_user();
 829          $generator->enrol_user($student1->id, $course1->id, 'student');
 830          $generator->enrol_user($student1->id, $course2->id, 'student');
 831          $generator->enrol_user($student1->id, $course3->id, 'student');
 832  
 833          // Student 2 belongs only to course 2.
 834          $student2 = $generator->create_user();
 835          $generator->enrol_user($student2->id, $course2->id, 'student');
 836  
 837          // And the third student is only in course 3.
 838          $student3 = $generator->create_user();
 839          $generator->enrol_user($student3->id, $course3->id, 'student');
 840  
 841          $search = \testable_core_search::instance();
 842          $search->add_core_search_areas();
 843  
 844          // Admin gets 'true' result to function regardless of blocks.
 845          $this->setAdminUser();
 846          $this->assertEquals((object)['everything' => true], $search->get_areas_user_accesses());
 847  
 848          // Student 1 gets all 3 block contexts.
 849          $this->setUser($student1);
 850          $contexts = $search->get_areas_user_accesses()->usercontexts;
 851          $this->assertArrayHasKey('block_html-content', $contexts);
 852          $this->assertCount(3, $contexts['block_html-content']);
 853  
 854          // Student 2 does not get any blocks.
 855          $this->setUser($student2);
 856          $contexts = $search->get_areas_user_accesses()->usercontexts;
 857          $this->assertArrayNotHasKey('block_html-content', $contexts);
 858  
 859          // Student 3 gets only two of them.
 860          $this->setUser($student3);
 861          $contexts = $search->get_areas_user_accesses()->usercontexts;
 862          $this->assertArrayHasKey('block_html-content', $contexts);
 863          $this->assertCount(2, $contexts['block_html-content']);
 864  
 865          // A course limited search for student 1 is the same as the student 3 search.
 866          $this->setUser($student1);
 867          $limitedcontexts = $search->get_areas_user_accesses([$course3->id])->usercontexts;
 868          $this->assertEquals($contexts['block_html-content'], $limitedcontexts['block_html-content']);
 869  
 870          // Get block context ids for the blocks that appear.
 871          $blockcontextids = $DB->get_fieldset_sql('
 872              SELECT x.id
 873                FROM {block_instances} bi
 874                JOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ?
 875               WHERE (parentcontextid = ? OR parentcontextid = ?)
 876                     AND blockname = ?
 877            ORDER BY bi.id', [CONTEXT_BLOCK, $context1->id, $context3->id, 'html']);
 878  
 879          // Context limited search (no course).
 880          $contexts = $search->get_areas_user_accesses(false,
 881                  [$blockcontextids[0], $blockcontextids[2]])->usercontexts;
 882          $this->assertCount(2, $contexts['block_html-content']);
 883  
 884          // Context limited search (with course 3).
 885          $contexts = $search->get_areas_user_accesses([$course2->id, $course3->id],
 886                  [$blockcontextids[0], $blockcontextids[2]])->usercontexts;
 887          $this->assertCount(1, $contexts['block_html-content']);
 888      }
 889  
 890      /**
 891       * Tests retrieval of users search areas when limiting to a course the user is not enrolled in
 892       */
 893      public function test_search_users_accesses_limit_non_enrolled_course() {
 894          global $DB;
 895  
 896          $this->resetAfterTest();
 897  
 898          $user = $this->getDataGenerator()->create_user();
 899          $this->setUser($user);
 900  
 901          $search = \testable_core_search::instance();
 902          $search->add_core_search_areas();
 903  
 904          $course = $this->getDataGenerator()->create_course();
 905          $context = \context_course::instance($course->id);
 906  
 907          // Limit courses to search to only those the user is enrolled in.
 908          set_config('searchallavailablecourses', 0);
 909  
 910          $usercontexts = $search->get_areas_user_accesses([$course->id])->usercontexts;
 911          $this->assertNotEmpty($usercontexts);
 912          $this->assertArrayNotHasKey('core_course-course', $usercontexts);
 913  
 914          // This config ensures the search will also include courses the user can view.
 915          set_config('searchallavailablecourses', 1);
 916  
 917          // Allow "Authenticated user" role to view the course without being enrolled in it.
 918          $userrole = $DB->get_record('role', ['shortname' => 'user'], '*', MUST_EXIST);
 919          role_change_permission($userrole->id, $context, 'moodle/course:view', CAP_ALLOW);
 920  
 921          $usercontexts = $search->get_areas_user_accesses([$course->id])->usercontexts;
 922          $this->assertNotEmpty($usercontexts);
 923          $this->assertArrayHasKey('core_course-course', $usercontexts);
 924          $this->assertEquals($context->id, reset($usercontexts['core_course-course']));
 925      }
 926  
 927      /**
 928       * Test get_areas_user_accesses with regard to the 'all available courses' config option.
 929       *
 930       * @return void
 931       */
 932      public function test_search_user_accesses_allavailable() {
 933          global $DB, $CFG;
 934  
 935          $this->resetAfterTest();
 936  
 937          // Front page, including a forum.
 938          $frontpage = $DB->get_record('course', array('id' => SITEID));
 939          $forumfront = $this->getDataGenerator()->create_module('forum', array('course' => $frontpage->id));
 940          $forumfrontctx = \context_module::instance($forumfront->cmid);
 941  
 942          // Course 1 does not allow guest access.
 943          $course1 = $this->getDataGenerator()->create_course((object)array(
 944                  'enrol_guest_status_0' => ENROL_INSTANCE_DISABLED,
 945                  'enrol_guest_password_0' => ''));
 946          $forum1 = $this->getDataGenerator()->create_module('forum', array('course' => $course1->id));
 947          $forum1ctx = \context_module::instance($forum1->cmid);
 948  
 949          // Course 2 does not allow guest but is accessible by all users.
 950          $course2 = $this->getDataGenerator()->create_course((object)array(
 951                  'enrol_guest_status_0' => ENROL_INSTANCE_DISABLED,
 952                  'enrol_guest_password_0' => ''));
 953          $course2ctx = \context_course::instance($course2->id);
 954          $forum2 = $this->getDataGenerator()->create_module('forum', array('course' => $course2->id));
 955          $forum2ctx = \context_module::instance($forum2->cmid);
 956          assign_capability('moodle/course:view', CAP_ALLOW, $CFG->defaultuserroleid, $course2ctx->id);
 957  
 958          // Course 3 allows guest access without password.
 959          $course3 = $this->getDataGenerator()->create_course((object)array(
 960                  'enrol_guest_status_0' => ENROL_INSTANCE_ENABLED,
 961                  'enrol_guest_password_0' => ''));
 962          $forum3 = $this->getDataGenerator()->create_module('forum', array('course' => $course2->id));
 963          $forum3ctx = \context_module::instance($forum3->cmid);
 964  
 965          // Student user is enrolled in course 1.
 966          $student = $this->getDataGenerator()->create_user();
 967          $this->getDataGenerator()->enrol_user($student->id, $course1->id, 'student');
 968  
 969          // No access user is just a user with no permissions.
 970          $noaccess = $this->getDataGenerator()->create_user();
 971  
 972          // First test without the all available option.
 973          $search = \testable_core_search::instance();
 974  
 975          // Admin user can access everything.
 976          $this->setAdminUser();
 977          $this->assertEquals((object)['everything' => true], $search->get_areas_user_accesses());
 978  
 979          // No-access user can access only the front page forum.
 980          $this->setUser($noaccess);
 981          $contexts = $search->get_areas_user_accesses()->usercontexts;
 982          $this->assertEquals([$forumfrontctx->id], array_keys($contexts[$this->forumpostareaid]));
 983  
 984          // Student can access the front page forum plus the enrolled one.
 985          $this->setUser($student);
 986          $contexts = $search->get_areas_user_accesses()->usercontexts;
 987          $this->assertEquals([$forum1ctx->id, $forumfrontctx->id],
 988                  array_keys($contexts[$this->forumpostareaid]));
 989  
 990          // Now turn on the all available option.
 991          set_config('searchallavailablecourses', 1);
 992  
 993          // Admin user can access everything.
 994          $this->setAdminUser();
 995          $this->assertEquals((object)['everything' => true], $search->get_areas_user_accesses());
 996  
 997          // No-access user can access the front page forum and course 2, 3.
 998          $this->setUser($noaccess);
 999          $contexts = $search->get_areas_user_accesses()->usercontexts;
1000          $this->assertEquals([$forum2ctx->id, $forum3ctx->id, $forumfrontctx->id],
1001                  array_keys($contexts[$this->forumpostareaid]));
1002  
1003          // Student can access the front page forum plus the enrolled one plus courses 2, 3.
1004          $this->setUser($student);
1005          $contexts = $search->get_areas_user_accesses()->usercontexts;
1006          $this->assertEquals([$forum1ctx->id, $forum2ctx->id, $forum3ctx->id, $forumfrontctx->id],
1007                  array_keys($contexts[$this->forumpostareaid]));
1008      }
1009  
1010      /**
1011       * Tests group-related aspects of the get_areas_user_accesses function.
1012       */
1013      public function test_search_user_accesses_groups() {
1014          global $DB;
1015  
1016          $this->resetAfterTest();
1017          $this->setAdminUser();
1018  
1019          // Create 2 courses each with 2 groups and 2 forums (separate/visible groups).
1020          $generator = $this->getDataGenerator();
1021          $course1 = $generator->create_course();
1022          $course2 = $generator->create_course();
1023          $group1 = $generator->create_group(['courseid' => $course1->id]);
1024          $group2 = $generator->create_group(['courseid' => $course1->id]);
1025          $group3 = $generator->create_group(['courseid' => $course2->id]);
1026          $group4 = $generator->create_group(['courseid' => $course2->id]);
1027          $forum1s = $generator->create_module('forum', ['course' => $course1->id, 'groupmode' => SEPARATEGROUPS]);
1028          $id1s = \context_module::instance($forum1s->cmid)->id;
1029          $forum1v = $generator->create_module('forum', ['course' => $course1->id, 'groupmode' => VISIBLEGROUPS]);
1030          $id1v = \context_module::instance($forum1v->cmid)->id;
1031          $forum2s = $generator->create_module('forum', ['course' => $course2->id, 'groupmode' => SEPARATEGROUPS]);
1032          $id2s = \context_module::instance($forum2s->cmid)->id;
1033          $forum2n = $generator->create_module('forum', ['course' => $course2->id, 'groupmode' => NOGROUPS]);
1034          $id2n = \context_module::instance($forum2n->cmid)->id;
1035  
1036          // Get search instance.
1037          $search = \testable_core_search::instance();
1038          $search->add_core_search_areas();
1039  
1040          // User 1 is a manager in one course and a student in the other one. They belong to
1041          // all of the groups 1, 2, 3, and 4.
1042          $user1 = $generator->create_user();
1043          $generator->enrol_user($user1->id, $course1->id, 'manager');
1044          $generator->enrol_user($user1->id, $course2->id, 'student');
1045          groups_add_member($group1, $user1);
1046          groups_add_member($group2, $user1);
1047          groups_add_member($group3, $user1);
1048          groups_add_member($group4, $user1);
1049  
1050          $this->setUser($user1);
1051          $accessinfo = $search->get_areas_user_accesses();
1052          $contexts = $accessinfo->usercontexts;
1053  
1054          // Double-check all the forum contexts.
1055          $postcontexts = $contexts['mod_forum-post'];
1056          sort($postcontexts);
1057          $this->assertEquals([$id1s, $id1v, $id2s, $id2n], $postcontexts);
1058  
1059          // Only the context in the second course (no accessallgroups) is restricted.
1060          $restrictedcontexts = $accessinfo->separategroupscontexts;
1061          sort($restrictedcontexts);
1062          $this->assertEquals([$id2s], $restrictedcontexts);
1063  
1064          // Only the groups from the second course (no accessallgroups) are included.
1065          $groupids = $accessinfo->usergroups;
1066          sort($groupids);
1067          $this->assertEquals([$group3->id, $group4->id], $groupids);
1068  
1069          // User 2 is a student in each course and belongs to groups 2 and 4.
1070          $user2 = $generator->create_user();
1071          $generator->enrol_user($user2->id, $course1->id, 'student');
1072          $generator->enrol_user($user2->id, $course2->id, 'student');
1073          groups_add_member($group2, $user2);
1074          groups_add_member($group4, $user2);
1075  
1076          $this->setUser($user2);
1077          $accessinfo = $search->get_areas_user_accesses();
1078          $contexts = $accessinfo->usercontexts;
1079  
1080          // Double-check all the forum contexts.
1081          $postcontexts = $contexts['mod_forum-post'];
1082          sort($postcontexts);
1083          $this->assertEquals([$id1s, $id1v, $id2s, $id2n], $postcontexts);
1084  
1085          // Both separate groups forums are restricted.
1086          $restrictedcontexts = $accessinfo->separategroupscontexts;
1087          sort($restrictedcontexts);
1088          $this->assertEquals([$id1s, $id2s], $restrictedcontexts);
1089  
1090          // Groups from both courses are included.
1091          $groupids = $accessinfo->usergroups;
1092          sort($groupids);
1093          $this->assertEquals([$group2->id, $group4->id], $groupids);
1094  
1095          // User 3 is a manager at system level.
1096          $user3 = $generator->create_user();
1097          role_assign($DB->get_field('role', 'id', ['shortname' => 'manager'], MUST_EXIST), $user3->id,
1098                  \context_system::instance());
1099  
1100          $this->setUser($user3);
1101          $accessinfo = $search->get_areas_user_accesses();
1102  
1103          // Nothing is restricted and no groups are relevant.
1104          $this->assertEquals([], $accessinfo->separategroupscontexts);
1105          $this->assertEquals([], $accessinfo->usergroups);
1106      }
1107  
1108      /**
1109       * test_is_search_area
1110       *
1111       * @return void
1112       */
1113      public function test_is_search_area() {
1114  
1115          $this->assertFalse(\testable_core_search::is_search_area('\asd\asd'));
1116          $this->assertFalse(\testable_core_search::is_search_area('\mod_forum\search\posta'));
1117          $this->assertFalse(\testable_core_search::is_search_area('\core_search\base_mod'));
1118          $this->assertTrue(\testable_core_search::is_search_area('\mod_forum\search\post'));
1119          $this->assertTrue(\testable_core_search::is_search_area('\\mod_forum\\search\\post'));
1120          $this->assertTrue(\testable_core_search::is_search_area('mod_forum\\search\\post'));
1121      }
1122  
1123      /**
1124       * Tests the request_index function used for reindexing certain contexts. This only tests
1125       * adding things to the request list, it doesn't test that they are actually indexed by the
1126       * scheduled task.
1127       */
1128      public function test_request_index() {
1129          global $DB;
1130  
1131          $this->resetAfterTest();
1132  
1133          $course1 = $this->getDataGenerator()->create_course();
1134          $course1ctx = \context_course::instance($course1->id);
1135          $course2 = $this->getDataGenerator()->create_course();
1136          $course2ctx = \context_course::instance($course2->id);
1137          $forum1 = $this->getDataGenerator()->create_module('forum', ['course' => $course1->id]);
1138          $forum1ctx = \context_module::instance($forum1->cmid);
1139          $forum2 = $this->getDataGenerator()->create_module('forum', ['course' => $course2->id]);
1140          $forum2ctx = \context_module::instance($forum2->cmid);
1141  
1142          // Initially no requests.
1143          $this->assertEquals(0, $DB->count_records('search_index_requests'));
1144  
1145          // Request update for course 1, all areas.
1146          \core_search\manager::request_index($course1ctx);
1147  
1148          // Check all details of entry.
1149          $results = array_values($DB->get_records('search_index_requests'));
1150          $this->assertCount(1, $results);
1151          $this->assertEquals($course1ctx->id, $results[0]->contextid);
1152          $this->assertEquals('', $results[0]->searcharea);
1153          $now = time();
1154          $this->assertLessThanOrEqual($now, $results[0]->timerequested);
1155          $this->assertGreaterThan($now - 10, $results[0]->timerequested);
1156          $this->assertEquals('', $results[0]->partialarea);
1157          $this->assertEquals(0, $results[0]->partialtime);
1158  
1159          // Request forum 1, all areas; not added as covered by course 1.
1160          \core_search\manager::request_index($forum1ctx);
1161          $this->assertEquals(1, $DB->count_records('search_index_requests'));
1162  
1163          // Request forum 1, specific area; not added as covered by course 1 all areas.
1164          \core_search\manager::request_index($forum1ctx, 'forum-post');
1165          $this->assertEquals(1, $DB->count_records('search_index_requests'));
1166  
1167          // Request course 1 again, specific area; not added as covered by all areas.
1168          \core_search\manager::request_index($course1ctx, 'forum-post');
1169          $this->assertEquals(1, $DB->count_records('search_index_requests'));
1170  
1171          // Request course 1 again, all areas; not needed as covered already.
1172          \core_search\manager::request_index($course1ctx);
1173          $this->assertEquals(1, $DB->count_records('search_index_requests'));
1174  
1175          // Request course 2, specific area.
1176          \core_search\manager::request_index($course2ctx, 'label-activity');
1177          // Note: I'm ordering by ID for convenience - this is dangerous in real code (see MDL-43447)
1178          // but in a unit test it shouldn't matter as nobody is using clustered databases for unit
1179          // test.
1180          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1181          $this->assertCount(2, $results);
1182          $this->assertEquals($course1ctx->id, $results[0]->contextid);
1183          $this->assertEquals($course2ctx->id, $results[1]->contextid);
1184          $this->assertEquals('label-activity', $results[1]->searcharea);
1185  
1186          // Request forum 2, same specific area; not added.
1187          \core_search\manager::request_index($forum2ctx, 'label-activity');
1188          $this->assertEquals(2, $DB->count_records('search_index_requests'));
1189  
1190          // Request forum 2, different specific area; added.
1191          \core_search\manager::request_index($forum2ctx, 'forum-post');
1192          $this->assertEquals(3, $DB->count_records('search_index_requests'));
1193  
1194          // Request forum 2, all areas; also added. (Note: This could obviously remove the previous
1195          // one, but for simplicity, I didn't make it do that; also it could perhaps cause problems
1196          // if we had already begun processing the previous entry.)
1197          \core_search\manager::request_index($forum2ctx);
1198          $this->assertEquals(4, $DB->count_records('search_index_requests'));
1199  
1200          // Clear queue and do tests relating to priority.
1201          $DB->delete_records('search_index_requests');
1202  
1203          // Request forum 1, specific area, priority 100.
1204          \core_search\manager::request_index($forum1ctx, 'forum-post', 100);
1205          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1206          $this->assertCount(1, $results);
1207          $this->assertEquals(100, $results[0]->indexpriority);
1208  
1209          // Request forum 1, same area, lower priority; no change.
1210          \core_search\manager::request_index($forum1ctx, 'forum-post', 99);
1211          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1212          $this->assertCount(1, $results);
1213          $this->assertEquals(100, $results[0]->indexpriority);
1214  
1215          // Request forum 1, same area, higher priority; priority stored changes.
1216          \core_search\manager::request_index($forum1ctx, 'forum-post', 101);
1217          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1218          $this->assertCount(1, $results);
1219          $this->assertEquals(101, $results[0]->indexpriority);
1220  
1221          // Request forum 1, all areas, lower priority; adds second entry.
1222          \core_search\manager::request_index($forum1ctx, '', 100);
1223          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1224          $this->assertCount(2, $results);
1225          $this->assertEquals(100, $results[1]->indexpriority);
1226  
1227          // Request course 1, all areas, lower priority; adds third entry.
1228          \core_search\manager::request_index($course1ctx, '', 99);
1229          $results = array_values($DB->get_records('search_index_requests', null, 'id'));
1230          $this->assertCount(3, $results);
1231          $this->assertEquals(99, $results[2]->indexpriority);
1232      }
1233  
1234      /**
1235       * Tests the process_index_requests function.
1236       */
1237      public function test_process_index_requests() {
1238          global $DB;
1239  
1240          $this->resetAfterTest();
1241  
1242          $search = \testable_core_search::instance();
1243  
1244          // When there are no index requests, nothing gets logged.
1245          $progress = new \progress_trace_buffer(new \text_progress_trace(), false);
1246          $search->process_index_requests(0.0, $progress);
1247          $out = $progress->get_buffer();
1248          $progress->reset_buffer();
1249          $this->assertEquals('', $out);
1250  
1251          // Set up the course with 3 forums.
1252          $generator = $this->getDataGenerator();
1253          $course = $generator->create_course(['fullname' => 'TCourse']);
1254          $forum1 = $generator->create_module('forum', ['course' => $course->id, 'name' => 'TForum1']);
1255          $forum2 = $generator->create_module('forum', ['course' => $course->id, 'name' => 'TForum2']);
1256          $forum3 = $generator->create_module('forum', ['course' => $course->id, 'name' => 'TForum3']);
1257  
1258          // Hack the forums so they have different creation times.
1259          $now = time();
1260          $DB->set_field('forum', 'timemodified', $now - 30, ['id' => $forum1->id]);
1261          $DB->set_field('forum', 'timemodified', $now - 20, ['id' => $forum2->id]);
1262          $DB->set_field('forum', 'timemodified', $now - 10, ['id' => $forum3->id]);
1263          $forum2time = $now - 20;
1264  
1265          // Make 2 index requests.
1266          \testable_core_search::fake_current_time($now - 3);
1267          $search::request_index(\context_course::instance($course->id), 'mod_label-activity');
1268          \testable_core_search::fake_current_time($now - 2);
1269          $search::request_index(\context_module::instance($forum1->cmid));
1270  
1271          // Run with no time limit.
1272          $search->process_index_requests(0.0, $progress);
1273          $out = $progress->get_buffer();
1274          $progress->reset_buffer();
1275  
1276          // Check that it's done both areas.
1277          $this->assertStringContainsString(
1278                  'Indexing requested context: Course: TCourse (search area: mod_label-activity)',
1279                  $out);
1280          $this->assertStringContainsString(
1281                  'Completed requested context: Course: TCourse (search area: mod_label-activity)',
1282                  $out);
1283          $this->assertStringContainsString('Indexing requested context: Forum: TForum1', $out);
1284          $this->assertStringContainsString('Completed requested context: Forum: TForum1', $out);
1285  
1286          // Check the requests database table is now empty.
1287          $this->assertEquals(0, $DB->count_records('search_index_requests'));
1288  
1289          // Request indexing the course a couple of times.
1290          \testable_core_search::fake_current_time($now - 3);
1291          $search::request_index(\context_course::instance($course->id), 'mod_forum-activity');
1292          \testable_core_search::fake_current_time($now - 2);
1293          $search::request_index(\context_course::instance($course->id), 'mod_forum-post');
1294  
1295          // Do the processing again with a time limit and indexing delay. The time limit is too
1296          // small; because of the way the logic works, this means it will index 2 activities.
1297          $search->get_engine()->set_add_delay(0.2);
1298          $search->process_index_requests(0.1, $progress);
1299          $out = $progress->get_buffer();
1300          $progress->reset_buffer();
1301  
1302          // Confirm the right wrapper information was logged.
1303          $this->assertStringContainsString(
1304                  'Indexing requested context: Course: TCourse (search area: mod_forum-activity)',
1305                  $out);
1306          $this->assertStringContainsString('Stopping indexing due to time limit', $out);
1307          $this->assertStringContainsString(
1308                  'Ending requested context: Course: TCourse (search area: mod_forum-activity)',
1309                  $out);
1310  
1311          // Check the database table has been updated with progress.
1312          $records = array_values($DB->get_records('search_index_requests', null, 'searcharea'));
1313          $this->assertEquals('mod_forum-activity', $records[0]->partialarea);
1314          $this->assertEquals($forum2time, $records[0]->partialtime);
1315  
1316          // Run again and confirm it now finishes.
1317          $search->process_index_requests(2.0, $progress);
1318          $out = $progress->get_buffer();
1319          $progress->reset_buffer();
1320          $this->assertStringContainsString(
1321                  'Completed requested context: Course: TCourse (search area: mod_forum-activity)',
1322                  $out);
1323          $this->assertStringContainsString(
1324                  'Completed requested context: Course: TCourse (search area: mod_forum-post)',
1325                  $out);
1326  
1327          // Confirm table is now empty.
1328          $this->assertEquals(0, $DB->count_records('search_index_requests'));
1329  
1330          // Make 2 requests - first one is low priority.
1331          \testable_core_search::fake_current_time($now - 3);
1332          $search::request_index(\context_module::instance($forum1->cmid), 'mod_forum-activity',
1333                  \core_search\manager::INDEX_PRIORITY_REINDEXING);
1334          \testable_core_search::fake_current_time($now - 2);
1335          $search::request_index(\context_module::instance($forum2->cmid), 'mod_forum-activity');
1336  
1337          // Process with short time limit and confirm it does the second one first.
1338          $search->process_index_requests(0.1, $progress);
1339          $out = $progress->get_buffer();
1340          $progress->reset_buffer();
1341          $this->assertStringContainsString(
1342                  'Completed requested context: Forum: TForum2 (search area: mod_forum-activity)',
1343                  $out);
1344          $search->process_index_requests(0.1, $progress);
1345          $out = $progress->get_buffer();
1346          $progress->reset_buffer();
1347          $this->assertStringContainsString(
1348                  'Completed requested context: Forum: TForum1 (search area: mod_forum-activity)',
1349                  $out);
1350  
1351          // Make a request for a course context...
1352          $course = $generator->create_course();
1353          $context = \context_course::instance($course->id);
1354          $search::request_index($context);
1355  
1356          // ...but then delete it (note: delete_course spews output, so we throw it away).
1357          ob_start();
1358          delete_course($course);
1359          ob_end_clean();
1360  
1361          // Process requests - it should only note the deleted context.
1362          $search->process_index_requests(10, $progress);
1363          $out = $progress->get_buffer();
1364          $progress->reset_buffer();
1365          $this->assertStringContainsString('Skipped deleted context: ' . $context->id, $out);
1366  
1367          // Confirm request table is now empty.
1368          $this->assertEquals(0, $DB->count_records('search_index_requests'));
1369      }
1370  
1371      /**
1372       * Test search area categories.
1373       */
1374      public function test_get_search_area_categories() {
1375          $categories = \core_search\manager::get_search_area_categories();
1376  
1377          $this->assertTrue(is_array($categories));
1378          $this->assertTrue(count($categories) >= 4); // We always should have 4 core categories.
1379          $this->assertArrayHasKey('core-all', $categories);
1380          $this->assertArrayHasKey('core-course-content', $categories);
1381          $this->assertArrayHasKey('core-courses', $categories);
1382          $this->assertArrayHasKey('core-users', $categories);
1383  
1384          foreach ($categories as $category) {
1385              $this->assertInstanceOf('\core_search\area_category', $category);
1386          }
1387      }
1388  
1389      /**
1390       * Test that we can find out if search area categories functionality is enabled.
1391       */
1392      public function test_is_search_area_categories_enabled() {
1393          $this->resetAfterTest();
1394  
1395          $this->assertFalse(\core_search\manager::is_search_area_categories_enabled());
1396          set_config('searchenablecategories', 1);
1397          $this->assertTrue(\core_search\manager::is_search_area_categories_enabled());
1398          set_config('searchenablecategories', 0);
1399          $this->assertFalse(\core_search\manager::is_search_area_categories_enabled());
1400      }
1401  
1402      /**
1403       * Test that we can find out if hiding all results category is enabled.
1404       */
1405      public function test_should_hide_all_results_category() {
1406          $this->resetAfterTest();
1407  
1408          $this->assertEquals(0, \core_search\manager::should_hide_all_results_category());
1409          set_config('searchhideallcategory', 1);
1410          $this->assertEquals(1, \core_search\manager::should_hide_all_results_category());
1411          set_config('searchhideallcategory', 0);
1412          $this->assertEquals(0, \core_search\manager::should_hide_all_results_category());
1413      }
1414  
1415      /**
1416       * Test that we can get default search category name.
1417       */
1418      public function test_get_default_area_category_name() {
1419          $this->resetAfterTest();
1420  
1421          $expected = 'core-all';
1422          $this->assertEquals($expected, \core_search\manager::get_default_area_category_name());
1423  
1424          set_config('searchhideallcategory', 1);
1425          $expected = 'core-course-content';
1426          $this->assertEquals($expected, \core_search\manager::get_default_area_category_name());
1427  
1428          set_config('searchhideallcategory', 0);
1429          $expected = 'core-all';
1430          $this->assertEquals($expected, \core_search\manager::get_default_area_category_name());
1431      }
1432  
1433      /**
1434       * Test that we can get correct search area category by its name.
1435       */
1436      public function test_get_search_area_category_by_name() {
1437          $this->resetAfterTest();
1438  
1439          $testcategory = \core_search\manager::get_search_area_category_by_name('test_random_name');
1440          $this->assertEquals('core-all', $testcategory->get_name());
1441  
1442          $testcategory = \core_search\manager::get_search_area_category_by_name('core-courses');
1443          $this->assertEquals('core-courses', $testcategory->get_name());
1444  
1445          set_config('searchhideallcategory', 1);
1446          $testcategory = \core_search\manager::get_search_area_category_by_name('test_random_name');
1447          $this->assertEquals('core-course-content', $testcategory->get_name());
1448      }
1449  
1450      /**
1451       * Test that we can check that "Include all visible courses" feature is enabled.
1452       */
1453      public function test_include_all_courses_enabled() {
1454          $this->resetAfterTest();
1455          $this->assertFalse(\core_search\manager::include_all_courses());
1456          set_config('searchincludeallcourses', 1);
1457          $this->assertTrue(\core_search\manager::include_all_courses());
1458      }
1459  
1460      /**
1461       * Test that we can correctly build a list of courses for a course filter for the search results.
1462       */
1463      public function test_build_limitcourseids() {
1464          global $USER;
1465  
1466          $this->resetAfterTest();
1467          $this->setAdminUser();
1468  
1469          $course1 = $this->getDataGenerator()->create_course();
1470          $course2 = $this->getDataGenerator()->create_course();
1471          $course3 = $this->getDataGenerator()->create_course();
1472          $course4 = $this->getDataGenerator()->create_course();
1473  
1474          $this->getDataGenerator()->enrol_user($USER->id, $course1->id);
1475          $this->getDataGenerator()->enrol_user($USER->id, $course3->id);
1476  
1477          $search = \testable_core_search::instance();
1478  
1479          $formdata = new \stdClass();
1480          $formdata->courseids = [];
1481          $formdata->mycoursesonly = false;
1482          $limitcourseids = $search->build_limitcourseids($formdata);
1483          $this->assertEquals(false, $limitcourseids);
1484  
1485          $formdata->courseids = [];
1486          $formdata->mycoursesonly = true;
1487          $limitcourseids = $search->build_limitcourseids($formdata);
1488          $this->assertEquals([$course1->id, $course3->id], $limitcourseids);
1489  
1490          $formdata->courseids = [$course1->id, $course2->id, $course4->id];
1491          $formdata->mycoursesonly = false;
1492          $limitcourseids = $search->build_limitcourseids($formdata);
1493          $this->assertEquals([$course1->id, $course2->id, $course4->id], $limitcourseids);
1494  
1495          $formdata->courseids = [$course1->id, $course2->id, $course4->id];
1496          $formdata->mycoursesonly = true;
1497          $limitcourseids = $search->build_limitcourseids($formdata);
1498          $this->assertEquals([$course1->id], $limitcourseids);
1499      }
1500  
1501      /**
1502       * Test data for test_parse_areaid test fucntion.
1503       *
1504       * @return array
1505       */
1506      public function parse_search_area_id_data_provider() {
1507          return [
1508              ['mod_book-chapter', ['mod_book', 'search_chapter']],
1509              ['mod_customcert-activity', ['mod_customcert', 'search_activity']],
1510              ['core_course-mycourse', ['core_search', 'core_course_mycourse']],
1511          ];
1512      }
1513  
1514      /**
1515       * Test that manager class can parse area id correctly.
1516       * @dataProvider parse_search_area_id_data_provider
1517       *
1518       * @param string $areaid Area id to parse.
1519       * @param array $expected Expected result of parsing.
1520       */
1521      public function test_parse_search_area_id($areaid, $expected) {
1522          $this->assertEquals($expected, \core_search\manager::parse_areaid($areaid));
1523      }
1524  
1525      /**
1526       * Test that manager class will throw an exception when parsing an invalid area id.
1527       */
1528      public function test_parse_invalid_search_area_id() {
1529          $this->expectException('coding_exception');
1530          $this->expectExceptionMessage('Trying to parse invalid search area id invalid_area');
1531          \core_search\manager::parse_areaid('invalid_area');
1532      }
1533  
1534      /**
1535       * Test getting a coding exception when trying to lean up existing search area.
1536       */
1537      public function test_cleaning_up_existing_search_area() {
1538          $expectedmessage = "Area mod_assign-activity exists. Please use appropriate search area class to manipulate the data.";
1539  
1540          $this->expectException('coding_exception');
1541          $this->expectExceptionMessage($expectedmessage);
1542  
1543          \core_search\manager::clean_up_non_existing_area('mod_assign-activity');
1544      }
1545  
1546      /**
1547       * Test clean up of non existing search area.
1548       */
1549      public function test_clean_up_non_existing_search_area() {
1550          global $DB;
1551  
1552          $this->resetAfterTest();
1553  
1554          $areaid = 'core_course-mycourse';
1555          $plugin = 'core_search';
1556  
1557          // Get all settings to DB and make sure they are there.
1558          foreach (\core_search\base::get_settingnames() as $settingname) {
1559              $record = new \stdClass();
1560              $record->plugin = $plugin;
1561              $record->name = 'core_course_mycourse'. $settingname;
1562              $record->value = 'test';
1563  
1564              $DB->insert_record('config_plugins', $record);
1565              $this->assertTrue($DB->record_exists('config_plugins', ['plugin' => $plugin, 'name' => $record->name]));
1566          }
1567  
1568          // Clean up the search area.
1569          \core_search\manager::clean_up_non_existing_area($areaid);
1570  
1571          // Check that records are not in DB after we ran clean up.
1572          foreach (\core_search\base::get_settingnames() as $settingname) {
1573              $plugin = 'core_search';
1574              $name = 'core_course_mycourse'. $settingname;
1575              $this->assertFalse($DB->record_exists('config_plugins', ['plugin' => $plugin, 'name' => $name]));
1576          }
1577      }
1578  
1579      /**
1580       * Tests the context_deleted, course_deleting_start, and course_deleting_finish methods.
1581       */
1582      public function test_context_deletion() {
1583          $this->resetAfterTest();
1584  
1585          // Create one course with 4 activities, and another with one.
1586          $generator = $this->getDataGenerator();
1587          $course1 = $generator->create_course();
1588          $page1 = $generator->create_module('page', ['course' => $course1]);
1589          $context1 = \context_module::instance($page1->cmid);
1590          $page2 = $generator->create_module('page', ['course' => $course1]);
1591          $page3 = $generator->create_module('page', ['course' => $course1]);
1592          $context3 = \context_module::instance($page3->cmid);
1593          $page4 = $generator->create_module('page', ['course' => $course1]);
1594          $course2 = $generator->create_course();
1595          $page5 = $generator->create_module('page', ['course' => $course2]);
1596          $context5 = \context_module::instance($page5->cmid);
1597  
1598          // Also create a user.
1599          $user = $generator->create_user();
1600          $usercontext = \context_user::instance($user->id);
1601  
1602          $search = \testable_core_search::instance();
1603  
1604          // Delete two of the pages individually.
1605          course_delete_module($page1->cmid);
1606          course_delete_module($page3->cmid);
1607  
1608          // Delete the course with another two.
1609          delete_course($course1->id, false);
1610  
1611          // Delete the user.
1612          delete_user($user);
1613  
1614          // Delete the page from the other course.
1615          course_delete_module($page5->cmid);
1616  
1617          // It should have deleted the contexts and the course, but not the contexts in the course.
1618          $expected = [
1619              ['context', $context1->id],
1620              ['context', $context3->id],
1621              ['course', $course1->id],
1622              ['context', $usercontext->id],
1623              ['context', $context5->id]
1624          ];
1625          $this->assertEquals($expected, $search->get_engine()->get_and_clear_deletes());
1626      }
1627  }