NN2022090201/vendor/topthink/framework/tests/thinkphp/library/think/cacheTest.php

<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2016 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <liu21st@gmail.com>
// +----------------------------------------------------------------------

namespace tests\thinkphp\library\think;

use tests\thinkphp\library\think\config\ConfigInitTrait;
use think\Cache;
use think\Config;

class cacheTest extends \PHPUnit_Framework_TestCase
{
    use ConfigInitTrait {
        ConfigInitTrait::tearDown as ConfigTearDown;
    }

    public function tearDown()
    {
        $this->ConfigTearDown();

        call_user_func(\Closure::bind(function () {
            Cache::$handler    = null;
            Cache::$instance   = [];
            Cache::$readTimes  = 0;
            Cache::$writeTimes = 0;
        }, null, '\think\Cache'));
    }

    /**
     * @dataProvider provideTestConnect
     */
    public function testConnect($options, $expected)
    {
        $connection = Cache::connect($options);
        $this->assertInstanceOf($expected, $connection);
        $this->assertSame($connection, Cache::connect($options));

        $instance = $this->getPropertyVal('instance');
        $this->assertArrayHasKey(md5(serialize($options)), $instance);

        $newConnection = Cache::connect($options, true);
        $newInstance = $this->getPropertyVal('instance');
        $this->assertInstanceOf($expected, $connection);
        $this->assertNotSame($connection, $newConnection);
        $this->assertEquals($instance, $newInstance);
    }

    /**
     * @dataProvider provideTestInit
     */
    public function testInit($options, $expected)
    {
        $connection = Cache::init($options);
        $this->assertInstanceOf($expected, $connection);

        $connectionNew = Cache::init(['type' => 'foo']);
        $this->assertSame($connection, $connectionNew);
    }

    public function testStore()
    {
        Config::set('cache.redis', ['type' => 'redis']);

        $connectionDefault = Cache::store();
        $this->assertInstanceOf('\think\cache\driver\File', $connectionDefault);

        Config::set('cache.type', false);
        $connectionNotRedis = Cache::store('redis');
        $this->assertSame($connectionDefault, $connectionNotRedis);

        Config::set('cache.type', 'complex');
        $connectionRedis = Cache::store('redis');
        $this->assertNotSame($connectionNotRedis, $connectionRedis);
        $this->assertInstanceOf('\think\cache\driver\Redis', $connectionRedis);

        // 即便成功切换到其他存储类型，也不影响原先的操作句柄
        $this->assertSame($connectionDefault, Cache::store());
    }

    public function testHas()
    {
        $key = $this->buildTestKey('Has');

        $this->assertFalse(Cache::has($key));

        Cache::set($key, 5);
        $this->assertTrue(Cache::has($key));
    }

    public function testGet()
    {
        $key = $this->buildTestKey('Get');

        $this->assertFalse(Cache::get($key));

        $this->assertEquals('default', Cache::get($key, 'default'));

        Cache::set($key, 5);
        $this->assertSame(5, Cache::get($key));
    }

    public function testSet()
    {
        $key = $this->buildTestKey('Set');

        $this->assertTrue(Cache::set(null, null));
        $this->assertTrue(Cache::set($key, 'ThinkPHP3.2'));
        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', null));
        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', -1));
        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', 0));
        $this->assertTrue(Cache::set($key, 'ThinkPHP5.0', 7200));
    }

    public function testInc()
    {
        $key = $this->buildTestKey('Inc');

        Cache::inc($key);
        $this->assertEquals(1, Cache::get($key));

        Cache::inc($key, '2');
        $this->assertEquals(3, Cache::get($key));

        Cache::inc($key, -1);
        $this->assertEquals(2, Cache::get($key));

        Cache::inc($key, null);
        $this->assertEquals(2, Cache::get($key));

        Cache::inc($key, true);
        $this->assertEquals(3, Cache::get($key));

        Cache::inc($key, false);
        $this->assertEquals(3, Cache::get($key));

        Cache::inc($key, 0.789);
        $this->assertEquals(3.789, Cache::get($key));
    }
    public function testDec()
    {
        $key = $this->buildTestKey('Dec');

        Cache::dec($key);
        $this->assertEquals(-1, Cache::get($key));

        Cache::dec($key, '2');
        $this->assertEquals(-3, Cache::get($key));

        Cache::dec($key, -1);
        $this->assertEquals(-2, Cache::get($key));

        Cache::dec($key, null);
        $this->assertEquals(-2, Cache::get($key));

        Cache::dec($key, true);
        $this->assertEquals(-3, Cache::get($key));

        Cache::dec($key, false);
        $this->assertEquals(-3, Cache::get($key));

        Cache::dec($key, 0.359);
        $this->assertEquals(-3.359, Cache::get($key));
    }

