/**
* Test the cache can be bootstrapped when using the redis driver.
*
* @covers Molovo\Amnesia\Cache::bootstrap
* @covers Molovo\Amnesia\Cache\Instance::__construct
* @covers Molovo\Amnesia\Driver\File::__construct
* @covers Molovo\Amnesia\Cache::instance
*/
public function testBootstrap()
{
$name = 'file_driver_test';
$config = [$name => ['driver' => 'file', 'store_path' => dirname(dirname(__DIR__)) . '/_data/cache/store']];
if (!is_dir($config[$name]['store_path'])) {
// This is a test cache, so just let anyone write to it
// to avoid having to deal with permissions issues
mkdir($config[$name]['store_path'], 0777, true);
}
Cache::bootstrap($config);
$instance = Cache::instance($name);
verify($instance)->isInstanceOf(Instance::class);
// Test that the driver has been instantiated correctly
$property = new \ReflectionProperty(Instance::class, 'driver');
$property->setAccessible(true);
$driver = $property->getValue($instance);
verify($driver)->isInstanceOf(File::class);
// Call a second time to test retrieval from cache
$cached_instance = Cache::instance($name);
// Compare hashes of the two instances to ensure they are
// the same object
$hash1 = spl_object_hash($instance);
$hash2 = spl_object_hash($cached_instance);
verify($hash1)->equals($hash2);
// Store the instance so we can use it in other tests
static::$instance = $instance;
}
/**
* Test the cache can be bootstrapped when using the memcached driver.
*
* @covers Molovo\Amnesia\Cache::bootstrap
* @covers Molovo\Amnesia\Cache\Instance::__construct
* @covers Molovo\Amnesia\Driver\Memcached::__construct
* @covers Molovo\Amnesia\Cache::instance
*/
public function testBootstrap()
{
$name = 'memcached_driver_test';
$config = [$name => ['driver' => 'memcached', 'servers' => [['localhost', 11211]]]];
Cache::bootstrap($config);
$instance = Cache::instance($name);
verify($instance)->isInstanceOf(Instance::class);
// Test that the driver has been instantiated correctly
$property = new \ReflectionProperty(Instance::class, 'driver');
$property->setAccessible(true);
$driver = $property->getValue($instance);
verify($driver)->isInstanceOf(Memcached::class);
// Call a second time to test retrieval from cache
$cached_instance = Cache::instance($name);
// Compare hashes of the two instances to ensure they are
// the same object
$hash1 = spl_object_hash($instance);
$hash2 = spl_object_hash($cached_instance);
verify($hash1)->equals($hash2);
// Store the instance so we can use it in other tests
static::$instance = $instance;
}
/**
* Create a new instance of the cache and driver.
*
* @param string|null $name The connection name
* @param Config|null $config The config for the instance
*/
public function __construct($name = null, Config $config = null)
{
// If a name isn't provided, then we'll use the default
$this->name = $name ?: 'default';
// Load the config if it isn't passed in
if ($config === null) {
$config = Cache::config()->{$this->name};
}
// If config is still null, then throw an exception
if ($config === null) {
throw new ConfigNotFoundException('No config could be found for instance ' . $this->name . '.');
}
// Set the name in the config as some drivers need it
$config->name = $this->name;
// Create a cache namespace key
$this->key = hash('adler32', $name);
// If the driver isn't created, throw an exception
if (!isset($this->drivers[$config->driver])) {
throw new InvalidDriverException($config->driver . ' is not a valid driver.');
}
// Initialise the driver
$driverClass = $this->drivers[$config->driver];
$this->driver = new $driverClass($config, $this);
}
/**
* Test the cache can be bootstrapped when using the redis driver.
*
* @covers Molovo\Amnesia\Cache::bootstrap
* @covers Molovo\Amnesia\Cache\Instance::__construct
* @covers Molovo\Amnesia\Driver\Redis::__construct
* @covers Molovo\Amnesia\Cache::instance
*/
public function testBootstrapSocket()
{
$name = 'redis_driver_socket_test';
$config = [$name => ['driver' => 'redis', 'socket' => '/usr/local/var/run/redis/redis.sock']];
Cache::bootstrap($config);
$instance = Cache::instance($name);
verify($instance)->isInstanceOf(Instance::class);
// Test that the driver has been instantiated correctly
$property = new \ReflectionProperty(Instance::class, 'driver');
$property->setAccessible(true);
$driver = $property->getValue($instance);
verify($driver)->isInstanceOf(Redis::class);
// Call a second time to test retrieval from cache
$cached_instance = Cache::instance($name);
// Compare hashes of the two instances to ensure they are
// the same object
$hash1 = spl_object_hash($instance);
$hash2 = spl_object_hash($cached_instance);
verify($hash1)->equals($hash2);
}
/**
* Set a config value.
*
* @param string $path The path of the value to set
* @param mixed $value The value to set
*
* @return mixed The value
*/
public static function set($key, $value = null)
{
return Cache::config()->setValueForPath($key, $value);
}
/**
* Create a new application instance.
*/
public function __construct()
{
// Store the instance statically
static::$instance = $this;
// Load the app's config
$this->loadConfig();
// Register the error handler
$this->registerErrorHandler();
// Create our request and response objects
$this->request = new Request();
$this->response = new Response();
// Bootstrap the database
Database::bootstrap($this->config->db->toArray());
// Convert relative store paths to absolute, and bootstrap the cache
foreach ($this->config->cache as $instance => $config) {
$cacheStorePath = $config->store_path;
if ($cacheStorePath !== null) {
if (!is_dir($cacheStorePath) && is_dir(APP_ROOT . $cacheStorePath)) {
$this->config->cache->{$instance}->store_path = APP_ROOT . $cacheStorePath;
}
}
}
Cache::bootstrap($this->config->cache->toArray());
// Convert relative store paths to absolute, and bootstrap the session
$sessionStorePath = $this->config->session->store_path;
if ($sessionStorePath !== null) {
if (!is_dir($sessionStorePath) && is_dir(APP_ROOT . $sessionStorePath)) {
$this->config->session->store_path = APP_ROOT . $sessionStorePath;
}
}
Session::bootstrap($this->config->session);
// Include the app routes
require APP_ROOT . 'routes.php';
// Register global view variables
View::addGlobal('appName', $this->config->app->name);
View::addGlobal('app', $this);
View::addGlobal('input', $this->request->input);
$this->compileAssets();
// Execute routes
Router::execute();
if (PHP_SAPI !== 'cli') {
$this->checkRoute();
}
}
/**
* Render the contents of a view.
*
* @param array $vars Variables to pass to views
* @param bool $bypassCache Whether to bypass the cache
*
* @return string The rendered HTML
*/
public function render(array $vars = [], $bypassCache = false)
{
// Check the cache
if ($this->cache && !$bypassCache) {
if (($content = Cache::get($this->cacheKey())) !== null) {
return $content;
}
}
$vars = array_merge($this->vars, $vars);
switch ($this->type) {
// The view is a markdown file
case 'md':
case 'markdown':
$this->content = $this->renderMarkdown($vars);
break;
// The view is a mustache template
// The view is a mustache template
case 'mhtml':
case 'mustache':
$this->content = $this->renderMustache($vars);
break;
// The view is a simple PHP file
// The view is a simple PHP file
case 'php':
default:
$this->content = $this->renderPhp($vars);
break;
}
$vars = array_merge($this->vars, $vars);
if ($this->options['layout'] !== null) {
$vars['content'] = $this->content;
$this->content = (new self($this->options['layout'], $vars))->render();
}
if ($this->cache) {
Cache::set($this->cacheKey(), $this->content, $this->cache_expiry);
}
return $this->content;
}
/**
* Create the instance which we will use during testing.
*/
public static function setUpBeforeClass()
{
Cache::bootstrap(['default' => ['driver' => 'redis']]);
static::$instance = Cache::instance();
}