WebSVN – Moodle – Diff – /cache/tests/fixtures/lib.php

  * Support library for the cache PHPUnit tests.
+ *
  * This file is part of Moodle's cache API, affectionately called MUC.
  * It contains the components that are requried in order to use caching.
+ *
- * @package    core
+ * @package    core_cache
  * @category   cache
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 defined('MOODLE_INTERNAL') || die();
-require_once($CFG->dirroot.'/cache/locallib.php');
+use core_cache\store;
 /**
  * @since 2.9
  * @copyright 2012 Sam Hemelryk
  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class cache_config_testing extends cache_config_writer {
     /**
      * Creates the default configuration and saves it.
+     *
      * This function calls config_save, however it is safe to continue using it afterwards as this function should only ever
      * be called when there is no configuration file already.
     public static function create_default_configuration($forcesave = false) {
         global $CFG;
         // HACK ALERT.
         // We probably need to come up with a better way to create the default stores, or at least ensure 100% that the
         // default store plugins are protected from deletion.
-        $writer = new self;
+        $writer = new self();
         $writer->configstores = self::get_default_stores();
         $writer->configdefinitions = self::locate_definitions();
         $defaultapplication = 'default_application';
         $appdefine = defined('TEST_CACHE_USING_APPLICATION_STORE') ? TEST_CACHE_USING_APPLICATION_STORE : false;
         if ($appdefine !== false && preg_match('/^[a-zA-Z][a-zA-Z0-9_]+$/', $appdefine)) {
             $expectedstore = $appdefine;
-            $file = $CFG->dirroot.'/cache/stores/'.$appdefine.'/lib.php';
+            $file = $CFG->dirroot . '/cache/stores/' . $appdefine . '/lib.php';
-            $class = 'cachestore_'.$appdefine;
+            $class = 'cachestore_' . $appdefine;
             if (file_exists($file)) {
                 require_once($file);
+            }
             if (class_exists($class) && $class::ready_to_be_used_for_testing()) {
-                /* @var cache_store $class */
+                /* @var store $class */
-                $writer->configstores['test_application'] = array(
+                $writer->configstores['test_application'] = [
                     'name' => 'test_application',
                     'plugin' => $expectedstore,
                     'modes' => $class::get_supported_modes(),
                     'features' => $class::get_supported_features(),
-                    'configuration' => $class::unit_test_configuration()
+                    'configuration' => $class::unit_test_configuration(),
-                );
+                ];
                 $defaultapplication = 'test_application';
             }
         }
