lib/tests/filterlib_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 namespace core;
  18
  19 use filter_manager;
  20
  21 defined('MOODLE_INTERNAL') || die();
  22
  23 global $CFG;
  24 require_once($CFG->libdir . '/filterlib.php');
  25
  26 /**
  27  * Test filters.
  28  *
  29  * Tests for the parts of ../filterlib.php that involve loading the configuration
  30  * from, and saving the configuration to, the database.
  31  *
  32  * @package   core
  33  * @category  test
  34  * @copyright 2009 Tim Hunt
  35  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36  */
  37 class filterlib_test extends \advanced_testcase {
  38
  39     private function assert_only_one_filter_globally($filter, $state) {
  40         global $DB;
  41         $recs = $DB->get_records('filter_active');
  42         $this->assertCount(1, $recs);
  43         $rec = reset($recs);
  44         unset($rec->id);
  45         $expectedrec = new \stdClass();
  46         $expectedrec->filter = $filter;
  47         $expectedrec->contextid = \context_system::instance()->id;
  48         $expectedrec->active = $state;
  49         $expectedrec->sortorder = 1;
  50         $this->assertEquals($expectedrec, $rec);
  51     }
  52
  53     private function assert_global_sort_order($filters) {
  54         global $DB;
  55
  56         $sortedfilters = $DB->get_records_menu('filter_active',
  57             array('contextid' => \context_system::instance()->id), 'sortorder', 'sortorder,filter');
  58         $testarray = array();
  59         $index = 1;
  60         foreach ($filters as $filter) {
  61             $testarray[$index++] = $filter;
  62         }
  63         $this->assertEquals($testarray, $sortedfilters);
  64     }
  65
  66     public function test_set_filter_globally_on() {
  67         $this->resetAfterTest();
  68         $this->remove_all_filters_from_config(); // Remove all filters.
  69         // Setup fixture.
  70         // Exercise SUT.
  71         filter_set_global_state('name', TEXTFILTER_ON);
  72         // Validate.
  73         $this->assert_only_one_filter_globally('name', TEXTFILTER_ON);
  74     }
  75
  76     public function test_set_filter_globally_off() {
  77         $this->resetAfterTest();
  78         $this->remove_all_filters_from_config(); // Remove all filters.
  79         // Setup fixture.
  80         // Exercise SUT.
  81         filter_set_global_state('name', TEXTFILTER_OFF);
  82         // Validate.
  83         $this->assert_only_one_filter_globally('name', TEXTFILTER_OFF);
  84     }
  85
  86     public function test_set_filter_globally_disabled() {
  87         $this->resetAfterTest();
  88         $this->remove_all_filters_from_config(); // Remove all filters.
  89         // Setup fixture.
  90         // Exercise SUT.
  91         filter_set_global_state('name', TEXTFILTER_DISABLED);
  92         // Validate.
  93         $this->assert_only_one_filter_globally('name', TEXTFILTER_DISABLED);
  94     }
  95
  96     public function test_global_config_exception_on_invalid_state() {
  97         $this->resetAfterTest();
  98         $this->expectException(\coding_exception::class);
  99         filter_set_global_state('name', 0);
 100     }
 101
 102     public function test_auto_sort_order() {
 103         $this->resetAfterTest();
 104         $this->remove_all_filters_from_config(); // Remove all filters.
 105         // Setup fixture.
 106         // Exercise SUT.
 107         filter_set_global_state('one', TEXTFILTER_DISABLED);
 108         filter_set_global_state('two', TEXTFILTER_DISABLED);
 109         // Validate.
 110         $this->assert_global_sort_order(array('one', 'two'));
 111     }
 112
 113     public function test_auto_sort_order_enabled() {
 114         $this->resetAfterTest();
 115         $this->remove_all_filters_from_config(); // Remove all filters.
 116         // Setup fixture.
 117         // Exercise SUT.
 118         filter_set_global_state('one', TEXTFILTER_ON);
 119         filter_set_global_state('two', TEXTFILTER_OFF);
 120         // Validate.
 121         $this->assert_global_sort_order(array('one', 'two'));
 122     }
 123
 124     public function test_update_existing_dont_duplicate() {
 125         $this->resetAfterTest();
 126         $this->remove_all_filters_from_config(); // Remove all filters.
 127         // Setup fixture.
 128         // Exercise SUT.
 129         filter_set_global_state('name', TEXTFILTER_ON);
 130         filter_set_global_state('name', TEXTFILTER_OFF);
 131         // Validate.
 132         $this->assert_only_one_filter_globally('name', TEXTFILTER_OFF);
 133     }
 134
 135     public function test_update_reorder_down() {
 136         global $DB;
 137
 138         $this->resetAfterTest();
 139         $this->remove_all_filters_from_config(); // Remove all filters.
 140         // Setup fixture.
 141         filter_set_global_state('one', TEXTFILTER_ON);
 142         filter_set_global_state('two', TEXTFILTER_ON);
 143         filter_set_global_state('three', TEXTFILTER_ON);
 144         // Exercise SUT.
 145         filter_set_global_state('two', TEXTFILTER_ON, -1);
 146         // Validate.
 147         $this->assert_global_sort_order(array('two', 'one', 'three'));
 148
 149         // Check this was logged in config log.
 150         $logs = $DB->get_records('config_log', null, 'id DESC', '*', 0, 1);
 151         $log = reset($logs);
 152         $this->assertEquals('core_filter', $log->plugin);
 153         $this->assertEquals('order', $log->name);
 154         $this->assertEquals('two, one, three', $log->value);
 155         $this->assertEquals('one, two, three', $log->oldvalue);
 156     }
 157
 158     public function test_update_reorder_up() {
 159         global $DB;
 160
 161         $this->resetAfterTest();
 162         $this->remove_all_filters_from_config(); // Remove all filters.
 163         // Setup fixture.
 164         filter_set_global_state('one', TEXTFILTER_ON);
 165         filter_set_global_state('two', TEXTFILTER_ON);
 166         filter_set_global_state('three', TEXTFILTER_ON);
 167         filter_set_global_state('four', TEXTFILTER_ON);
 168         // Exercise SUT.
 169         filter_set_global_state('two', TEXTFILTER_ON, 1);
 170         // Validate.
 171         $this->assert_global_sort_order(array('one', 'three', 'two', 'four'));
 172
 173         // Check this was logged in config log.
 174         $logs = $DB->get_records('config_log', null, 'id DESC', '*', 0, 1);
 175         $log = reset($logs);
 176         $this->assertEquals('core_filter', $log->plugin);
 177         $this->assertEquals('order', $log->name);
 178         $this->assertEquals('one, three, two, four', $log->value);
 179         $this->assertEquals('one, two, three, four', $log->oldvalue);
 180     }
 181
 182     public function test_auto_sort_order_change_to_enabled() {
 183         $this->resetAfterTest();
 184         $this->remove_all_filters_from_config(); // Remove all filters.
 185         // Setup fixture.
 186         filter_set_global_state('one', TEXTFILTER_ON);
 187         filter_set_global_state('two', TEXTFILTER_DISABLED);
 188         filter_set_global_state('three', TEXTFILTER_DISABLED);
 189         // Exercise SUT.
 190         filter_set_global_state('three', TEXTFILTER_ON);
 191         // Validate.
 192         $this->assert_global_sort_order(array('one', 'three', 'two'));
 193     }
 194
 195     public function test_auto_sort_order_change_to_disabled() {
 196         $this->resetAfterTest();
 197         $this->remove_all_filters_from_config(); // Remove all filters.
 198         // Setup fixture.
 199         filter_set_global_state('one', TEXTFILTER_ON);
 200         filter_set_global_state('two', TEXTFILTER_ON);
 201         filter_set_global_state('three', TEXTFILTER_DISABLED);
 202         // Exercise SUT.
 203         filter_set_global_state('one', TEXTFILTER_DISABLED);
 204         // Validate.
 205         $this->assert_global_sort_order(array('two', 'one', 'three'));
 206     }
 207
 208     public function test_filter_get_global_states() {
 209         $this->resetAfterTest();
 210         $this->remove_all_filters_from_config(); // Remove all filters.
 211         // Setup fixture.
 212         filter_set_global_state('one', TEXTFILTER_ON);
 213         filter_set_global_state('two', TEXTFILTER_OFF);
 214         filter_set_global_state('three', TEXTFILTER_DISABLED);
 215         // Exercise SUT.
 216         $filters = filter_get_global_states();
 217         // Validate.
 218         $this->assertEquals(array(
 219             'one' => (object) array('filter' => 'one', 'active' => TEXTFILTER_ON, 'sortorder' => 1),
 220             'two' => (object) array('filter' => 'two', 'active' => TEXTFILTER_OFF, 'sortorder' => 2),
 221             'three' => (object) array('filter' => 'three', 'active' => TEXTFILTER_DISABLED, 'sortorder' => 3)
 222         ), $filters);
 223     }
 224
 225     private function assert_only_one_local_setting($filter, $contextid, $state) {
 226         global $DB;
 227         $recs = $DB->get_records('filter_active');
 228         $this->assertEquals(1, count($recs), 'More than one record returned %s.');
 229         $rec = reset($recs);
 230         unset($rec->id);
 231         unset($rec->sortorder);
 232         $expectedrec = new \stdClass();
 233         $expectedrec->filter = $filter;
 234         $expectedrec->contextid = $contextid;
 235         $expectedrec->active = $state;
 236         $this->assertEquals($expectedrec, $rec);
 237     }
 238
 239     private function assert_no_local_setting() {
 240         global $DB;
 241         $this->assertEquals(0, $DB->count_records('filter_active'));
 242     }
 243
 244     public function test_local_on() {
 245         $this->resetAfterTest();
 246         $this->remove_all_filters_from_config(); // Remove all filters.
 247         // Exercise SUT.
 248         filter_set_local_state('name', 123, TEXTFILTER_ON);
 249         // Validate.
 250         $this->assert_only_one_local_setting('name', 123, TEXTFILTER_ON);
 251     }
 252
 253     public function test_local_off() {
 254         $this->resetAfterTest();
 255         $this->remove_all_filters_from_config(); // Remove all filters.
 256         // Exercise SUT.
 257         filter_set_local_state('name', 123, TEXTFILTER_OFF);
 258         // Validate.
 259         $this->assert_only_one_local_setting('name', 123, TEXTFILTER_OFF);
 260     }
 261
 262     public function test_local_inherit() {
 263         $this->resetAfterTest();
 264         $this->remove_all_filters_from_config(); // Remove all filters.
 265         // Exercise SUT.
 266         filter_set_local_state('name', 123, TEXTFILTER_INHERIT);
 267         // Validate.
 268         $this->assert_no_local_setting();
 269     }
 270
 271     public function test_local_invalid_state_throws_exception() {
 272         $this->resetAfterTest();
 273         // Exercise SUT.
 274         $this->expectException(\coding_exception::class);
 275         filter_set_local_state('name', 123, -9999);
 276     }
 277
 278     public function test_throws_exception_when_setting_global() {
 279         $this->resetAfterTest();
 280         // Exercise SUT.
 281         $this->expectException(\coding_exception::class);
 282         filter_set_local_state('name', \context_system::instance()->id, TEXTFILTER_INHERIT);
 283     }
 284
 285     public function test_local_inherit_deletes_existing() {
 286         $this->resetAfterTest();
 287         $this->remove_all_filters_from_config(); // Remove all filters.
 288         // Setup fixture.
 289         filter_set_local_state('name', 123, TEXTFILTER_INHERIT);
 290         // Exercise SUT.
 291         filter_set_local_state('name', 123, TEXTFILTER_INHERIT);
 292         // Validate.
 293         $this->assert_no_local_setting();
 294     }
 295
 296     private function assert_only_one_config($filter, $context, $name, $value) {
 297         global $DB;
 298         $recs = $DB->get_records('filter_config');
 299         $this->assertEquals(1, count($recs), 'More than one record returned %s.');
 300         $rec = reset($recs);
 301         unset($rec->id);
 302         $expectedrec = new \stdClass();
 303         $expectedrec->filter = $filter;
 304         $expectedrec->contextid = $context;
 305         $expectedrec->name = $name;
 306         $expectedrec->value = $value;
 307         $this->assertEquals($expectedrec, $rec);
 308     }
 309
 310     public function test_set_new_config() {
 311         $this->resetAfterTest();
 312         $this->remove_all_filters_from_config(); // Remove all filters.
 313         // Exercise SUT.
 314         filter_set_local_config('name', 123, 'settingname', 'An arbitrary value');
 315         // Validate.
 316         $this->assert_only_one_config('name', 123, 'settingname', 'An arbitrary value');
 317     }
 318
 319     public function test_update_existing_config() {
 320         $this->resetAfterTest();
 321         $this->remove_all_filters_from_config(); // Remove all filters.
 322         // Setup fixture.
 323         filter_set_local_config('name', 123, 'settingname', 'An arbitrary value');
 324         // Exercise SUT.
 325         filter_set_local_config('name', 123, 'settingname', 'A changed value');
 326         // Validate.
 327         $this->assert_only_one_config('name', 123, 'settingname', 'A changed value');
 328     }
 329
 330     public function test_filter_get_local_config() {
 331         $this->resetAfterTest();
 332         // Setup fixture.
 333         filter_set_local_config('name', 123, 'setting1', 'An arbitrary value');
 334         filter_set_local_config('name', 123, 'setting2', 'Another arbitrary value');
 335         filter_set_local_config('name', 122, 'settingname', 'Value from another context');
 336         filter_set_local_config('other', 123, 'settingname', 'Someone else\'s value');
 337         // Exercise SUT.
 338         $config = filter_get_local_config('name', 123);
 339         // Validate.
 340         $this->assertEquals(array('setting1' => 'An arbitrary value', 'setting2' => 'Another arbitrary value'), $config);
 341     }
 342
 343     protected function setup_available_in_context_tests() {
 344         $course = $this->getDataGenerator()->create_course(array('category' => 1));
 345
 346         $childcontext = \context_coursecat::instance(1);
 347         $childcontext2 = \context_course::instance($course->id);
 348         $syscontext = \context_system::instance();
 349
 350         return [
 351             'syscontext' => $syscontext,
 352             'childcontext' => $childcontext,
 353             'childcontext2' => $childcontext2
 354         ];
 355     }
 356
 357     protected function remove_all_filters_from_config() {
 358         global $DB;
 359         $DB->delete_records('filter_active', array());
 360         $DB->delete_records('filter_config', array());
 361     }
 362
 363     private function assert_filter_list($expectedfilters, $filters) {
 364         $this->assertEqualsCanonicalizing($expectedfilters, array_keys($filters));
 365     }
 366
 367     public function test_globally_on_is_returned() {
 368         $this->resetAfterTest();
 369         $this->remove_all_filters_from_config(); // Remove all filters.
 370         [
 371             'syscontext' => $syscontext
 372         ] = $this->setup_available_in_context_tests();
 373         // Setup fixture.
 374         filter_set_global_state('name', TEXTFILTER_ON);
 375         // Exercise SUT.
 376         $filters = filter_get_active_in_context($syscontext);
 377         // Validate.
 378         $this->assert_filter_list(array('name'), $filters);
 379         // Check no config returned correctly.
 380         $this->assertEquals(array(), $filters['name']);
 381     }
 382
 383     public function test_globally_off_not_returned() {
 384         $this->resetAfterTest();
 385         $this->remove_all_filters_from_config(); // Remove all filters.
 386         [
 387             'childcontext2' => $childcontext2
 388         ] = $this->setup_available_in_context_tests();
 389         // Setup fixture.
 390         filter_set_global_state('name', TEXTFILTER_OFF);
 391         // Exercise SUT.
 392         $filters = filter_get_active_in_context($childcontext2);
 393         // Validate.
 394         $this->assert_filter_list(array(), $filters);
 395     }
 396
 397     public function test_globally_off_overridden() {
 398         $this->resetAfterTest();
 399         $this->remove_all_filters_from_config(); // Remove all filters.
 400         [
 401             'childcontext' => $childcontext,
 402             'childcontext2' => $childcontext2
 403         ] = $this->setup_available_in_context_tests();
 404         // Setup fixture.
 405         filter_set_global_state('name', TEXTFILTER_OFF);
 406         filter_set_local_state('name', $childcontext->id, TEXTFILTER_ON);
 407         // Exercise SUT.
 408         $filters = filter_get_active_in_context($childcontext2);
 409         // Validate.
 410         $this->assert_filter_list(array('name'), $filters);
 411     }
 412
 413     public function test_globally_on_overridden() {
 414         $this->resetAfterTest();
 415         $this->remove_all_filters_from_config(); // Remove all filters.
 416         [
 417             'childcontext' => $childcontext,
 418             'childcontext2' => $childcontext2
 419         ] = $this->setup_available_in_context_tests();
 420         // Setup fixture.
 421         filter_set_global_state('name', TEXTFILTER_ON);
 422         filter_set_local_state('name', $childcontext->id, TEXTFILTER_OFF);
 423         // Exercise SUT.
 424         $filters = filter_get_active_in_context($childcontext2);
 425         // Validate.
 426         $this->assert_filter_list(array(), $filters);
 427     }
 428
 429     public function test_globally_disabled_not_overridden() {
 430         $this->resetAfterTest();
 431         $this->remove_all_filters_from_config(); // Remove all filters.
 432         [
 433             'syscontext' => $syscontext,
 434             'childcontext' => $childcontext
 435         ] = $this->setup_available_in_context_tests();
 436         // Setup fixture.
 437         filter_set_global_state('name', TEXTFILTER_DISABLED);
 438         filter_set_local_state('name', $childcontext->id, TEXTFILTER_ON);
 439         // Exercise SUT.
 440         $filters = filter_get_active_in_context($syscontext);
 441         // Validate.
 442         $this->assert_filter_list(array(), $filters);
 443     }
 444
 445     public function test_single_config_returned() {
 446         $this->resetAfterTest();
 447         [
 448             'childcontext' => $childcontext
 449         ] = $this->setup_available_in_context_tests();
 450         // Setup fixture.
 451         filter_set_global_state('name', TEXTFILTER_ON);
 452         filter_set_local_config('name', $childcontext->id, 'settingname', 'A value');
 453         // Exercise SUT.
 454         $filters = filter_get_active_in_context($childcontext);
 455         // Validate.
 456         $this->assertEquals(array('settingname' => 'A value'), $filters['name']);
 457     }
 458
 459     public function test_multi_config_returned() {
 460         $this->resetAfterTest();
 461         [
 462             'childcontext' => $childcontext
 463         ] = $this->setup_available_in_context_tests();
 464         // Setup fixture.
 465         filter_set_global_state('name', TEXTFILTER_ON);
 466         filter_set_local_config('name', $childcontext->id, 'settingname', 'A value');
 467         filter_set_local_config('name', $childcontext->id, 'anothersettingname', 'Another value');
 468         // Exercise SUT.
 469         $filters = filter_get_active_in_context($childcontext);
 470         // Validate.
 471         $this->assertEquals(array('settingname' => 'A value', 'anothersettingname' => 'Another value'), $filters['name']);
 472     }
 473
 474     public function test_config_from_other_context_not_returned() {
 475         $this->resetAfterTest();
 476         [
 477             'childcontext' => $childcontext,
 478             'childcontext2' => $childcontext2
 479         ] = $this->setup_available_in_context_tests();
 480         // Setup fixture.
 481         filter_set_global_state('name', TEXTFILTER_ON);
 482         filter_set_local_config('name', $childcontext->id, 'settingname', 'A value');
 483         filter_set_local_config('name', $childcontext2->id, 'anothersettingname', 'Another value');
 484         // Exercise SUT.
 485         $filters = filter_get_active_in_context($childcontext2);
 486         // Validate.
 487         $this->assertEquals(array('anothersettingname' => 'Another value'), $filters['name']);
 488     }
 489
 490     public function test_config_from_other_filter_not_returned() {
 491         $this->resetAfterTest();
 492         [
 493             'childcontext' => $childcontext
 494         ] = $this->setup_available_in_context_tests();
 495         // Setup fixture.
 496         filter_set_global_state('name', TEXTFILTER_ON);
 497         filter_set_local_config('name', $childcontext->id, 'settingname', 'A value');
 498         filter_set_local_config('other', $childcontext->id, 'anothersettingname', 'Another value');
 499         // Exercise SUT.
 500         $filters = filter_get_active_in_context($childcontext);
 501         // Validate.
 502         $this->assertEquals(array('settingname' => 'A value'), $filters['name']);
 503     }
 504
 505     protected function assert_one_available_filter($filter, $localstate, $inheritedstate, $filters) {
 506         $this->assertEquals(1, count($filters), 'More than one record returned %s.');
 507         $rec = $filters[$filter];
 508         unset($rec->id);
 509         $expectedrec = new \stdClass();
 510         $expectedrec->filter = $filter;
 511         $expectedrec->localstate = $localstate;
 512         $expectedrec->inheritedstate = $inheritedstate;
 513         $this->assertEquals($expectedrec, $rec);
 514     }
 515
 516     public function test_available_in_context_localoverride() {
 517         $this->resetAfterTest();
 518         $this->remove_all_filters_from_config(); // Remove all filters.
 519         [
 520             'childcontext' => $childcontext
 521         ] = $this->setup_available_in_context_tests();
 522         // Setup fixture.
 523         filter_set_global_state('name', TEXTFILTER_ON);
 524         filter_set_local_state('name', $childcontext->id, TEXTFILTER_OFF);
 525         // Exercise SUT.
 526         $filters = filter_get_available_in_context($childcontext);
 527         // Validate.
 528         $this->assert_one_available_filter('name', TEXTFILTER_OFF, TEXTFILTER_ON, $filters);
 529     }
 530
 531     public function test_available_in_context_nolocaloverride() {
 532         $this->resetAfterTest();
 533         $this->remove_all_filters_from_config(); // Remove all filters.
 534         [
 535             'childcontext' => $childcontext,
 536             'childcontext2' => $childcontext2
 537         ] = $this->setup_available_in_context_tests();
 538         // Setup fixture.
 539         filter_set_global_state('name', TEXTFILTER_ON);
 540         filter_set_local_state('name', $childcontext->id, TEXTFILTER_OFF);
 541         // Exercise SUT.
 542         $filters = filter_get_available_in_context($childcontext2);
 543         // Validate.
 544         $this->assert_one_available_filter('name', TEXTFILTER_INHERIT, TEXTFILTER_OFF, $filters);
 545     }
 546
 547     public function test_available_in_context_disabled_not_returned() {
 548         $this->resetAfterTest();
 549         $this->remove_all_filters_from_config(); // Remove all filters.
 550         [
 551             'childcontext' => $childcontext
 552         ] = $this->setup_available_in_context_tests();
 553         // Setup fixture.
 554         filter_set_global_state('name', TEXTFILTER_DISABLED);
 555         filter_set_local_state('name', $childcontext->id, TEXTFILTER_ON);
 556         // Exercise SUT.
 557         $filters = filter_get_available_in_context($childcontext);
 558         // Validate.
 559         $this->assertEquals(array(), $filters);
 560     }
 561
 562     public function test_available_in_context_exception_with_syscontext() {
 563         $this->resetAfterTest();
 564         [
 565             'syscontext' => $syscontext
 566         ] = $this->setup_available_in_context_tests();
 567         // Exercise SUT.
 568         $this->expectException(\coding_exception::class);
 569         filter_get_available_in_context($syscontext);
 570     }
 571
 572     protected function setup_preload_activities_test() {
 573         $syscontext = \context_system::instance();
 574         $catcontext = \context_coursecat::instance(1);
 575         $course = $this->getDataGenerator()->create_course(array('category' => 1));
 576         $coursecontext = \context_course::instance($course->id);
 577         $page1 = $this->getDataGenerator()->create_module('page', array('course' => $course->id));
 578         $activity1context = \context_module::instance($page1->cmid);
 579         $page2 = $this->getDataGenerator()->create_module('page', array('course' => $course->id));
 580         $activity2context = \context_module::instance($page2->cmid);
 581         return [
 582             'syscontext' => $syscontext,
 583             'catcontext' => $catcontext,
 584             'course' => $course,
 585             'coursecontext' => $coursecontext,
 586             'activity1context' => $activity1context,
 587             'activity2context' => $activity2context
 588          ];
 589     }
 590
 591     private function assert_matches($modinfo, $activity1context, $activity2context) {
 592         global $FILTERLIB_PRIVATE, $DB;
 593
 594         // Use preload cache...
 595         $FILTERLIB_PRIVATE = new \stdClass();
 596         filter_preload_activities($modinfo);
 597
 598         // Get data and check no queries are made.
 599         $before = $DB->perf_get_reads();
 600         $plfilters1 = filter_get_active_in_context($activity1context);
 601         $plfilters2 = filter_get_active_in_context($activity2context);
 602         $after = $DB->perf_get_reads();
 603         $this->assertEquals($before, $after);
 604
 605         // Repeat without cache and check it makes queries now.
 606         $FILTERLIB_PRIVATE = new \stdClass;
 607         $before = $DB->perf_get_reads();
 608         $filters1 = filter_get_active_in_context($activity1context);
 609         $filters2 = filter_get_active_in_context($activity2context);
 610         $after = $DB->perf_get_reads();
 611         $this->assertTrue($after > $before);
 612
 613         // Check they match.
 614         $this->assertEquals($plfilters1, $filters1);
 615         $this->assertEquals($plfilters2, $filters2);
 616     }
 617
 618     public function test_preload() {
 619         $this->resetAfterTest();
 620         [
 621             'catcontext' => $catcontext,
 622             'course' => $course,
 623             'coursecontext' => $coursecontext,
 624             'activity1context' => $activity1context,
 625             'activity2context' => $activity2context
 626          ] = $this->setup_preload_activities_test();
 627         // Get course and modinfo.
 628         $modinfo = new \course_modinfo($course, 2);
 629
 630         // Note: All the tests in this function check that the result from the
 631         // preloaded cache is the same as the result from calling the standard
 632         // function without preloading.
 633
 634         // Initially, check with no filters enabled.
 635         $this->assert_matches($modinfo, $activity1context, $activity2context);
 636
 637         // Enable filter globally, check.
 638         filter_set_global_state('name', TEXTFILTER_ON);
 639         $this->assert_matches($modinfo, $activity1context, $activity2context);
 640
 641         // Disable for activity 2.
 642         filter_set_local_state('name', $activity2context->id, TEXTFILTER_OFF);
 643         $this->assert_matches($modinfo, $activity1context, $activity2context);
 644
 645         // Disable at category.
 646         filter_set_local_state('name', $catcontext->id, TEXTFILTER_OFF);
 647         $this->assert_matches($modinfo, $activity1context, $activity2context);
 648
 649         // Enable for activity 1.
 650         filter_set_local_state('name', $activity1context->id, TEXTFILTER_ON);
 651         $this->assert_matches($modinfo, $activity1context, $activity2context);
 652
 653         // Disable globally.
 654         filter_set_global_state('name', TEXTFILTER_DISABLED);
 655         $this->assert_matches($modinfo, $activity1context, $activity2context);
 656
 657         // Add another 2 filters.
 658         filter_set_global_state('frog', TEXTFILTER_ON);
 659         filter_set_global_state('zombie', TEXTFILTER_ON);
 660         $this->assert_matches($modinfo, $activity1context, $activity2context);
 661
 662         // Disable random one of these in each context.
 663         filter_set_local_state('zombie', $activity1context->id, TEXTFILTER_OFF);
 664         filter_set_local_state('frog', $activity2context->id, TEXTFILTER_OFF);
 665         $this->assert_matches($modinfo, $activity1context, $activity2context);
 666
 667         // Now do some filter options.
 668         filter_set_local_config('name', $activity1context->id, 'a', 'x');
 669         filter_set_local_config('zombie', $activity1context->id, 'a', 'y');
 670         filter_set_local_config('frog', $activity1context->id, 'a', 'z');
 671         // These last two don't do anything as they are not at final level but I
 672         // thought it would be good to have that verified in test.
 673         filter_set_local_config('frog', $coursecontext->id, 'q', 'x');
 674         filter_set_local_config('frog', $catcontext->id, 'q', 'z');
 675         $this->assert_matches($modinfo, $activity1context, $activity2context);
 676     }
 677
 678     public function test_filter_delete_all_for_filter() {
 679         global $DB;
 680         $this->resetAfterTest();
 681         $this->remove_all_filters_from_config(); // Remove all filters.
 682
 683         // Setup fixture.
 684         filter_set_global_state('name', TEXTFILTER_ON);
 685         filter_set_global_state('other', TEXTFILTER_ON);
 686         filter_set_local_config('name', \context_system::instance()->id, 'settingname', 'A value');
 687         filter_set_local_config('other', \context_system::instance()->id, 'settingname', 'Other value');
 688         set_config('configname', 'A config value', 'filter_name');
 689         set_config('configname', 'Other config value', 'filter_other');
 690         // Exercise SUT.
 691         filter_delete_all_for_filter('name');
 692         // Validate.
 693         $this->assertEquals(1, $DB->count_records('filter_active'));
 694         $this->assertTrue($DB->record_exists('filter_active', array('filter' => 'other')));
 695         $this->assertEquals(1, $DB->count_records('filter_config'));
 696         $this->assertTrue($DB->record_exists('filter_config', array('filter' => 'other')));
 697         $expectedconfig = new \stdClass;
 698         $expectedconfig->configname = 'Other config value';
 699         $this->assertEquals($expectedconfig, get_config('filter_other'));
 700         $this->assertEquals(get_config('filter_name'), new \stdClass());
 701     }
 702
 703     public function test_filter_delete_all_for_context() {
 704         global $DB;
 705         $this->resetAfterTest();
 706         $this->remove_all_filters_from_config(); // Remove all filters.
 707
 708         // Setup fixture.
 709         filter_set_global_state('name', TEXTFILTER_ON);
 710         filter_set_local_state('name', 123, TEXTFILTER_OFF);
 711         filter_set_local_config('name', 123, 'settingname', 'A value');
 712         filter_set_local_config('other', 123, 'settingname', 'Other value');
 713         filter_set_local_config('other', 122, 'settingname', 'Other value');
 714         // Exercise SUT.
 715         filter_delete_all_for_context(123);
 716         // Validate.
 717         $this->assertEquals(1, $DB->count_records('filter_active'));
 718         $this->assertTrue($DB->record_exists('filter_active', array('contextid' => \context_system::instance()->id)));
 719         $this->assertEquals(1, $DB->count_records('filter_config'));
 720         $this->assertTrue($DB->record_exists('filter_config', array('filter' => 'other')));
 721     }
 722
 723     public function test_set() {
 724         global $CFG;
 725         $this->resetAfterTest();
 726
 727         $this->assertFileExists("$CFG->dirroot/filter/emailprotect"); // Any standard filter.
 728         $this->assertFileExists("$CFG->dirroot/filter/tidy");         // Any standard filter.
 729         $this->assertFileDoesNotExist("$CFG->dirroot/filter/grgrggr");   // Any non-existent filter.
 730
 731         // Setup fixture.
 732         set_config('filterall', 0);
 733         set_config('stringfilters', '');
 734         // Exercise SUT.
 735         filter_set_applies_to_strings('tidy', true);
 736         // Validate.
 737         $this->assertEquals('tidy', $CFG->stringfilters);
 738         $this->assertEquals(1, $CFG->filterall);
 739
 740         filter_set_applies_to_strings('grgrggr', true);
 741         $this->assertEquals('tidy', $CFG->stringfilters);
 742         $this->assertEquals(1, $CFG->filterall);
 743
 744         filter_set_applies_to_strings('emailprotect', true);
 745         $this->assertEquals('tidy,emailprotect', $CFG->stringfilters);
 746         $this->assertEquals(1, $CFG->filterall);
 747     }
 748
 749     public function test_unset_to_empty() {
 750         global $CFG;
 751         $this->resetAfterTest();
 752
 753         $this->assertFileExists("$CFG->dirroot/filter/tidy"); // Any standard filter.
 754
 755         // Setup fixture.
 756         set_config('filterall', 1);
 757         set_config('stringfilters', 'tidy');
 758         // Exercise SUT.
 759         filter_set_applies_to_strings('tidy', false);
 760         // Validate.
 761         $this->assertEquals('', $CFG->stringfilters);
 762         $this->assertEquals('', $CFG->filterall);
 763     }
 764
 765     public function test_unset_multi() {
 766         global $CFG;
 767         $this->resetAfterTest();
 768
 769         $this->assertFileExists("$CFG->dirroot/filter/emailprotect"); // Any standard filter.
 770         $this->assertFileExists("$CFG->dirroot/filter/tidy");         // Any standard filter.
 771         $this->assertFileExists("$CFG->dirroot/filter/multilang");    // Any standard filter.
 772
 773         // Setup fixture.
 774         set_config('filterall', 1);
 775         set_config('stringfilters', 'emailprotect,tidy,multilang');
 776         // Exercise SUT.
 777         filter_set_applies_to_strings('tidy', false);
 778         // Validate.
 779         $this->assertEquals('emailprotect,multilang', $CFG->stringfilters);
 780         $this->assertEquals(1, $CFG->filterall);
 781     }
 782
 783     public function test_filter_manager_instance() {
 784         $this->resetAfterTest();
 785
 786         set_config('perfdebug', 7);
 787         filter_manager::reset_caches();
 788         $filterman = filter_manager::instance();
 789         $this->assertInstanceOf('filter_manager', $filterman);
 790         $this->assertNotInstanceOf('performance_measuring_filter_manager', $filterman);
 791
 792         set_config('perfdebug', 15);
 793         filter_manager::reset_caches();
 794         $filterman = filter_manager::instance();
 795         $this->assertInstanceOf('filter_manager', $filterman);
 796         $this->assertInstanceOf('performance_measuring_filter_manager', $filterman);
 797     }
 798
 799     public function test_filter_get_active_state_contextid_parameter() {
 800         $this->resetAfterTest();
 801
 802         filter_set_global_state('glossary', TEXTFILTER_ON);
 803         // Using system context by default.
 804         $active = filter_get_active_state('glossary');
 805         $this->assertEquals($active, TEXTFILTER_ON);
 806
 807         $systemcontext = \context_system::instance();
 808         // Passing $systemcontext object.
 809         $active = filter_get_active_state('glossary', $systemcontext);
 810         $this->assertEquals($active, TEXTFILTER_ON);
 811
 812         // Passing $systemcontext id.
 813         $active = filter_get_active_state('glossary', $systemcontext->id);
 814         $this->assertEquals($active, TEXTFILTER_ON);
 815
 816         // Not system context.
 817         filter_set_local_state('glossary', '123', TEXTFILTER_ON);
 818         $active = filter_get_active_state('glossary', '123');
 819         $this->assertEquals($active, TEXTFILTER_ON);
 820     }
 821
 822     public function test_filter_get_active_state_filtername_parameter() {
 823         $this->resetAfterTest();
 824
 825         filter_set_global_state('glossary', TEXTFILTER_ON);
 826         // Using full filtername.
 827         $active = filter_get_active_state('filter/glossary');
 828         $this->assertEquals($active, TEXTFILTER_ON);
 829
 830         // Wrong filtername.
 831         $this->expectException('coding_exception');
 832         $active = filter_get_active_state('mod/glossary');
 833     }
 834
 835     public function test_filter_get_active_state_after_change() {
 836         $this->resetAfterTest();
 837
 838         filter_set_global_state('glossary', TEXTFILTER_ON);
 839         $systemcontextid = \context_system::instance()->id;
 840         $active = filter_get_active_state('glossary', $systemcontextid);
 841         $this->assertEquals($active, TEXTFILTER_ON);
 842
 843         filter_set_global_state('glossary', TEXTFILTER_OFF);
 844         $systemcontextid = \context_system::instance()->id;
 845         $active = filter_get_active_state('glossary', $systemcontextid);
 846         $this->assertEquals($active, TEXTFILTER_OFF);
 847
 848         filter_set_global_state('glossary', TEXTFILTER_DISABLED);
 849         $systemcontextid = \context_system::instance()->id;
 850         $active = filter_get_active_state('glossary', $systemcontextid);
 851         $this->assertEquals($active, TEXTFILTER_DISABLED);
 852     }
 853
 854     public function test_filter_get_globally_enabled_default() {
 855         $this->resetAfterTest();
 856         $enabledfilters = filter_get_globally_enabled();
 857         $this->assertArrayNotHasKey('glossary', $enabledfilters);
 858     }
 859
 860     public function test_filter_get_globally_enabled_after_change() {
 861         $this->resetAfterTest();
 862         filter_set_global_state('glossary', TEXTFILTER_ON);
 863         $enabledfilters = filter_get_globally_enabled();
 864         $this->assertArrayHasKey('glossary', $enabledfilters);
 865     }
 866
 867     public function test_filter_get_globally_enabled_filters_with_config() {
 868         $this->resetAfterTest();
 869         $this->remove_all_filters_from_config(); // Remove all filters.
 870         [
 871             'syscontext' => $syscontext,
 872             'childcontext' => $childcontext
 873         ] = $this->setup_available_in_context_tests();
 874         $this->remove_all_filters_from_config(); // Remove all filters.
 875
 876         // Set few filters.
 877         filter_set_global_state('one', TEXTFILTER_ON);
 878         filter_set_global_state('three', TEXTFILTER_OFF, -1);
 879         filter_set_global_state('two', TEXTFILTER_DISABLED);
 880
 881         // Set global config.
 882         filter_set_local_config('one', $syscontext->id, 'test1a', 'In root');
 883         filter_set_local_config('one', $syscontext->id, 'test1b', 'In root');
 884         filter_set_local_config('two', $syscontext->id, 'test2a', 'In root');
 885         filter_set_local_config('two', $syscontext->id, 'test2b', 'In root');
 886
 887         // Set child config.
 888         filter_set_local_config('one', $childcontext->id, 'test1a', 'In child');
 889         filter_set_local_config('one', $childcontext->id, 'test1b', 'In child');
 890         filter_set_local_config('two', $childcontext->id, 'test2a', 'In child');
 891         filter_set_local_config('two', $childcontext->id, 'test2b', 'In child');
 892         filter_set_local_config('three', $childcontext->id, 'test3a', 'In child');
 893         filter_set_local_config('three', $childcontext->id, 'test3b', 'In child');
 894
 895         // Check.
 896         $actual = filter_get_globally_enabled_filters_with_config();
 897         $this->assertCount(2, $actual);
 898         $this->assertEquals(['three', 'one'], array_keys($actual));     // Checks sortorder.
 899         $this->assertArrayHasKey('one', $actual);
 900         $this->assertArrayNotHasKey('two', $actual);
 901         $this->assertArrayHasKey('three', $actual);
 902         $this->assertEquals(['test1a' => 'In root', 'test1b' => 'In root'], $actual['one']);
 903         $this->assertEquals([], $actual['three']);
 904     }
 905 }