MDL-40555 cache: implemented unit tests for default search functionality
[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      * Adds a definition to the stack
41      * @param string $area
42      * @param array $properties
43      */
44     public function phpunit_add_definition($area, array $properties) {
45         if (!array_key_exists('overrideclass', $properties)) {
46             switch ($properties['mode']) {
47                 case cache_store::MODE_APPLICATION:
48                     $properties['overrideclass'] = 'cache_phpunit_application';
49                     break;
50                 case cache_store::MODE_SESSION:
51                     $properties['overrideclass'] = 'cache_phpunit_session';
52                     break;
53                 case cache_store::MODE_REQUEST:
54                     $properties['overrideclass'] = 'cache_phpunit_request';
55                     break;
56             }
57         }
58         $this->configdefinitions[$area] = $properties;
59     }
61     /**
62      * Removes a definition.
63      * @param string $name
64      */
65     public function phpunit_remove_definition($name) {
66         unset($this->configdefinitions[$name]);
67     }
69     /**
70      * Removes the configured stores so that there are none available.
71      */
72     public function phpunit_remove_stores() {
73         $this->configstores = array();
74     }
76     /**
77      * Forcefully adds a file store.
78      *
79      * @param string $name
80      */
81     public function phpunit_add_file_store($name) {
82         $this->configstores[$name] = array(
83             'name' => $name,
84             'plugin' => 'file',
85             'configuration' => array(
86                 'path' => ''
87             ),
88             'features' => 6,
89             'modes' => 3,
90             'mappingsonly' => false,
91             'class' => 'cachestore_file',
92             'default' => false,
93             'lock' => 'cachelock_file_default'
94         );
95     }
97     /**
98      * Forcefully injects a definition => store mapping.
99      *
100      * This function does no validation, you should only be calling if it you know
101      * exactly what to expect.
102      *
103      * @param string $definition
104      * @param string $store
105      * @param int $sort
106      */
107     public function phpunit_add_definition_mapping($definition, $store, $sort) {
108         $this->configdefinitionmappings[] = array(
109             'store' => $store,
110             'definition' => $definition,
111             'sort' => (int)$sort
112         );
113     }
115     /**
116      * Overrides the default site identifier used by the Cache API so that we can be sure of what it is.
117      *
118      * @return string
119      */
120     public function get_site_identifier() {
121         global $CFG;
122         return $CFG->wwwroot.'phpunit';
123     }
126 /**
127  * Dummy object for testing cacheable object interface and interaction
128  *
129  * @copyright  2012 Sam Hemelryk
130  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
131  */
132 class cache_phpunit_dummy_object extends stdClass implements cacheable_object {
133     /**
134      * Test property 1
135      * @var string
136      */
137     public $property1;
138     /**
139      * Test property 1
140      * @var string
141      */
142     public $property2;
143     /**
144      * Constructor
145      * @param string $property1
146      * @param string $property2
147      */
148     public function __construct($property1, $property2) {
149         $this->property1 = $property1;
150         $this->property2 = $property2;
151     }
152     /**
153      * Prepares this object for caching
154      * @return array
155      */
156     public function prepare_to_cache() {
157         return array($this->property1.'_ptc', $this->property2.'_ptc');
158     }
159     /**
160      * Returns this object from the cache
161      * @param array $data
162      * @return cache_phpunit_dummy_object
163      */
164     public static function wake_from_cache($data) {
165         return new cache_phpunit_dummy_object(array_shift($data).'_wfc', array_shift($data).'_wfc');
166     }
169 /**
170  * Dummy data source object for testing data source interface and implementation
171  *
172  * @copyright  2012 Sam Hemelryk
173  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
174  */
175 class cache_phpunit_dummy_datasource implements cache_data_source {
176     /**
177      * Returns an instance of this object for use with the cache.
178      *
179      * @param cache_definition $definition
180      * @return cache_phpunit_dummy_datasource
181      */
182     public static function get_instance_for_cache(cache_definition $definition) {
183         return new cache_phpunit_dummy_datasource();
184     }
186     /**
187      * Loads a key for the cache.
188      *
189      * @param string $key
190      * @return string
191      */
192     public function load_for_cache($key) {
193         return $key.' has no value really.';
194     }
196     /**
197      * Loads many keys for the cache
198      *
199      * @param array $keys
200      * @return array
201      */
202     public function load_many_for_cache(array $keys) {
203         $return = array();
204         foreach ($keys as $key) {
205             $return[$key] = $key.' has no value really.';
206         }
207         return $return;
208     }
211 /**
212  * PHPUnit application cache loader.
213  *
214  * Used to expose things we could not otherwise see within an application cache.
215  *
216  * @copyright  2012 Sam Hemelryk
217  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
218  */
219 class cache_phpunit_application extends cache_application {
221     /**
222      * Returns the class of the store immediately associated with this cache.
223      * @return string
224      */
225     public function phpunit_get_store_class() {
226         return get_class($this->get_store());
227     }
229     /**
230      * Returns all the interfaces the cache store implements.
231      * @return array
232      */
233     public function phpunit_get_store_implements() {
234         return class_implements($this->get_store());
235     }
238 /**
239  * PHPUnit session cache loader.
240  *
241  * Used to expose things we could not otherwise see within an session cache.
242  *
243  * @copyright  2012 Sam Hemelryk
244  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
245  */
246 class cache_phpunit_session extends cache_session {
248     /**
249      * Returns the class of the store immediately associated with this cache.
250      * @return string
251      */
252     public function phpunit_get_store_class() {
253         return get_class($this->get_store());
254     }
256     /**
257      * Returns all the interfaces the cache store implements.
258      * @return array
259      */
260     public function phpunit_get_store_implements() {
261         return class_implements($this->get_store());
262     }
265 /**
266  * PHPUnit request cache loader.
267  *
268  * Used to expose things we could not otherwise see within an request cache.
269  *
270  * @copyright  2012 Sam Hemelryk
271  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
272  */
273 class cache_phpunit_request extends cache_request {
275     /**
276      * Returns the class of the store immediately associated with this cache.
277      * @return string
278      */
279     public function phpunit_get_store_class() {
280         return get_class($this->get_store());
281     }
283     /**
284      * Returns all the interfaces the cache store implements.
285      * @return array
286      */
287     public function phpunit_get_store_implements() {
288         return class_implements($this->get_store());
289     }
292 /**
293  * Dummy overridden cache loader class that we can use to test overriding loader functionality.
294  *
295  * @copyright  2012 Sam Hemelryk
296  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
297  */
298 class cache_phpunit_dummy_overrideclass extends cache_application {
299     // Satisfying the code pre-checker is just part of my day job.
302 /**
303  * Cache PHPUnit specific factory.
304  *
305  * @copyright  2012 Sam Hemelryk
306  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
307  */
308 class cache_phpunit_factory extends cache_factory {
309     /**
310      * Exposes the cache_factory's disable method.
311      *
312      * Perhaps one day that method will be made public, for the time being it is protected.
313      */
314     public static function phpunit_disable() {
315         parent::disable();
316     }