analytics/tests/manager_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_analytics;
  18
  19 defined('MOODLE_INTERNAL') || die();
  20
  21 require_once(__DIR__ . '/fixtures/test_indicator_max.php');
  22 require_once(__DIR__ . '/fixtures/test_indicator_min.php');
  23 require_once(__DIR__ . '/fixtures/test_indicator_fullname.php');
  24 require_once(__DIR__ . '/fixtures/test_target_course_level_shortname.php');
  25
  26 /**
  27  * Unit tests for the core_analytics manager.
  28  *
  29  * @package   core_analytics
  30  * @copyright 2017 David Monllaó {@link http://www.davidmonllao.com}
  31  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  32  */
  33 class manager_test extends \advanced_testcase {
  34
  35     /**
  36      * test_deleted_context
  37      */
  38     public function test_deleted_context() {
  39         global $DB;
  40
  41         $this->resetAfterTest(true);
  42         $this->setAdminuser();
  43         set_config('enabled_stores', 'logstore_standard', 'tool_log');
  44
  45         $target = \core_analytics\manager::get_target('test_target_course_level_shortname');
  46         $indicators = array('test_indicator_max', 'test_indicator_min', 'test_indicator_fullname');
  47         foreach ($indicators as $key => $indicator) {
  48             $indicators[$key] = \core_analytics\manager::get_indicator($indicator);
  49         }
  50
  51         $model = \core_analytics\model::create($target, $indicators);
  52         $modelobj = $model->get_model_obj();
  53
  54         $coursepredict1 = $this->getDataGenerator()->create_course(array('visible' => 0));
  55         $coursepredict2 = $this->getDataGenerator()->create_course(array('visible' => 0));
  56         $coursetrain1 = $this->getDataGenerator()->create_course(array('visible' => 1));
  57         $coursetrain2 = $this->getDataGenerator()->create_course(array('visible' => 1));
  58
  59         $model->enable('\core\analytics\time_splitting\no_splitting');
  60
  61         $model->train();
  62         $model->predict();
  63
  64         // Generate a prediction action to confirm that it is deleted when there is an important update.
  65         $predictions = $DB->get_records('analytics_predictions');
  66         $prediction = reset($predictions);
  67         $prediction = new \core_analytics\prediction($prediction, array('whatever' => 'not used'));
  68         $prediction->action_executed(\core_analytics\prediction::ACTION_USEFUL, $model->get_target());
  69
  70         $predictioncontextid = $prediction->get_prediction_data()->contextid;
  71
  72         $npredictions = $DB->count_records('analytics_predictions', array('contextid' => $predictioncontextid));
  73         $npredictionactions = $DB->count_records('analytics_prediction_actions',
  74             array('predictionid' => $prediction->get_prediction_data()->id));
  75         $nindicatorcalc = $DB->count_records('analytics_indicator_calc', array('contextid' => $predictioncontextid));
  76
  77         \core_analytics\manager::cleanup();
  78
  79         // Nothing is incorrectly deleted.
  80         $this->assertEquals($npredictions, $DB->count_records('analytics_predictions',
  81             array('contextid' => $predictioncontextid)));
  82         $this->assertEquals($npredictionactions, $DB->count_records('analytics_prediction_actions',
  83             array('predictionid' => $prediction->get_prediction_data()->id)));
  84         $this->assertEquals($nindicatorcalc, $DB->count_records('analytics_indicator_calc',
  85             array('contextid' => $predictioncontextid)));
  86
  87         // Now we delete a context, the course predictions and prediction actions should be deleted.
  88         $deletedcontext = \context::instance_by_id($predictioncontextid);
  89         delete_course($deletedcontext->instanceid, false);
  90
  91         \core_analytics\manager::cleanup();
  92
  93         $this->assertEmpty($DB->count_records('analytics_predictions', array('contextid' => $predictioncontextid)));
  94         $this->assertEmpty($DB->count_records('analytics_prediction_actions',
  95             array('predictionid' => $prediction->get_prediction_data()->id)));
  96         $this->assertEmpty($DB->count_records('analytics_indicator_calc', array('contextid' => $predictioncontextid)));
  97
  98         set_config('enabled_stores', '', 'tool_log');
  99         get_log_manager(true);
 100     }
 101
 102     /**
 103      * test_deleted_analysable
 104      */
 105     public function test_deleted_analysable() {
 106         global $DB;
 107
 108         $this->resetAfterTest(true);
 109         $this->setAdminuser();
 110         set_config('enabled_stores', 'logstore_standard', 'tool_log');
 111
 112         $target = \core_analytics\manager::get_target('test_target_course_level_shortname');
 113         $indicators = array('test_indicator_max', 'test_indicator_min', 'test_indicator_fullname');
 114         foreach ($indicators as $key => $indicator) {
 115             $indicators[$key] = \core_analytics\manager::get_indicator($indicator);
 116         }
 117
 118         $model = \core_analytics\model::create($target, $indicators);
 119         $modelobj = $model->get_model_obj();
 120
 121         $coursepredict1 = $this->getDataGenerator()->create_course(array('visible' => 0));
 122         $coursepredict2 = $this->getDataGenerator()->create_course(array('visible' => 0));
 123         $coursetrain1 = $this->getDataGenerator()->create_course(array('visible' => 1));
 124         $coursetrain2 = $this->getDataGenerator()->create_course(array('visible' => 1));
 125
 126         $model->enable('\core\analytics\time_splitting\no_splitting');
 127
 128         $model->train();
 129         $model->predict();
 130
 131         $this->assertNotEmpty($DB->count_records('analytics_predict_samples'));
 132         $this->assertNotEmpty($DB->count_records('analytics_train_samples'));
 133         $this->assertNotEmpty($DB->count_records('analytics_used_analysables'));
 134
 135         // Now we delete an analysable, stored predict and training samples should be deleted.
 136         $deletedcontext = \context_course::instance($coursepredict1->id);
 137         delete_course($coursepredict1, false);
 138
 139         \core_analytics\manager::cleanup();
 140
 141         $this->assertEmpty($DB->count_records('analytics_predict_samples', array('analysableid' => $coursepredict1->id)));
 142         $this->assertEmpty($DB->count_records('analytics_train_samples', array('analysableid' => $coursepredict1->id)));
 143         $this->assertEmpty($DB->count_records('analytics_used_analysables', array('analysableid' => $coursepredict1->id)));
 144
 145         set_config('enabled_stores', '', 'tool_log');
 146         get_log_manager(true);
 147     }
 148
 149     /**
 150      * Tests for the {@link \core_analytics\manager::load_default_models_for_component()} implementation.
 151      */
 152     public function test_load_default_models_for_component() {
 153         $this->resetAfterTest();
 154
 155         // Attempting to load builtin models should always work without throwing exception.
 156         \core_analytics\manager::load_default_models_for_component('core');
 157
 158         // Attempting to load from a core subsystem without its own subsystem directory.
 159         $this->assertSame([], \core_analytics\manager::load_default_models_for_component('core_access'));
 160
 161         // Attempting to load from a non-existing subsystem.
 162         $this->assertSame([], \core_analytics\manager::load_default_models_for_component('core_nonexistingsubsystem'));
 163
 164         // Attempting to load from a non-existing plugin of a known plugin type.
 165         $this->assertSame([], \core_analytics\manager::load_default_models_for_component('mod_foobarbazquaz12240996776'));
 166
 167         // Attempting to load from a non-existing plugin type.
 168         $this->assertSame([], \core_analytics\manager::load_default_models_for_component('foo_bar2776327736558'));
 169     }
 170
 171     /**
 172      * Tests for the {@link \core_analytics\manager::load_default_models_for_all_components()} implementation.
 173      */
 174     public function test_load_default_models_for_all_components() {
 175         $this->resetAfterTest();
 176
 177         $models = \core_analytics\manager::load_default_models_for_all_components();
 178
 179         $this->assertTrue(is_array($models['core']));
 180         $this->assertNotEmpty($models['core']);
 181         $this->assertNotEmpty($models['core'][0]['target']);
 182         $this->assertNotEmpty($models['core'][0]['indicators']);
 183     }
 184
 185     /**
 186      * Tests for the successful execution of the {@link \core_analytics\manager::validate_models_declaration()}.
 187      */
 188     public function test_validate_models_declaration() {
 189         $this->resetAfterTest();
 190
 191         // This is expected to run without an exception.
 192         $models = $this->load_models_from_fixture_file('no_teaching');
 193         \core_analytics\manager::validate_models_declaration($models);
 194     }
 195
 196     /**
 197      * Tests for the exceptions thrown by {@link \core_analytics\manager::validate_models_declaration()}.
 198      *
 199      * @dataProvider validate_models_declaration_exceptions_provider
 200      * @param array $models Models declaration.
 201      * @param string $exception Expected coding exception message.
 202      */
 203     public function test_validate_models_declaration_exceptions(array $models, string $exception) {
 204         $this->resetAfterTest();
 205
 206         $this->expectException(\coding_exception::class);
 207         $this->expectExceptionMessage($exception);
 208         \core_analytics\manager::validate_models_declaration($models);
 209     }
 210
 211     /**
 212      * Data provider for the {@link self::test_validate_models_declaration_exceptions()}.
 213      *
 214      * @return array of (string)testcase => [(array)models, (string)expected exception message]
 215      */
 216     public function validate_models_declaration_exceptions_provider() {
 217         return [
 218             'missing_target' => [
 219                 $this->load_models_from_fixture_file('missing_target'),
 220                 'Missing target declaration',
 221             ],
 222             'invalid_target' => [
 223                 $this->load_models_from_fixture_file('invalid_target'),
 224                 'Invalid target classname',
 225             ],
 226             'missing_indicators' => [
 227                 $this->load_models_from_fixture_file('missing_indicators'),
 228                 'Missing indicators declaration',
 229             ],
 230             'invalid_indicators' => [
 231                 $this->load_models_from_fixture_file('invalid_indicators'),
 232                 'Invalid indicator classname',
 233             ],
 234             'invalid_time_splitting' => [
 235                 $this->load_models_from_fixture_file('invalid_time_splitting'),
 236                 'Invalid time splitting classname',
 237             ],
 238             'invalid_time_splitting_fq' => [
 239                 $this->load_models_from_fixture_file('invalid_time_splitting_fq'),
 240                 'Expecting fully qualified time splitting classname',
 241             ],
 242             'invalid_enabled' => [
 243                 $this->load_models_from_fixture_file('invalid_enabled'),
 244                 'Cannot enable a model without time splitting method specified',
 245             ],
 246         ];
 247     }
 248
 249     /**
 250      * Loads models as declared in the given fixture file.
 251      *
 252      * @param string $filename
 253      * @return array
 254      */
 255     protected function load_models_from_fixture_file(string $filename) {
 256         global $CFG;
 257
 258         $models = null;
 259
 260         require($CFG->dirroot.'/analytics/tests/fixtures/db_analytics_php/'.$filename.'.php');
 261
 262         return $models;
 263     }
 264
 265     /**
 266      * Test the implementation of the {@link \core_analytics\manager::create_declared_model()}.
 267      */
 268     public function test_create_declared_model() {
 269         global $DB;
 270
 271         $this->resetAfterTest();
 272         $this->setAdminuser();
 273
 274         $declaration = [
 275             'target' => 'test_target_course_level_shortname',
 276             'indicators' => [
 277                 'test_indicator_max',
 278                 'test_indicator_min',
 279                 'test_indicator_fullname',
 280             ],
 281         ];
 282
 283         $declarationwithtimesplitting = array_merge($declaration, [
 284             'timesplitting' => '\core\analytics\time_splitting\no_splitting',
 285         ]);
 286
 287         $declarationwithtimesplittingenabled = array_merge($declarationwithtimesplitting, [
 288             'enabled' => true,
 289         ]);
 290
 291         // Check that no such model exists yet.
 292         $target = \core_analytics\manager::get_target('test_target_course_level_shortname');
 293         $this->assertEquals(0, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 294         $this->assertFalse(\core_analytics\model::exists($target));
 295
 296         // Check that the model is created.
 297         $created = \core_analytics\manager::create_declared_model($declaration);
 298         $this->assertTrue($created instanceof \core_analytics\model);
 299         $this->assertTrue(\core_analytics\model::exists($target));
 300         $this->assertEquals(1, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 301         $modelid = $created->get_id();
 302
 303         // Check that created models are disabled by default.
 304         $existing = new \core_analytics\model($modelid);
 305         $this->assertEquals(0, $existing->get_model_obj()->enabled);
 306         $this->assertEquals(0, $DB->get_field('analytics_models', 'enabled', ['target' => $target->get_id()], MUST_EXIST));
 307
 308         // Let the admin enable the model.
 309         $existing->enable('\core\analytics\time_splitting\no_splitting');
 310         $this->assertEquals(1, $DB->get_field('analytics_models', 'enabled', ['target' => $target->get_id()], MUST_EXIST));
 311
 312         // Check that further calls create a new model.
 313         $repeated = \core_analytics\manager::create_declared_model($declaration);
 314         $this->assertTrue($repeated instanceof \core_analytics\model);
 315         $this->assertEquals(2, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 316
 317         // Delete the models.
 318         $existing->delete();
 319         $repeated->delete();
 320         $this->assertEquals(0, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 321         $this->assertFalse(\core_analytics\model::exists($target));
 322
 323         // Create it again, this time with time splitting method specified.
 324         $created = \core_analytics\manager::create_declared_model($declarationwithtimesplitting);
 325         $this->assertTrue($created instanceof \core_analytics\model);
 326         $this->assertTrue(\core_analytics\model::exists($target));
 327         $this->assertEquals(1, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 328         $modelid = $created->get_id();
 329
 330         // Even if the time splitting method was specified, the model is still not enabled automatically.
 331         $existing = new \core_analytics\model($modelid);
 332         $this->assertEquals(0, $existing->get_model_obj()->enabled);
 333         $this->assertEquals(0, $DB->get_field('analytics_models', 'enabled', ['target' => $target->get_id()], MUST_EXIST));
 334         $existing->delete();
 335
 336         // Let's define the model so that it is enabled by default.
 337         $enabled = \core_analytics\manager::create_declared_model($declarationwithtimesplittingenabled);
 338         $this->assertTrue($enabled instanceof \core_analytics\model);
 339         $this->assertTrue(\core_analytics\model::exists($target));
 340         $this->assertEquals(1, $DB->count_records('analytics_models', ['target' => $target->get_id()]));
 341         $modelid = $enabled->get_id();
 342         $existing = new \core_analytics\model($modelid);
 343         $this->assertEquals(1, $existing->get_model_obj()->enabled);
 344         $this->assertEquals(1, $DB->get_field('analytics_models', 'enabled', ['target' => $target->get_id()], MUST_EXIST));
 345
 346         // Let the admin disable the model.
 347         $existing->update(0, false, false);
 348         $this->assertEquals(0, $DB->get_field('analytics_models', 'enabled', ['target' => $target->get_id()], MUST_EXIST));
 349     }
 350
 351     /**
 352      * Test the implementation of the {@link \core_analytics\manager::update_default_models_for_component()}.
 353      */
 354     public function test_update_default_models_for_component() {
 355
 356         $this->resetAfterTest();
 357         $this->setAdminuser();
 358
 359         $noteaching = \core_analytics\manager::get_target('\core_course\analytics\target\no_teaching');
 360         $dropout = \core_analytics\manager::get_target('\core_course\analytics\target\course_dropout');
 361         $upcomingactivities = \core_analytics\manager::get_target('\core_user\analytics\target\upcoming_activities_due');
 362         $norecentaccesses = \core_analytics\manager::get_target('\core_course\analytics\target\no_recent_accesses');
 363         $noaccesssincestart = \core_analytics\manager::get_target('\core_course\analytics\target\no_access_since_course_start');
 364
 365         $this->assertTrue(\core_analytics\model::exists($noteaching));
 366         $this->assertTrue(\core_analytics\model::exists($dropout));
 367         $this->assertTrue(\core_analytics\model::exists($upcomingactivities));
 368         $this->assertTrue(\core_analytics\model::exists($norecentaccesses));
 369         $this->assertTrue(\core_analytics\model::exists($noaccesssincestart));
 370
 371         foreach (\core_analytics\manager::get_all_models() as $model) {
 372             $model->delete();
 373         }
 374
 375         $this->assertFalse(\core_analytics\model::exists($noteaching));
 376         $this->assertFalse(\core_analytics\model::exists($dropout));
 377         $this->assertFalse(\core_analytics\model::exists($upcomingactivities));
 378         $this->assertFalse(\core_analytics\model::exists($norecentaccesses));
 379         $this->assertFalse(\core_analytics\model::exists($noaccesssincestart));
 380
 381         $updated = \core_analytics\manager::update_default_models_for_component('moodle');
 382
 383         $this->assertEquals(5, count($updated));
 384         $this->assertTrue(array_pop($updated) instanceof \core_analytics\model);
 385         $this->assertTrue(array_pop($updated) instanceof \core_analytics\model);
 386         $this->assertTrue(array_pop($updated) instanceof \core_analytics\model);
 387         $this->assertTrue(array_pop($updated) instanceof \core_analytics\model);
 388         $this->assertTrue(array_pop($updated) instanceof \core_analytics\model);
 389         $this->assertTrue(\core_analytics\model::exists($noteaching));
 390         $this->assertTrue(\core_analytics\model::exists($dropout));
 391         $this->assertTrue(\core_analytics\model::exists($upcomingactivities));
 392         $this->assertTrue(\core_analytics\model::exists($norecentaccesses));
 393         $this->assertTrue(\core_analytics\model::exists($noaccesssincestart));
 394
 395         $repeated = \core_analytics\manager::update_default_models_for_component('moodle');
 396
 397         $this->assertSame([], $repeated);
 398     }
 399
 400     /**
 401      * test_get_time_splitting_methods description
 402      * @return null
 403      */
 404     public function test_get_time_splitting_methods() {
 405         $this->resetAfterTest(true);
 406
 407         $all = \core_analytics\manager::get_all_time_splittings();
 408         $this->assertArrayHasKey('\core\analytics\time_splitting\upcoming_week', $all);
 409         $this->assertArrayHasKey('\core\analytics\time_splitting\quarters', $all);
 410
 411         $allforevaluation = \core_analytics\manager::get_time_splitting_methods_for_evaluation(true);
 412         $this->assertArrayNotHasKey('\core\analytics\time_splitting\upcoming_week', $allforevaluation);
 413         $this->assertArrayHasKey('\core\analytics\time_splitting\quarters', $allforevaluation);
 414
 415         $defaultforevaluation = \core_analytics\manager::get_time_splitting_methods_for_evaluation(false);
 416         $this->assertArrayNotHasKey('\core\analytics\time_splitting\upcoming_week', $defaultforevaluation);
 417         $this->assertArrayHasKey('\core\analytics\time_splitting\quarters', $defaultforevaluation);
 418
 419         $sometimesplittings = '\core\analytics\time_splitting\single_range,' .
 420             '\core\analytics\time_splitting\tenths';
 421         set_config('defaulttimesplittingsevaluation', $sometimesplittings, 'analytics');
 422
 423         $defaultforevaluation = \core_analytics\manager::get_time_splitting_methods_for_evaluation(false);
 424         $this->assertArrayNotHasKey('\core\analytics\time_splitting\quarters', $defaultforevaluation);
 425     }
 426
 427     /**
 428      * Test the implementation of the {@link \core_analytics\manager::model_declaration_identifier()}.
 429      */
 430     public function test_model_declaration_identifier() {
 431
 432         $noteaching1 = $this->load_models_from_fixture_file('no_teaching');
 433         $noteaching2 = $this->load_models_from_fixture_file('no_teaching');
 434         $noteaching3 = $this->load_models_from_fixture_file('no_teaching');
 435
 436         // Same model declaration should always lead to same identifier.
 437         $this->assertEquals(
 438             \core_analytics\manager::model_declaration_identifier(reset($noteaching1)),
 439             \core_analytics\manager::model_declaration_identifier(reset($noteaching2))
 440         );
 441
 442         // If something is changed, the identifier should change, too.
 443         $noteaching2[0]['target'] .= '_';
 444         $this->assertNotEquals(
 445             \core_analytics\manager::model_declaration_identifier(reset($noteaching1)),
 446             \core_analytics\manager::model_declaration_identifier(reset($noteaching2))
 447         );
 448
 449         $noteaching3[0]['indicators'][] = '\core_analytics\local\indicator\binary';
 450         $this->assertNotEquals(
 451             \core_analytics\manager::model_declaration_identifier(reset($noteaching1)),
 452             \core_analytics\manager::model_declaration_identifier(reset($noteaching3))
 453         );
 454
 455         // The identifier is supposed to contain PARAM_ALPHANUM only.
 456         $this->assertEquals(
 457             \core_analytics\manager::model_declaration_identifier(reset($noteaching1)),
 458             clean_param(\core_analytics\manager::model_declaration_identifier(reset($noteaching1)), PARAM_ALPHANUM)
 459         );
 460         $this->assertEquals(
 461             \core_analytics\manager::model_declaration_identifier(reset($noteaching2)),
 462             clean_param(\core_analytics\manager::model_declaration_identifier(reset($noteaching2)), PARAM_ALPHANUM)
 463         );
 464         $this->assertEquals(
 465             \core_analytics\manager::model_declaration_identifier(reset($noteaching3)),
 466             clean_param(\core_analytics\manager::model_declaration_identifier(reset($noteaching3)), PARAM_ALPHANUM)
 467         );
 468     }
 469
 470     /**
 471      * Tests for the {@link \core_analytics\manager::get_declared_target_and_indicators_instances()}.
 472      */
 473     public function test_get_declared_target_and_indicators_instances() {
 474         $this->resetAfterTest();
 475
 476         $definition = $this->load_models_from_fixture_file('no_teaching');
 477
 478         list($target, $indicators) = \core_analytics\manager::get_declared_target_and_indicators_instances($definition[0]);
 479
 480         $this->assertTrue($target instanceof \core_analytics\local\target\base);
 481         $this->assertNotEmpty($indicators);
 482         $this->assertContainsOnlyInstancesOf(\core_analytics\local\indicator\base::class, $indicators);
 483     }
 484
 485     /**
 486      * test_get_potential_context_restrictions description
 487      */
 488     public function test_get_potential_context_restrictions() {
 489         $this->resetAfterTest();
 490
 491         // No potential context restrictions.
 492         $this->assertFalse(\core_analytics\manager::get_potential_context_restrictions([]));
 493
 494         // Include the all context levels so the misc. category get included.
 495         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions());
 496
 497         $this->getDataGenerator()->create_course();
 498         $this->getDataGenerator()->create_category();
 499         $this->assertCount(3, \core_analytics\manager::get_potential_context_restrictions());
 500         $this->assertCount(3, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSE, CONTEXT_COURSECAT]));
 501
 502         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSE]));
 503         $this->assertCount(2, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSECAT]));
 504
 505         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSECAT], 'Course category'));
 506         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSECAT], 'Course category 1'));
 507         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSECAT], 'Miscellaneous'));
 508         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSE], 'Test course 1'));
 509         $this->assertCount(1, \core_analytics\manager::get_potential_context_restrictions([CONTEXT_COURSE], 'Test course'));
 510     }
 511 }