845ca41deaaa16bd8bfffdfee02913b2e326856b
[moodle.git] / cache / tests / fixtures / lib.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/>.
17 /**
18  * Support library for the cache PHPUnit tests.
19  *
20  * This file is part of Moodle's cache API, affectionately called MUC.
21  * It contains the components that are requried in order to use caching.
22  *
23  * @package    core
24  * @category   cache
25  * @copyright  2012 Sam Hemelryk
26  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
27  */
29 defined('MOODLE_INTERNAL') || die();
31 /**
32  * Override the default cache configuration for our own maniacle purposes.
33  *
34  * @copyright  2012 Sam Hemelryk
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
37 class cache_config_phpunittest extends cache_config_writer {
39     /**
40      * Returns the expected path to the configuration file.
41      *
42      * We override this function to add handling for $CFG->altcacheconfigpath.
43      * We want to support it so that people can run unit tests against alternative cache setups.
44      * However we don't want to ever make changes to the file at $CFG->altcacheconfigpath so we
45      * always use dataroot and copy the alt file there as required.
46      *
47      * @throws cache_exception
48      * @return string The absolute path
49      */
50     protected static function get_config_file_path() {
51         global $CFG;
52         // We always use this path.
53         $configpath = $CFG->dataroot.'/muc/config.php';
55         if (!empty($CFG->altcacheconfigpath)) {
56             $path = $CFG->altcacheconfigpath;
57             if (is_dir($path) && is_writable($path)) {
58                 // Its a writable directory, thats fine. Convert it to a file.
59                 $path = $CFG->altcacheconfigpath.'/cacheconfig.php';
60             }
61             if (is_readable($path)) {
62                 $directory = dirname($configpath);
63                 if ($directory !== $CFG->dataroot && !file_exists($directory)) {
64                     $result = make_writable_directory($directory, false);
65                     if (!$result) {
66                         throw new cache_exception('ex_configcannotsave', 'cache', '', null, 'Cannot create config directory. Check the permissions on your moodledata directory.');
67                     }
68                 }
69                 // We don't care that this fails but we should let the developer know.
70                 if (!is_readable($configpath) && !@copy($path, $configpath)) {
71                     debugging('Failed to copy alt cache config file to required location');
72                 }
73             }
74         }
76         // We always use the dataroot location.
77         return $configpath;
78     }
80     /**
81      * Adds a definition to the stack
82      * @param string $area
83      * @param array $properties
84      */
85     public function phpunit_add_definition($area, array $properties) {
86         if (!array_key_exists('overrideclass', $properties)) {
87             switch ($properties['mode']) {
88                 case cache_store::MODE_APPLICATION:
89                     $properties['overrideclass'] = 'cache_phpunit_application';
90                     break;
91                 case cache_store::MODE_SESSION:
92                     $properties['overrideclass'] = 'cache_phpunit_session';
93                     break;
94                 case cache_store::MODE_REQUEST:
95                     $properties['overrideclass'] = 'cache_phpunit_request';
96                     break;
97             }
98         }
99         $this->configdefinitions[$area] = $properties;
100         switch ($properties['mode']) {
101             case cache_store::MODE_APPLICATION:
102                 $this->phpunit_add_definition_mapping($area, 'default_application', 0);
103                 break;
104             case cache_store::MODE_SESSION:
105                 $this->phpunit_add_definition_mapping($area, 'default_session', 0);
106                 break;
107             case cache_store::MODE_REQUEST:
108                 $this->phpunit_add_definition_mapping($area, 'default_request', 0);
109                 break;
110         }
111     }
113     /**
114      * Removes a definition.
115      * @param string $name
116      */
117     public function phpunit_remove_definition($name) {
118         unset($this->configdefinitions[$name]);
119     }
121     /**
122      * Removes the configured stores so that there are none available.
123      */
124     public function phpunit_remove_stores() {
125         $this->configstores = array();
126     }
128     /**
129      * Forcefully adds a file store.
130      *
131      * @param string $name
132      */
133     public function phpunit_add_file_store($name) {
134         $this->configstores[$name] = array(
135             'name' => $name,
136             'plugin' => 'file',
137             'configuration' => array(
138                 'path' => ''
139             ),
140             'features' => 6,
141             'modes' => 3,
142             'mappingsonly' => false,
143             'class' => 'cachestore_file',
144             'default' => false,
145             'lock' => 'cachelock_file_default'
146         );
147     }
149     /**
150      * Forcefully adds a session store.
151      *
152      * @param string $name
153      */
154     public function phpunit_add_session_store($name) {
155         $this->configstores[$name] = array(
156             'name' => $name,
157             'plugin' => 'session',
158             'configuration' => array(),
159             'features' => 14,
160             'modes' => 2,
161             'default' => true,
162             'class' => 'cachestore_session',
163             'lock' => 'cachelock_file_default',
164         );
165     }
167     /**
168      * Forcefully injects a definition => store mapping.
169      *
170      * This function does no validation, you should only be calling if it you know
171      * exactly what to expect.
172      *
173      * @param string $definition
174      * @param string $store
175      * @param int $sort
176      */
177     public function phpunit_add_definition_mapping($definition, $store, $sort) {
178         $this->configdefinitionmappings[] = array(
179             'store' => $store,
180             'definition' => $definition,
181             'sort' => (int)$sort
182         );
183     }
185     /**
186      * Overrides the default site identifier used by the Cache API so that we can be sure of what it is.
187      *
188      * @return string
189      */
190     public function get_site_identifier() {
191         global $CFG;
192         return $CFG->wwwroot.'phpunit';
193     }
196 /**
197  * Dummy object for testing cacheable object interface and interaction
198  *
199  * @copyright  2012 Sam Hemelryk
200  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
201  */
202 class cache_phpunit_dummy_object extends stdClass implements cacheable_object {
203     /**
204      * Test property 1
205      * @var string
206      */
207     public $property1;
208     /**
209      * Test property 1
210      * @var string
211      */
212     public $property2;
213     /**
214      * Constructor
215      * @param string $property1
216      * @param string $property2
217      */
218     public function __construct($property1, $property2) {
219         $this->property1 = $property1;
220         $this->property2 = $property2;
221     }
222     /**
223      * Prepares this object for caching
224      * @return array
225      */
226     public function prepare_to_cache() {
227         return array($this->property1.'_ptc', $this->property2.'_ptc');
228     }
229     /**
230      * Returns this object from the cache
231      * @param array $data
232      * @return cache_phpunit_dummy_object
233      */
234     public static function wake_from_cache($data) {
235         return new cache_phpunit_dummy_object(array_shift($data).'_wfc', array_shift($data).'_wfc');
236     }
239 /**
240  * Dummy data source object for testing data source interface and implementation
241  *
242  * @copyright  2012 Sam Hemelryk
243  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
244  */
245 class cache_phpunit_dummy_datasource implements cache_data_source {
246     /**
247      * Returns an instance of this object for use with the cache.
248      *
249      * @param cache_definition $definition
250      * @return cache_phpunit_dummy_datasource
251      */
252     public static function get_instance_for_cache(cache_definition $definition) {
253         return new cache_phpunit_dummy_datasource();
254     }
256     /**
257      * Loads a key for the cache.
258      *
259      * @param string $key
260      * @return string
261      */
262     public function load_for_cache($key) {
263         return $key.' has no value really.';
264     }
266     /**
267      * Loads many keys for the cache
268      *
269      * @param array $keys
270      * @return array
271      */
272     public function load_many_for_cache(array $keys) {
273         $return = array();
274         foreach ($keys as $key) {
275             $return[$key] = $key.' has no value really.';
276         }
277         return $return;
278     }
281 /**
282  * PHPUnit application cache loader.
283  *
284  * Used to expose things we could not otherwise see within an application cache.
285  *
286  * @copyright  2012 Sam Hemelryk
287  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
288  */
289 class cache_phpunit_application extends cache_application {
291     /**
292      * Returns the class of the store immediately associated with this cache.
293      * @return string
294      */
295     public function phpunit_get_store_class() {
296         return get_class($this->get_store());
297     }
299     /**
300      * Returns all the interfaces the cache store implements.
301      * @return array
302      */
303     public function phpunit_get_store_implements() {
304         return class_implements($this->get_store());
305     }
307     /**
308      * Returns the given key directly from the static acceleration array.
309      *
310      * @param string $key
311      * @return false|mixed
312      */
313     public function phpunit_static_acceleration_get($key) {
314         $key = $this->parse_key($key);
315         return $this->static_acceleration_get($key);
316     }
319 /**
320  * PHPUnit session cache loader.
321  *
322  * Used to expose things we could not otherwise see within an session cache.
323  *
324  * @copyright  2012 Sam Hemelryk
325  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
326  */
327 class cache_phpunit_session extends cache_session {
329     /**
330      * Returns the class of the store immediately associated with this cache.
331      * @return string
332      */
333     public function phpunit_get_store_class() {
334         return get_class($this->get_store());
335     }
337     /**
338      * Returns all the interfaces the cache store implements.
339      * @return array
340      */
341     public function phpunit_get_store_implements() {
342         return class_implements($this->get_store());
343     }
346 /**
347  * PHPUnit request cache loader.
348  *
349  * Used to expose things we could not otherwise see within an request cache.
350  *
351  * @copyright  2012 Sam Hemelryk
352  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
353  */
354 class cache_phpunit_request extends cache_request {
356     /**
357      * Returns the class of the store immediately associated with this cache.
358      * @return string
359      */
360     public function phpunit_get_store_class() {
361         return get_class($this->get_store());
362     }
364     /**
365      * Returns all the interfaces the cache store implements.
366      * @return array
367      */
368     public function phpunit_get_store_implements() {
369         return class_implements($this->get_store());
370     }
373 /**
374  * Dummy overridden cache loader class that we can use to test overriding loader functionality.
375  *
376  * @copyright  2012 Sam Hemelryk
377  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
378  */
379 class cache_phpunit_dummy_overrideclass extends cache_application {
380     // Satisfying the code pre-checker is just part of my day job.
383 /**
384  * Cache PHPUnit specific factory.
385  *
386  * @copyright  2012 Sam Hemelryk
387  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
388  */
389 class cache_phpunit_factory extends cache_factory {
390     /**
391      * Exposes the cache_factory's disable method.
392      *
393      * Perhaps one day that method will be made public, for the time being it is protected.
394      */
395     public static function phpunit_disable() {
396         parent::disable();
397     }