    public function testRm()
    {
        $key = $this->buildTestKey('Rm');

        $this->assertFalse(Cache::rm($key));

        Cache::set($key, 'ThinkPHP');
        $this->assertTrue(Cache::rm($key));
    }

    public function testClear()
    {
        $key1 = $this->buildTestKey('Clear1');
        $key2 = $this->buildTestKey('Clear2');

        Cache::set($key1, 'ThinkPHP3.2');
        Cache::set($key2, 'ThinkPHP5.0');

        $this->assertEquals('ThinkPHP3.2', Cache::get($key1));
        $this->assertEquals('ThinkPHP5.0', Cache::get($key2));
        Cache::clear();
        $this->assertFalse(Cache::get($key1));
        $this->assertFalse(Cache::get($key2));
    }

    public function testPull()
    {
        $key = $this->buildTestKey('Pull');

        $this->assertNull(Cache::pull($key));

        Cache::set($key, 'ThinkPHP');
        $this->assertEquals('ThinkPHP', Cache::pull($key));
        $this->assertFalse(Cache::get($key));
    }

    public function testRemember()
    {
        $key1 = $this->buildTestKey('Remember1');
        $key2 = $this->buildTestKey('Remember2');

        $this->assertEquals('ThinkPHP3.2', Cache::remember($key1, 'ThinkPHP3.2'));
        $this->assertEquals('ThinkPHP3.2', Cache::remember($key1, 'ThinkPHP5.0'));

        $this->assertEquals('ThinkPHP5.0', Cache::remember($key2, function () {
            return 'ThinkPHP5.0';
        }));
        $this->assertEquals('ThinkPHP5.0', Cache::remember($key2, function () {
            return 'ThinkPHP3.2';
        }));
    }

    public function testTag()
    {
        $key = $this->buildTestKey('Tag');

        $cacheTagWithoutName = Cache::tag(null);
        $this->assertInstanceOf('think\cache\Driver', $cacheTagWithoutName);

        $cacheTagWithKey = Cache::tag($key, [1, 2, 3]);
        $this->assertSame($cacheTagWithoutName, $cacheTagWithKey);
    }

    protected function getPropertyVal($name)
    {
        static $reflectionClass;
        if (empty($reflectionClass)) {
            $reflectionClass = new \ReflectionClass('\think\Cache');
        }

        $property = $reflectionClass->getProperty($name);
        $property->setAccessible(true);

        return $property->getValue();
    }

    public function provideTestConnect()
    {
        $provideData = [];

        $options   = ['type' => null];
        $expected  = '\think\cache\driver\File';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'File'];
        $expected  = '\think\cache\driver\File';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'Lite'];
        $expected  = '\think\cache\driver\Lite';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'Memcached'];
        $expected  = '\think\cache\driver\Memcached';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'Redis'];
        $expected  = '\think\cache\driver\Redis';
        $provideData[] = [$options, $expected];

        // TODO
        // $options   = ['type' => 'Memcache'];
        // $expected  = '\think\cache\driver\Memcache';
        // $provideData[] = [$options, $expected];
        //
        // $options   = ['type' => 'Wincache'];
        // $expected  = '\think\cache\driver\Wincache';
        // $provideData[] = [$options, $expected];

        // $options   = ['type' => 'Sqlite'];
        // $expected  = '\think\cache\driver\Sqlite';
        // $provideData[] = [$options, $expected];
        //
        // $options   = ['type' => 'Xcache'];
        // $expected  = '\think\cache\driver\Xcache';
        // $provideData[] = [$options, $expected];

        return $provideData;
    }

    public function provideTestInit()
    {
        $provideData = [];

        $options   = [];
        $expected  = '\think\cache\driver\File';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'File'];
        $expected  = '\think\cache\driver\File';
        $provideData[] = [$options, $expected];

        $options   = ['type' => 'Lite'];
        $expected  = '\think\cache\driver\Lite';
        $provideData[] = [$options, $expected];

        return $provideData;
    }

    protected function buildTestKey($tag)
    {
        return sprintf('ThinkPHP_Test_%s_%d_%d', $tag, time(), rand(0, 10000));
    }
}