-        $writer->configmodemappings = array(
+        $writer->configmodemappings = [
-            array(
+            [
-                'mode' => cache_store::MODE_APPLICATION,
+                'mode' => store::MODE_APPLICATION,
                 'store' => $defaultapplication,
-                'sort' => -1
+                'sort' => -1,
-            ),
+            ],
-            array(
+            [
-                'mode' => cache_store::MODE_SESSION,
+                'mode' => store::MODE_SESSION,
                 'store' => 'default_session',
-                'sort' => -1
+                'sort' => -1,
-            ),
+            ],
-            array(
+            [
-                'mode' => cache_store::MODE_REQUEST,
+                'mode' => store::MODE_REQUEST,
                 'store' => 'default_request',
-                'sort' => -1
+                'sort' => -1,
-            )
+            ],
-        );
+        ];
-        $writer->configlocks = array(
+        $writer->configlocks = [
-            'default_file_lock' => array(
+            'default_file_lock' => [
                 'name' => 'cachelock_file_default',
                 'type' => 'cachelock_file',
                 'dir' => 'filelocks',
-                'default' => true
+                'default' => true,
             ],
-        );
+        ];
      * @return string The absolute path
      */
     protected static function get_config_file_path() {
         global $CFG;
         // We always use this path.
-        $configpath = $CFG->dataroot.'/muc/config.php';
+        $configpath = $CFG->dataroot . '/muc/config.php';
-        if (!empty($CFG->altcacheconfigpath)) {
         if (!empty($CFG->altcacheconfigpath)) {
             // No need to check we are within a test here, this is the cache config class that gets used
             // only when one of those is true.
-            if  (!defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') || !TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH) {
+            if (!defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') || !TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH) {
                 // TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH has not being defined or is false, we want to use the default.
                 return $configpath;
+            }
             $path = $CFG->altcacheconfigpath;
             if (is_dir($path) && is_writable($path)) {
                 // Its a writable directory, thats fine. Convert it to a file.
-                $path = $CFG->altcacheconfigpath.'/cacheconfig.php';
+                $path = $CFG->altcacheconfigpath . '/cacheconfig.php';
+            }
             if (is_readable($path)) {
                 $directory = dirname($configpath);
      *    however set this to false if you only want it to add the definition and not the mapping.
      */
     public function phpunit_add_definition($area, array $properties, $addmapping = true) {
         if (!array_key_exists('overrideclass', $properties)) {
             switch ($properties['mode']) {
-                case cache_store::MODE_APPLICATION:
+                case store::MODE_APPLICATION:
                     $properties['overrideclass'] = 'cache_phpunit_application';
                     break;
-                case cache_store::MODE_SESSION:
+                case store::MODE_SESSION:
                     $properties['overrideclass'] = 'cache_phpunit_session';
                     break;
-                case cache_store::MODE_REQUEST:
+                case store::MODE_REQUEST:
                     $properties['overrideclass'] = 'cache_phpunit_request';
                     break;
+            }
+        }
         $this->configdefinitions[$area] = $properties;
         if ($addmapping) {
             switch ($properties['mode']) {
-                case cache_store::MODE_APPLICATION:
+                case store::MODE_APPLICATION:
                     $this->phpunit_add_definition_mapping($area, 'default_application', 0);
                     break;
-                case cache_store::MODE_SESSION:
+                case store::MODE_SESSION:
                     $this->phpunit_add_definition_mapping($area, 'default_session', 0);
                     break;
-                case cache_store::MODE_REQUEST:
+                case store::MODE_REQUEST:
                     $this->phpunit_add_definition_mapping($area, 'default_request', 0);
                     break;
+            }
+        }
+    }
     /**
      * Removes the configured stores so that there are none available.
      */
     public function phpunit_remove_stores() {
-        $this->configstores = array();
+        $this->configstores = [];
+    }
     /**
      */
     public function phpunit_add_file_store(string $name, bool $nativettl = true): void {
         if (!$nativettl) {
             require_once(__DIR__ . '/cachestore_file_with_ttl_wrappers.php');
+        }
-        $this->configstores[$name] = array(
+        $this->configstores[$name] = [
             'name' => $name,
             'plugin' => 'file',
-            'configuration' => array(
+            'configuration' => [
-                'path' => ''
+                'path' => '',
-            ),
+            ],
             'features' => 6,
             'modes' => 3,
             'mappingsonly' => false,
             'class' => $nativettl ? 'cachestore_file' : 'cachestore_file_with_ttl_wrappers',
             'default' => false,
-            'lock' => 'cachelock_file_default'
+            'lock' => 'cachelock_file_default',
-        );
+        ];
+    }
     /**
      * Hacks the in-memory configuration for a store.
      * Forcefully adds a session store.
+     *
      * @param string $name
      */
     public function phpunit_add_session_store($name) {
-        $this->configstores[$name] = array(
+        $this->configstores[$name] = [
             'name' => $name,
             'plugin' => 'session',
-            'configuration' => array(),
+            'configuration' => [],
             'features' => 14,
             'modes' => 2,
             'default' => true,
             'class' => 'cachestore_session',
             'lock' => 'cachelock_file_default',
-        );
+        ];
+    }
     /**
      * Forcefully injects a definition => store mapping.
      * @param string $definition
      * @param string $store
      * @param int $sort
      */
     public function phpunit_add_definition_mapping($definition, $store, $sort) {
-        $this->configdefinitionmappings[] = array(
+        $this->configdefinitionmappings[] = [
             'store' => $store,
             'definition' => $definition,
-            'sort' => (int)$sort
+            'sort' => (int)$sort,
-        );
+        ];
+    }
     /**
      * Overrides the default site identifier used by the Cache API so that we can be sure of what it is.
+     *
      * @return string
      */
     public function get_site_identifier() {
         global $CFG;
-        return $CFG->wwwroot.'phpunit';
+        return $CFG->wwwroot . 'phpunit';
+    }
     /**
     /**
      * Prepares this object for caching
      * @return array
      */
     public function prepare_to_cache() {
-        return array($this->property1.'_ptc', $this->property2.'_ptc', $this->propertytime);
+        return [$this->property1 . '_ptc', $this->property2 . '_ptc', $this->propertytime];
+    }
     /**
      * Returns this object from the cache
      * @param array $data
      * @return cache_phpunit_dummy_object
         if (!is_null($data[2])) {
             // Windows 32bit microtime() resolution is 15ms, we ensure the time has moved forward.
             do {
                 $time = microtime(true);
             } while ($time == $data[2]);
+        }
-        return new cache_phpunit_dummy_object(array_shift($data).'_wfc', array_shift($data).'_wfc', $time);
+        return new cache_phpunit_dummy_object(array_shift($data) . '_wfc', array_shift($data) . '_wfc', $time);
+    }
+}
 /**
+     *
      * @param string $key
      * @return string
      */
     public function load_for_cache($key) {
-        return $key.' has no value really.';
+        return $key . ' has no value really.';
+    }
     /**
      * Loads many keys for the cache
+     *
      * @param array $keys
      * @return array
      */
     public function load_many_for_cache(array $keys) {
-        $return = array();
+        $return = [];
         foreach ($keys as $key) {
-            $return[$key] = $key.' has no value really.';
+            $return[$key] = $key . ' has no value really.';
+        }
         return $return;
+    }
+ *
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class cache_phpunit_application extends cache_application {
+    #[\Override]
+    public function get_store() {
+        return parent::get_store();
+    }
     /**
      * Returns the class of the store immediately associated with this cache.
      * @return string
+ *
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class cache_phpunit_session extends cache_session {
     /** @var Static member used for emulating the behaviour of session_id() during the tests. */
     protected static $sessionidmockup = 'phpunitmockupsessionid';
+    #[\Override]
+    public function get_store() {
+        return parent::get_store();
+    }
     /**
      * Returns the class of the store immediately associated with this cache.
      * @return string
      */
+ *
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class cache_phpunit_request extends cache_request {
+    #[\Override]
+    public function get_store() {
+        return parent::get_store();
+    }
     /**
      * Returns the class of the store immediately associated with this cache.
      * @return string

Proyectos de Subversion Moodle

(root)/cache/tests/fixtures/lib.php – Rev 1 → 1441