cache/tests/config_writer_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_cache;
  18
  19 use cache_config_testing;
  20 use cache_config_writer;
  21 use cache_factory;
  22 use cache_store;
  23
  24 defined('MOODLE_INTERNAL') || die();
  25
  26 // Include the necessary evils.
  27 global $CFG;
  28 require_once($CFG->dirroot.'/cache/locallib.php');
  29 require_once($CFG->dirroot.'/cache/tests/fixtures/lib.php');
  30
  31 /**
  32  * PHPunit tests for the cache API and in particular the cache config writer.
  33  *
  34  * @package    core_cache
  35  * @category   test
  36  * @copyright  2012 Sam Hemelryk
  37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38  */
  39 class config_writer_test extends \advanced_testcase {
  40
  41     /**
  42      * Set things back to the default before each test.
  43      */
  44     public function setUp(): void {
  45         parent::setUp();
  46         cache_factory::reset();
  47         cache_config_testing::create_default_configuration();
  48     }
  49
  50     /**
  51      * Final task is to reset the cache system
  52      */
  53     public static function tearDownAfterClass(): void {
  54         parent::tearDownAfterClass();
  55         cache_factory::reset();
  56     }
  57
  58     /**
  59      * Test getting an instance. Pretty basic.
  60      */
  61     public function test_instance() {
  62         $config = cache_config_writer::instance();
  63         $this->assertInstanceOf('cache_config_writer', $config);
  64     }
  65
  66     /**
  67      * Test the default configuration.
  68      */
  69     public function test_default_configuration() {
  70         $config = cache_config_writer::instance();
  71
  72         // First check stores.
  73         $stores = $config->get_all_stores();
  74         $hasapplication = false;
  75         $hassession = false;
  76         $hasrequest = false;
  77         foreach ($stores as $store) {
  78             // Check the required keys.
  79             $this->assertArrayHasKey('name', $store);
  80             $this->assertArrayHasKey('plugin', $store);
  81             $this->assertArrayHasKey('modes', $store);
  82             $this->assertArrayHasKey('default', $store);
  83             // Check the mode, we need at least one default store of each mode.
  84             if (!empty($store['default'])) {
  85                 if ($store['modes'] & cache_store::MODE_APPLICATION) {
  86                     $hasapplication = true;
  87                 }
  88                 if ($store['modes'] & cache_store::MODE_SESSION) {
  89                     $hassession = true;
  90                 }
  91                 if ($store['modes'] & cache_store::MODE_REQUEST) {
  92                     $hasrequest = true;
  93                 }
  94             }
  95         }
  96         $this->assertTrue($hasapplication, 'There is no default application cache store.');
  97         $this->assertTrue($hassession, 'There is no default session cache store.');
  98         $this->assertTrue($hasrequest, 'There is no default request cache store.');
  99
 100         // Next check the definitions.
 101         $definitions = $config->get_definitions();
 102         $eventinvalidation = false;
 103         foreach ($definitions as $definition) {
 104             // Check the required keys.
 105             $this->assertArrayHasKey('mode', $definition);
 106             $this->assertArrayHasKey('component', $definition);
 107             $this->assertArrayHasKey('area', $definition);
 108             if ($definition['component'] === 'core' && $definition['area'] === 'eventinvalidation') {
 109                 $eventinvalidation = true;
 110             }
 111         }
 112         $this->assertTrue($eventinvalidation, 'Missing the event invalidation definition.');
 113
 114         // Next mode mappings
 115         $mappings = $config->get_mode_mappings();
 116         $hasapplication = false;
 117         $hassession = false;
 118         $hasrequest = false;
 119         foreach ($mappings as $mode) {
 120             // Check the required keys.
 121             $this->assertArrayHasKey('mode', $mode);
 122             $this->assertArrayHasKey('store', $mode);
 123
 124             if ($mode['mode'] === cache_store::MODE_APPLICATION) {
 125                 $hasapplication = true;
 126             }
 127             if ($mode['mode'] === cache_store::MODE_SESSION) {
 128                 $hassession = true;
 129             }
 130             if ($mode['mode'] === cache_store::MODE_REQUEST) {
 131                 $hasrequest = true;
 132             }
 133         }
 134         $this->assertTrue($hasapplication, 'There is no mapping for the application mode.');
 135         $this->assertTrue($hassession, 'There is no mapping for the session mode.');
 136         $this->assertTrue($hasrequest, 'There is no mapping for the request mode.');
 137
 138         // Finally check config locks
 139         $locks = $config->get_locks();
 140         foreach ($locks as $lock) {
 141             $this->assertArrayHasKey('name', $lock);
 142             $this->assertArrayHasKey('type', $lock);
 143             $this->assertArrayHasKey('default', $lock);
 144         }
 145         // There has to be at least the default lock.
 146         $this->assertTrue(count($locks) > 0);
 147     }
 148
 149     /**
 150      * Test updating the definitions.
 151      */
 152     public function test_update_definitions() {
 153         $config = cache_config_writer::instance();
 154         // Remove the definition.
 155         $config->phpunit_remove_definition('core/string');
 156         $definitions = $config->get_definitions();
 157         // Check it is gone.
 158         $this->assertFalse(array_key_exists('core/string', $definitions));
 159         // Update definitions. This should re-add it.
 160         cache_config_writer::update_definitions();
 161         $definitions = $config->get_definitions();
 162         // Check it is back again.
 163         $this->assertTrue(array_key_exists('core/string', $definitions));
 164     }
 165
 166     /**
 167      * Test adding/editing/deleting store instances.
 168      */
 169     public function test_add_edit_delete_plugin_instance() {
 170         $config = cache_config_writer::instance();
 171         $this->assertArrayNotHasKey('addplugintest', $config->get_all_stores());
 172         $this->assertArrayNotHasKey('addplugintestwlock', $config->get_all_stores());
 173         // Add a default file instance.
 174         $config->add_store_instance('addplugintest', 'file');
 175
 176         cache_factory::reset();
 177         $config = cache_config_writer::instance();
 178         $this->assertArrayHasKey('addplugintest', $config->get_all_stores());
 179
 180         // Add a store with a lock described.
 181         $config->add_store_instance('addplugintestwlock', 'file', array('lock' => 'default_file_lock'));
 182         $this->assertArrayHasKey('addplugintestwlock', $config->get_all_stores());
 183
 184         $config->delete_store_instance('addplugintest');
 185         $this->assertArrayNotHasKey('addplugintest', $config->get_all_stores());
 186         $this->assertArrayHasKey('addplugintestwlock', $config->get_all_stores());
 187
 188         $config->delete_store_instance('addplugintestwlock');
 189         $this->assertArrayNotHasKey('addplugintest', $config->get_all_stores());
 190         $this->assertArrayNotHasKey('addplugintestwlock', $config->get_all_stores());
 191
 192         // Add a default file instance.
 193         $config->add_store_instance('storeconfigtest', 'file', array('test' => 'a', 'one' => 'two'));
 194         $stores = $config->get_all_stores();
 195         $this->assertArrayHasKey('storeconfigtest', $stores);
 196         $this->assertArrayHasKey('configuration', $stores['storeconfigtest']);
 197         $this->assertArrayHasKey('test', $stores['storeconfigtest']['configuration']);
 198         $this->assertArrayHasKey('one', $stores['storeconfigtest']['configuration']);
 199         $this->assertEquals('a', $stores['storeconfigtest']['configuration']['test']);
 200         $this->assertEquals('two', $stores['storeconfigtest']['configuration']['one']);
 201
 202         $config->edit_store_instance('storeconfigtest', 'file', array('test' => 'b', 'one' => 'three'));
 203         $stores = $config->get_all_stores();
 204         $this->assertArrayHasKey('storeconfigtest', $stores);
 205         $this->assertArrayHasKey('configuration', $stores['storeconfigtest']);
 206         $this->assertArrayHasKey('test', $stores['storeconfigtest']['configuration']);
 207         $this->assertArrayHasKey('one', $stores['storeconfigtest']['configuration']);
 208         $this->assertEquals('b', $stores['storeconfigtest']['configuration']['test']);
 209         $this->assertEquals('three', $stores['storeconfigtest']['configuration']['one']);
 210
 211         $config->delete_store_instance('storeconfigtest');
 212
 213         try {
 214             $config->delete_store_instance('default_application');
 215             $this->fail('Default store deleted. This should not be possible!');
 216         } catch (\Exception $e) {
 217             $this->assertInstanceOf('cache_exception', $e);
 218         }
 219
 220         try {
 221             $config->delete_store_instance('some_crazy_store');
 222             $this->fail('You should not be able to delete a store that does not exist.');
 223         } catch (\Exception $e) {
 224             $this->assertInstanceOf('cache_exception', $e);
 225         }
 226
 227         try {
 228             // Try with a plugin that does not exist.
 229             $config->add_store_instance('storeconfigtest', 'shallowfail', array('test' => 'a', 'one' => 'two'));
 230             $this->fail('You should not be able to add an instance of a store that does not exist.');
 231         } catch (\Exception $e) {
 232             $this->assertInstanceOf('cache_exception', $e);
 233         }
 234     }
 235
 236     /**
 237      * Test setting some mode mappings.
 238      */
 239     public function test_set_mode_mappings() {
 240         $config = cache_config_writer::instance();
 241         $this->assertTrue($config->add_store_instance('setmodetest', 'file'));
 242         $this->assertTrue($config->set_mode_mappings(array(
 243             cache_store::MODE_APPLICATION => array('setmodetest', 'default_application'),
 244             cache_store::MODE_SESSION => array('default_session'),
 245             cache_store::MODE_REQUEST => array('default_request'),
 246         )));
 247         $mappings = $config->get_mode_mappings();
 248         $setmodetestfound = false;
 249         foreach ($mappings as $mapping) {
 250             if ($mapping['store'] == 'setmodetest' && $mapping['mode'] == cache_store::MODE_APPLICATION) {
 251                 $setmodetestfound = true;
 252             }
 253         }
 254         $this->assertTrue($setmodetestfound, 'Set mapping did not work as expected.');
 255     }
 256
 257     /**
 258      * Test setting some definition mappings.
 259      */
 260     public function test_set_definition_mappings() {
 261         $config = cache_config_testing::instance(true);
 262         $config->phpunit_add_definition('phpunit/testdefinition', array(
 263             'mode' => cache_store::MODE_APPLICATION,
 264             'component' => 'phpunit',
 265             'area' => 'testdefinition'
 266         ));
 267
 268         $config = cache_config_writer::instance();
 269         $this->assertTrue($config->add_store_instance('setdefinitiontest', 'file'));
 270         $this->assertIsArray($config->get_definition_by_id('phpunit/testdefinition'));
 271         $config->set_definition_mappings('phpunit/testdefinition', array('setdefinitiontest', 'default_application'));
 272
 273         try {
 274             $config->set_definition_mappings('phpunit/testdefinition', array('something that does not exist'));
 275             $this->fail('You should not be able to set a mapping for a store that does not exist.');
 276         } catch (\Exception $e) {
 277             $this->assertInstanceOf('coding_exception', $e);
 278         }
 279
 280         try {
 281             $config->set_definition_mappings('something/crazy', array('setdefinitiontest'));
 282             $this->fail('You should not be able to set a mapping for a definition that does not exist.');
 283         } catch (\Exception $e) {
 284             $this->assertInstanceOf('coding_exception', $e);
 285         }
 286     }
 287 }