pax_global_header 0000666 0000000 0000000 00000000064 13750251207 0014514 g ustar 00root root 0000000 0000000 52 comment=eda2e6b8bc5abcd623c8047e2345cda38dd6479e
integration-tests-0.17.0/ 0000775 0000000 0000000 00000000000 13750251207 0015264 5 ustar 00root root 0000000 0000000 integration-tests-0.17.0/.gitignore 0000775 0000000 0000000 00000000053 13750251207 0017255 0 ustar 00root root 0000000 0000000 .phpunit.result.cache
composer.lock
vendor
integration-tests-0.17.0/.travis.yml 0000664 0000000 0000000 00000001561 13750251207 0017400 0 ustar 00root root 0000000 0000000 dist: trusty
language: php
sudo: true
env:
global:
- SYMFONY_PHPUNIT_VERSION=5.7
matrix:
fast_finish: true
include:
- php: 7.0
env: SUITE=PHPCache
- php: 7.0
env: SUITE=Symfony
- php: 7.0
env: SUITE=Laravel
- php: 7.0
env: SUITE=Stash
- php: 7.1
env: SUITE=PHPCache
- php: 7.2
env: SUITE=PHPCache
allow_failures:
- env: SUITE=Stash
services:
- redis
- memcached
cache:
directories:
- "$HOME/.composer/cache"
before_install:
- echo "Disable xdebug" && phpenv config-rm xdebug.ini
install:
- echo "extension = memcached.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/conf.d/travis.ini
- echo "extension = redis.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/conf.d/travis.ini
- composer update --prefer-source
script:
- ./vendor/bin/simple-phpunit --testsuite $SUITE
integration-tests-0.17.0/LICENSE 0000775 0000000 0000000 00000002071 13750251207 0016274 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2015 Aaron Scherer
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
integration-tests-0.17.0/README.md 0000664 0000000 0000000 00000003433 13750251207 0016546 0 ustar 00root root 0000000 0000000 # PSR-6 and PSR-16 Integration tests
[](https://gitter.im/php-cache/cache?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
[](https://packagist.org/packages/cache/integration-tests)
[](https://packagist.org/packages/cache/integration-tests)
[](https://packagist.org/packages/cache/integration-tests)
[](LICENSE)
This repository contains integration tests to make sure your implementation of a PSR-6 and/or PSR-16 cache follows the rules by PHP-FIG.
It is a part of the PHP Cache organisation. To read about us please read the shared documentation at [www.php-cache.com](http://www.php-cache.com).
### Install
```bash
composer require --dev cache/integration-tests:dev-master
```
### Use
Create a test that looks like this:
```php
class PoolIntegrationTest extends CachePoolTest
{
public function createCachePool()
{
return new CachePool();
}
}
```
You could also test your tag implementation:
```php
class TagIntegrationTest extends TaggableCachePoolTest
{
public function createCachePool()
{
return new CachePool();
}
}
```
You can also test a PSR-16 implementation:
```php
class CacheIntegrationTest extends SimpleCacheTest
{
public function createSimpleCache()
{
return new SimpleCache();
}
}
```
### Contribute
Contributions are very welcome! Send a pull request or
report any issues you find on the [issue tracker](http://issues.php-cache.com).
integration-tests-0.17.0/composer.json 0000775 0000000 0000000 00000002437 13750251207 0020017 0 ustar 00root root 0000000 0000000 {
"name": "cache/integration-tests",
"type": "library",
"description": "Integration tests for PSR-6 and PSR-16 cache implementations",
"keywords": [
"cache",
"psr6",
"psr16",
"test"
],
"homepage": "https://github.com/php-cache/integration-tests",
"license": "MIT",
"authors": [
{
"name": "Aaron Scherer",
"email": "aequasi@gmail.com",
"homepage": "https://github.com/aequasi"
},
{
"name": "Tobias Nyholm",
"email": "tobias.nyholm@gmail.com",
"homepage": "https://github.com/nyholm"
}
],
"require": {
"php": ">=5.5.9",
"psr/cache": "~1.0",
"cache/tag-interop": "^1.0"
},
"require-dev": {
"cache/cache": "^1.0",
"symfony/cache": "^3.4.31|^4.3.4|^5.0",
"symfony/phpunit-bridge": "^5.1",
"illuminate/cache": "^5.4|^5.5|^5.6",
"tedivm/stash": "^0.14",
"mockery/mockery": "^1.0"
},
"conflict": {
"phpunit/phpunit": "<4.8.35|<5.4.3,>=5.0"
},
"autoload": {
"psr-4": {
"Cache\\IntegrationTests\\": "src/"
}
},
"minimum-stability": "dev",
"prefer-stable": true
}
integration-tests-0.17.0/phpunit.xml.dist 0000664 0000000 0000000 00000003714 13750251207 0020444 0 ustar 00root root 0000000 0000000
./vendor/cache/cache/src/Adapter/Redis/Tests/
./vendor/cache/cache/src/Bridge/SimpleCache/Tests/
./vendor/cache/cache/src/Adapter/Illuminate/Tests/
./vendor/symfony/cache/Tests/Adapter/FilesystemAdapterTest.php
./tests/StashTest.php
./
./Tests
./vendor
Cache\IntegrationTests
Symfony\Component\Cache
Symfony\Component\Cache\Tests\Fixtures
Symfony\Component\Cache\Tests\Traits
Symfony\Component\Cache\Traits
integration-tests-0.17.0/src/ 0000775 0000000 0000000 00000000000 13750251207 0016053 5 ustar 00root root 0000000 0000000 integration-tests-0.17.0/src/CachePoolTest.php 0000664 0000000 0000000 00000067554 13750251207 0021302 0 ustar 00root root 0000000 0000000 , Tobias Nyholm
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Cache\IntegrationTests;
use PHPUnit\Framework\TestCase;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
abstract class CachePoolTest extends TestCase
{
/**
* @type array with functionName => reason.
*/
protected $skippedTests = [];
/**
* @type CacheItemPoolInterface
*/
protected $cache;
/**
* @return CacheItemPoolInterface that is used in the tests
*/
abstract public function createCachePool();
/**
* @before
*/
public function setupService()
{
$this->cache = $this->createCachePool();
}
/**
* @after
*/
public function tearDownService()
{
if ($this->cache !== null) {
$this->cache->clear();
}
}
/**
* Data provider for invalid keys.
*
* @return array
*/
public static function invalidKeys()
{
return [
[true],
[false],
[null],
[2],
[2.5],
['{str'],
['rand{'],
['rand{str'],
['rand}str'],
['rand(str'],
['rand)str'],
['rand/str'],
['rand\\str'],
['rand@str'],
['rand:str'],
[new \stdClass()],
[['array']],
];
}
public function testBasicUsage()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('4711');
$this->cache->save($item);
$item = $this->cache->getItem('key2');
$item->set('4712');
$this->cache->save($item);
$fooItem = $this->cache->getItem('key');
$this->assertTrue($fooItem->isHit());
$this->assertEquals('4711', $fooItem->get());
$barItem = $this->cache->getItem('key2');
$this->assertTrue($barItem->isHit());
$this->assertEquals('4712', $barItem->get());
// Remove 'key' and make sure 'key2' is still there
$this->cache->deleteItem('key');
$this->assertFalse($this->cache->getItem('key')->isHit());
$this->assertTrue($this->cache->getItem('key2')->isHit());
// Remove everything
$this->cache->clear();
$this->assertFalse($this->cache->getItem('key')->isHit());
$this->assertFalse($this->cache->getItem('key2')->isHit());
}
public function testBasicUsageWithLongKey()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$pool = $this->createCachePool();
$key = str_repeat('a', 300);
$item = $pool->getItem($key);
$this->assertFalse($item->isHit());
$this->assertSame($key, $item->getKey());
$item->set('value');
$this->assertTrue($pool->save($item));
$item = $pool->getItem($key);
$this->assertTrue($item->isHit());
$this->assertSame($key, $item->getKey());
$this->assertSame('value', $item->get());
$this->assertTrue($pool->deleteItem($key));
$item = $pool->getItem($key);
$this->assertFalse($item->isHit());
}
public function testItemModifiersReturnsStatic()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$this->assertSame($item, $item->set('4711'));
$this->assertSame($item, $item->expiresAfter(2));
$this->assertSame($item, $item->expiresAt(new \DateTime('+2hours')));
}
public function testGetItem()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->save($item);
// get existing item
$item = $this->cache->getItem('key');
$this->assertEquals('value', $item->get(), 'A stored item must be returned from cached.');
$this->assertEquals('key', $item->getKey(), 'Cache key can not change.');
// get non-existent item
$item = $this->cache->getItem('key2');
$this->assertFalse($item->isHit());
$this->assertNull($item->get(), "Item's value must be null when isHit is false.");
}
public function testGetItems()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$keys = ['foo', 'bar', 'baz'];
$items = $this->cache->getItems($keys);
$count = 0;
/** @type CacheItemInterface $item */
foreach ($items as $i => $item) {
$item->set($i);
$this->cache->save($item);
$count++;
}
$this->assertSame(3, $count);
$keys[] = 'biz';
/** @type CacheItemInterface[] $items */
$items = $this->cache->getItems($keys);
$count = 0;
foreach ($items as $key => $item) {
$itemKey = $item->getKey();
$this->assertEquals($itemKey, $key, 'Keys must be preserved when fetching multiple items');
$this->assertEquals($key !== 'biz', $item->isHit());
$this->assertTrue(in_array($key, $keys), 'Cache key can not change.');
// Remove $key for $keys
foreach ($keys as $k => $v) {
if ($v === $key) {
unset($keys[$k]);
}
}
$count++;
}
$this->assertSame(4, $count);
}
public function testGetItemsEmpty()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$items = $this->cache->getItems([]);
$this->assertTrue(
is_array($items) || $items instanceof \Traversable,
'A call to getItems with an empty array must always return an array or \Traversable.'
);
$count = 0;
foreach ($items as $item) {
$count++;
}
$this->assertSame(0, $count);
}
public function testHasItem()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->save($item);
// has existing item
$this->assertTrue($this->cache->hasItem('key'));
// has non-existent item
$this->assertFalse($this->cache->hasItem('key2'));
}
public function testClear()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->save($item);
$return = $this->cache->clear();
$this->assertTrue($return, 'clear() must return true if cache was cleared. ');
$this->assertFalse($this->cache->getItem('key')->isHit(), 'No item should be a hit after the cache is cleared. ');
$this->assertFalse($this->cache->hasItem('key2'), 'The cache pool should be empty after it is cleared.');
}
public function testClearWithDeferredItems()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->saveDeferred($item);
$this->cache->clear();
$this->cache->commit();
$this->assertFalse($this->cache->getItem('key')->isHit(), 'Deferred items must be cleared on clear(). ');
}
public function testDeleteItem()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->save($item);
$this->assertTrue($this->cache->deleteItem('key'));
$this->assertFalse($this->cache->getItem('key')->isHit(), 'A deleted item should not be a hit.');
$this->assertFalse($this->cache->hasItem('key'), 'A deleted item should not be a in cache.');
$this->assertTrue($this->cache->deleteItem('key2'), 'Deleting an item that does not exist should return true.');
}
public function testDeleteItems()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$items = $this->cache->getItems(['foo', 'bar', 'baz']);
/** @type CacheItemInterface $item */
foreach ($items as $idx => $item) {
$item->set($idx);
$this->cache->save($item);
}
// All should be a hit but 'biz'
$this->assertTrue($this->cache->getItem('foo')->isHit());
$this->assertTrue($this->cache->getItem('bar')->isHit());
$this->assertTrue($this->cache->getItem('baz')->isHit());
$this->assertFalse($this->cache->getItem('biz')->isHit());
$return = $this->cache->deleteItems(['foo', 'bar', 'biz']);
$this->assertTrue($return);
$this->assertFalse($this->cache->getItem('foo')->isHit());
$this->assertFalse($this->cache->getItem('bar')->isHit());
$this->assertTrue($this->cache->getItem('baz')->isHit());
$this->assertFalse($this->cache->getItem('biz')->isHit());
}
public function testSave()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$return = $this->cache->save($item);
$this->assertTrue($return, 'save() should return true when items are saved.');
$this->assertEquals('value', $this->cache->getItem('key')->get());
}
public function testSaveExpired()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAt(\DateTime::createFromFormat('U', time() + 10));
$this->cache->save($item);
$item->expiresAt(\DateTime::createFromFormat('U', time() - 1));
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertFalse($item->isHit(), 'Cache should not save expired items');
}
public function testSaveWithoutExpire()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('test_ttl_null');
$item->set('data');
$this->cache->save($item);
// Use a new pool instance to ensure that we don't hit any caches
$pool = $this->createCachePool();
$item = $pool->getItem('test_ttl_null');
$this->assertTrue($item->isHit(), 'Cache should have retrieved the items');
$this->assertEquals('data', $item->get());
}
public function testDeferredSave()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('4711');
$return = $this->cache->saveDeferred($item);
$this->assertTrue($return, 'save() should return true when items are saved.');
$item = $this->cache->getItem('key2');
$item->set('4712');
$this->cache->saveDeferred($item);
// They are not saved yet but should be a hit
$this->assertTrue($this->cache->hasItem('key'), 'Deferred items should be considered as a part of the cache even before they are committed');
$this->assertTrue($this->cache->getItem('key')->isHit(), 'Deferred items should be a hit even before they are committed');
$this->assertTrue($this->cache->getItem('key2')->isHit());
$this->cache->commit();
// They should be a hit after the commit as well
$this->assertTrue($this->cache->getItem('key')->isHit());
$this->assertTrue($this->cache->getItem('key2')->isHit());
}
public function testDeferredExpired()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('4711');
$item->expiresAt(\DateTime::createFromFormat('U', time() - 1));
$this->cache->saveDeferred($item);
$this->assertFalse($this->cache->hasItem('key'), 'Cache should not have expired deferred item');
$this->cache->commit();
$item = $this->cache->getItem('key');
$this->assertFalse($item->isHit(), 'Cache should not save expired items');
}
public function testDeleteDeferredItem()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('4711');
$this->cache->saveDeferred($item);
$this->assertTrue($this->cache->getItem('key')->isHit());
$this->cache->deleteItem('key');
$this->assertFalse($this->cache->hasItem('key'), 'You must be able to delete a deferred item before committed. ');
$this->assertFalse($this->cache->getItem('key')->isHit(), 'You must be able to delete a deferred item before committed. ');
$this->cache->commit();
$this->assertFalse($this->cache->hasItem('key'), 'A deleted item should not reappear after commit. ');
$this->assertFalse($this->cache->getItem('key')->isHit(), 'A deleted item should not reappear after commit. ');
}
public function testDeferredSaveWithoutCommit()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->prepareDeferredSaveWithoutCommit();
gc_collect_cycles();
$cache = $this->createCachePool();
$this->assertTrue($cache->getItem('key')->isHit(), 'A deferred item should automatically be committed on CachePool::__destruct().');
}
private function prepareDeferredSaveWithoutCommit()
{
$cache = $this->cache;
$this->cache = null;
$item = $cache->getItem('key');
$item->set('4711');
$cache->saveDeferred($item);
}
public function testCommit()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->saveDeferred($item);
$return = $this->cache->commit();
$this->assertTrue($return, 'commit() should return true on successful commit. ');
$this->assertEquals('value', $this->cache->getItem('key')->get());
$return = $this->cache->commit();
$this->assertTrue($return, 'commit() should return true even if no items were deferred. ');
}
/**
* @medium
*/
public function testExpiration()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAfter(2);
$this->cache->save($item);
sleep(3);
$item = $this->cache->getItem('key');
$this->assertFalse($item->isHit());
$this->assertNull($item->get(), "Item's value must be null when isHit() is false.");
}
public function testExpiresAt()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAt(new \DateTime('+2hours'));
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
}
public function testExpiresAtWithNull()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAt(null);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
}
public function testExpiresAfterWithNull()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAfter(null);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
}
public function testKeyLength()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$key = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.';
$item = $this->cache->getItem($key);
$item->set('value');
$this->assertTrue($this->cache->save($item), 'The implementation does not support a valid cache key');
$this->assertTrue($this->cache->hasItem($key));
}
/**
* @dataProvider invalidKeys
*/
public function testGetItemInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\Cache\InvalidArgumentException');
$this->cache->getItem($key);
}
/**
* @dataProvider invalidKeys
*/
public function testGetItemsInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\Cache\InvalidArgumentException');
$this->cache->getItems(['key1', $key, 'key2']);
}
/**
* @dataProvider invalidKeys
*/
public function testHasItemInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\Cache\InvalidArgumentException');
$this->cache->hasItem($key);
}
/**
* @dataProvider invalidKeys
*/
public function testDeleteItemInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\Cache\InvalidArgumentException');
$this->cache->deleteItem($key);
}
/**
* @dataProvider invalidKeys
*/
public function testDeleteItemsInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\Cache\InvalidArgumentException');
$this->cache->deleteItems(['key1', $key, 'key2']);
}
public function testDataTypeString()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('5');
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue('5' === $item->get(), 'Wrong data type. If we store a string we must get an string back.');
$this->assertTrue(is_string($item->get()), 'Wrong data type. If we store a string we must get an string back.');
}
public function testDataTypeInteger()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set(5);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue(5 === $item->get(), 'Wrong data type. If we store an int we must get an int back.');
$this->assertTrue(is_int($item->get()), 'Wrong data type. If we store an int we must get an int back.');
}
public function testDataTypeNull()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set(null);
$this->cache->save($item);
$this->assertTrue($this->cache->hasItem('key'), 'Null is a perfectly fine cache value. hasItem() should return true when null are stored. ');
$item = $this->cache->getItem('key');
$this->assertTrue(null === $item->get(), 'Wrong data type. If we store null we must get an null back.');
$this->assertTrue(is_null($item->get()), 'Wrong data type. If we store null we must get an null back.');
$this->assertTrue($item->isHit(), 'isHit() should return true when null are stored. ');
}
public function testDataTypeFloat()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$float = 1.23456789;
$item = $this->cache->getItem('key');
$item->set($float);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue(is_float($item->get()), 'Wrong data type. If we store float we must get an float back.');
$this->assertEquals($float, $item->get());
$this->assertTrue($item->isHit(), 'isHit() should return true when float are stored. ');
}
public function testDataTypeBoolean()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set(true);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue(is_bool($item->get()), 'Wrong data type. If we store boolean we must get an boolean back.');
$this->assertTrue($item->get());
$this->assertTrue($item->isHit(), 'isHit() should return true when true are stored. ');
}
public function testDataTypeArray()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$array = ['a' => 'foo', 2 => 'bar'];
$item = $this->cache->getItem('key');
$item->set($array);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue(is_array($item->get()), 'Wrong data type. If we store array we must get an array back.');
$this->assertEquals($array, $item->get());
$this->assertTrue($item->isHit(), 'isHit() should return true when array are stored. ');
}
public function testDataTypeObject()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$object = new \stdClass();
$object->a = 'foo';
$item = $this->cache->getItem('key');
$item->set($object);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue(is_object($item->get()), 'Wrong data type. If we store object we must get an object back.');
$this->assertEquals($object, $item->get());
$this->assertTrue($item->isHit(), 'isHit() should return true when object are stored. ');
}
public function testBinaryData()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$data = '';
for ($i = 0; $i < 256; $i++) {
$data .= chr($i);
}
$item = $this->cache->getItem('key');
$item->set($data);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue($data === $item->get(), 'Binary data must survive a round trip.');
}
public function testIsHit()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
}
public function testIsHitDeferred()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->saveDeferred($item);
// Test accessing the value before it is committed
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
$this->cache->commit();
$item = $this->cache->getItem('key');
$this->assertTrue($item->isHit());
}
public function testSaveDeferredWhenChangingValues()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->saveDeferred($item);
$item = $this->cache->getItem('key');
$item->set('new value');
$item = $this->cache->getItem('key');
$this->assertEquals('value', $item->get(), 'Items that is put in the deferred queue should not get their values changed');
$this->cache->commit();
$item = $this->cache->getItem('key');
$this->assertEquals('value', $item->get(), 'Items that is put in the deferred queue should not get their values changed');
}
public function testSaveDeferredOverwrite()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$this->cache->saveDeferred($item);
$item = $this->cache->getItem('key');
$item->set('new value');
$this->cache->saveDeferred($item);
$item = $this->cache->getItem('key');
$this->assertEquals('new value', $item->get());
$this->cache->commit();
$item = $this->cache->getItem('key');
$this->assertEquals('new value', $item->get());
}
public function testSavingObject()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set(new \DateTime());
$this->cache->save($item);
$item = $this->cache->getItem('key');
$value = $item->get();
$this->assertInstanceOf('DateTime', $value, 'You must be able to store objects in cache.');
}
/**
* @medium
*/
public function testHasItemReturnsFalseWhenDeferredItemIsExpired()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key');
$item->set('value');
$item->expiresAfter(2);
$this->cache->saveDeferred($item);
sleep(3);
$this->assertFalse($this->cache->hasItem('key'));
}
}
integration-tests-0.17.0/src/HierarchicalCachePoolTest.php 0000664 0000000 0000000 00000011274 13750251207 0023565 0 ustar 00root root 0000000 0000000 , Tobias Nyholm
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Cache\IntegrationTests;
use PHPUnit\Framework\TestCase;
use Psr\Cache\CacheItemPoolInterface;
/**
* @author Tobias Nyholm
*/
abstract class HierarchicalCachePoolTest extends TestCase
{
/**
* @type array with functionName => reason.
*/
protected $skippedTests = [];
/**
* @type CacheItemPoolInterface
*/
protected $cache;
/**
* @return CacheItemPoolInterface that is used in the tests
*/
abstract public function createCachePool();
/**
* @before
*/
public function setupService()
{
$this->cache = $this->createCachePool();
}
/**
* @after
*/
public function tearDownService()
{
if ($this->cache !== null) {
$this->cache->clear();
}
}
public function testBasicUsage()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$user = 4711;
for ($i = 0; $i < 10; $i++) {
$item = $this->cache->getItem(sprintf('|users|%d|followers|%d|likes', $user, $i));
$item->set('Justin Bieber');
$this->cache->save($item);
}
$this->assertTrue($this->cache->hasItem('|users|4711|followers|4|likes'));
$this->cache->deleteItem('|users|4711|followers');
$this->assertFalse($this->cache->hasItem('|users|4711|followers|4|likes'));
}
public function testChain()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('|aaa|bbb|ccc|ddd');
$item->set('value');
$this->cache->save($item);
$item = $this->cache->getItem('|aaa|bbb|ccc|xxx');
$item->set('value');
$this->cache->save($item);
$item = $this->cache->getItem('|aaa|bbb|zzz|ddd');
$item->set('value');
$this->cache->save($item);
$this->assertTrue($this->cache->hasItem('|aaa|bbb|ccc|ddd'));
$this->assertTrue($this->cache->hasItem('|aaa|bbb|ccc|xxx'));
$this->assertTrue($this->cache->hasItem('|aaa|bbb|zzz|ddd'));
$this->assertFalse($this->cache->hasItem('|aaa|bbb|ccc'));
$this->assertFalse($this->cache->hasItem('|aaa|bbb|zzz'));
$this->assertFalse($this->cache->hasItem('|aaa|bbb'));
$this->assertFalse($this->cache->hasItem('|aaa'));
$this->assertFalse($this->cache->hasItem('|'));
// This is a different thing
$this->cache->deleteItem('|aaa|bbb|cc');
$this->assertTrue($this->cache->hasItem('|aaa|bbb|ccc|ddd'));
$this->assertTrue($this->cache->hasItem('|aaa|bbb|ccc|xxx'));
$this->assertTrue($this->cache->hasItem('|aaa|bbb|zzz|ddd'));
$this->cache->deleteItem('|aaa|bbb|ccc');
$this->assertFalse($this->cache->hasItem('|aaa|bbb|ccc|ddd'));
$this->assertFalse($this->cache->hasItem('|aaa|bbb|ccc|xxx'));
$this->assertTrue($this->cache->hasItem('|aaa|bbb|zzz|ddd'));
$this->cache->deleteItem('|aaa');
$this->assertFalse($this->cache->hasItem('|aaa|bbb|zzz|ddd'));
}
public function testRemoval()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('foo');
$item->set('value');
$this->cache->save($item);
$item = $this->cache->getItem('|aaa|bbb');
$item->set('value');
$this->cache->save($item);
$this->cache->deleteItem('|');
$this->assertFalse($this->cache->hasItem('|aaa|bbb'), 'Hierarchy items should be removed when deleting root');
$this->assertTrue($this->cache->hasItem('foo'), 'All cache should not be cleared when deleting root');
}
public function testRemovalWhenDeferred()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('|aaa|bbb');
$item->set('value');
$this->cache->saveDeferred($item);
$this->cache->deleteItem('|');
$this->assertFalse($this->cache->hasItem('|aaa|bbb'), 'Deferred hierarchy items should be removed');
$this->cache->commit();
$this->assertFalse($this->cache->hasItem('|aaa|bbb'), 'Deferred hierarchy items should be removed');
}
}
integration-tests-0.17.0/src/SimpleCacheTest.php 0000664 0000000 0000000 00000057527 13750251207 0021621 0 ustar 00root root 0000000 0000000 , Tobias Nyholm
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Cache\IntegrationTests;
use PHPUnit\Framework\TestCase;
use Psr\SimpleCache\CacheInterface;
abstract class SimpleCacheTest extends TestCase
{
/**
* @type array with functionName => reason.
*/
protected $skippedTests = [];
/**
* @type CacheInterface
*/
protected $cache;
/**
* @return CacheInterface that is used in the tests
*/
abstract public function createSimpleCache();
/**
* Advance time perceived by the cache for the purposes of testing TTL.
*
* The default implementation sleeps for the specified duration,
* but subclasses are encouraged to override this,
* adjusting a mocked time possibly set up in {@link createSimpleCache()},
* to speed up the tests.
*
* @param int $seconds
*/
public function advanceTime($seconds)
{
sleep($seconds);
}
/**
* @before
*/
public function setupService()
{
$this->cache = $this->createSimpleCache();
}
/**
* @after
*/
public function tearDownService()
{
if ($this->cache !== null) {
$this->cache->clear();
}
}
/**
* Data provider for invalid cache keys.
*
* @return array
*/
public static function invalidKeys()
{
return array_merge(
self::invalidArrayKeys(),
[
[2],
]
);
}
/**
* Data provider for invalid array keys.
*
* @return array
*/
public static function invalidArrayKeys()
{
return [
[''],
[true],
[false],
[null],
[2.5],
['{str'],
['rand{'],
['rand{str'],
['rand}str'],
['rand(str'],
['rand)str'],
['rand/str'],
['rand\\str'],
['rand@str'],
['rand:str'],
[new \stdClass()],
[['array']],
];
}
/**
* @return array
*/
public static function invalidTtl()
{
return [
[''],
[true],
[false],
['abc'],
[2.5],
[' 1'], // can be casted to a int
['12foo'], // can be casted to a int
['025'], // can be interpreted as hex
[new \stdClass()],
[['array']],
];
}
/**
* Data provider for valid keys.
*
* @return array
*/
public static function validKeys()
{
return [
['AbC19_.'],
['1234567890123456789012345678901234567890123456789012345678901234'],
];
}
/**
* Data provider for valid data to store.
*
* @return array
*/
public static function validData()
{
return [
['AbC19_.'],
[4711],
[47.11],
[true],
[null],
[['key' => 'value']],
[new \stdClass()],
];
}
public function testSet()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$result = $this->cache->set('key', 'value');
$this->assertTrue($result, 'set() must return true if success');
$this->assertEquals('value', $this->cache->get('key'));
}
/**
* @medium
*/
public function testSetTtl()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$result = $this->cache->set('key1', 'value', 2);
$this->assertTrue($result, 'set() must return true if success');
$this->assertEquals('value', $this->cache->get('key1'));
$this->cache->set('key2', 'value', new \DateInterval('PT2S'));
$this->assertEquals('value', $this->cache->get('key2'));
$this->advanceTime(3);
$this->assertNull($this->cache->get('key1'), 'Value must expire after ttl.');
$this->assertNull($this->cache->get('key2'), 'Value must expire after ttl.');
}
public function testSetExpiredTtl()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key0', 'value');
$this->cache->set('key0', 'value', 0);
$this->assertNull($this->cache->get('key0'));
$this->assertFalse($this->cache->has('key0'));
$this->cache->set('key1', 'value', -1);
$this->assertNull($this->cache->get('key1'));
$this->assertFalse($this->cache->has('key1'));
}
public function testGet()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->assertNull($this->cache->get('key'));
$this->assertEquals('foo', $this->cache->get('key', 'foo'));
$this->cache->set('key', 'value');
$this->assertEquals('value', $this->cache->get('key', 'foo'));
}
public function testDelete()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->assertTrue($this->cache->delete('key'), 'Deleting a value that does not exist should return true');
$this->cache->set('key', 'value');
$this->assertTrue($this->cache->delete('key'), 'Delete must return true on success');
$this->assertNull($this->cache->get('key'), 'Values must be deleted on delete()');
}
public function testClear()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->assertTrue($this->cache->clear(), 'Clearing an empty cache should return true');
$this->cache->set('key', 'value');
$this->assertTrue($this->cache->clear(), 'Delete must return true on success');
$this->assertNull($this->cache->get('key'), 'Values must be deleted on clear()');
}
public function testSetMultiple()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$result = $this->cache->setMultiple(['key0' => 'value0', 'key1' => 'value1']);
$this->assertTrue($result, 'setMultiple() must return true if success');
$this->assertEquals('value0', $this->cache->get('key0'));
$this->assertEquals('value1', $this->cache->get('key1'));
}
public function testSetMultipleWithIntegerArrayKey()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$result = $this->cache->setMultiple(['0' => 'value0']);
$this->assertTrue($result, 'setMultiple() must return true if success');
$this->assertEquals('value0', $this->cache->get('0'));
}
/**
* @medium
*/
public function testSetMultipleTtl()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->setMultiple(['key2' => 'value2', 'key3' => 'value3'], 2);
$this->assertEquals('value2', $this->cache->get('key2'));
$this->assertEquals('value3', $this->cache->get('key3'));
$this->cache->setMultiple(['key4' => 'value4'], new \DateInterval('PT2S'));
$this->assertEquals('value4', $this->cache->get('key4'));
$this->advanceTime(3);
$this->assertNull($this->cache->get('key2'), 'Value must expire after ttl.');
$this->assertNull($this->cache->get('key3'), 'Value must expire after ttl.');
$this->assertNull($this->cache->get('key4'), 'Value must expire after ttl.');
}
public function testSetMultipleExpiredTtl()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->setMultiple(['key0' => 'value0', 'key1' => 'value1'], 0);
$this->assertNull($this->cache->get('key0'));
$this->assertNull($this->cache->get('key1'));
}
public function testSetMultipleWithGenerator()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$gen = function () {
yield 'key0' => 'value0';
yield 'key1' => 'value1';
};
$this->cache->setMultiple($gen());
$this->assertEquals('value0', $this->cache->get('key0'));
$this->assertEquals('value1', $this->cache->get('key1'));
}
public function testGetMultiple()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$result = $this->cache->getMultiple(['key0', 'key1']);
$keys = [];
foreach ($result as $i => $r) {
$keys[] = $i;
$this->assertNull($r);
}
sort($keys);
$this->assertSame(['key0', 'key1'], $keys);
$this->cache->set('key3', 'value');
$result = $this->cache->getMultiple(['key2', 'key3', 'key4'], 'foo');
$keys = [];
foreach ($result as $key => $r) {
$keys[] = $key;
if ($key === 'key3') {
$this->assertEquals('value', $r);
} else {
$this->assertEquals('foo', $r);
}
}
sort($keys);
$this->assertSame(['key2', 'key3', 'key4'], $keys);
}
public function testGetMultipleWithGenerator()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$gen = function () {
yield 1 => 'key0';
yield 1 => 'key1';
};
$this->cache->set('key0', 'value0');
$result = $this->cache->getMultiple($gen());
$keys = [];
foreach ($result as $key => $r) {
$keys[] = $key;
if ($key === 'key0') {
$this->assertEquals('value0', $r);
} elseif ($key === 'key1') {
$this->assertNull($r);
} else {
$this->assertFalse(true, 'This should not happend');
}
}
sort($keys);
$this->assertSame(['key0', 'key1'], $keys);
$this->assertEquals('value0', $this->cache->get('key0'));
$this->assertNull($this->cache->get('key1'));
}
public function testDeleteMultiple()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->assertTrue($this->cache->deleteMultiple([]), 'Deleting a empty array should return true');
$this->assertTrue($this->cache->deleteMultiple(['key']), 'Deleting a value that does not exist should return true');
$this->cache->set('key0', 'value0');
$this->cache->set('key1', 'value1');
$this->assertTrue($this->cache->deleteMultiple(['key0', 'key1']), 'Delete must return true on success');
$this->assertNull($this->cache->get('key0'), 'Values must be deleted on deleteMultiple()');
$this->assertNull($this->cache->get('key1'), 'Values must be deleted on deleteMultiple()');
}
public function testDeleteMultipleGenerator()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$gen = function () {
yield 1 => 'key0';
yield 1 => 'key1';
};
$this->cache->set('key0', 'value0');
$this->assertTrue($this->cache->deleteMultiple($gen()), 'Deleting a generator should return true');
$this->assertNull($this->cache->get('key0'), 'Values must be deleted on deleteMultiple()');
$this->assertNull($this->cache->get('key1'), 'Values must be deleted on deleteMultiple()');
}
public function testHas()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->assertFalse($this->cache->has('key0'));
$this->cache->set('key0', 'value0');
$this->assertTrue($this->cache->has('key0'));
}
public function testBasicUsageWithLongKey()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$key = str_repeat('a', 300);
$this->assertFalse($this->cache->has($key));
$this->assertTrue($this->cache->set($key, 'value'));
$this->assertTrue($this->cache->has($key));
$this->assertSame('value', $this->cache->get($key));
$this->assertTrue($this->cache->delete($key));
$this->assertFalse($this->cache->has($key));
}
/**
* @dataProvider invalidKeys
*/
public function testGetInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->get($key);
}
/**
* @dataProvider invalidKeys
*/
public function testGetMultipleInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$result = $this->cache->getMultiple(['key1', $key, 'key2']);
}
public function testGetMultipleNoIterable()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$result = $this->cache->getMultiple('key');
}
/**
* @dataProvider invalidKeys
*/
public function testSetInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->set($key, 'foobar');
}
/**
* @dataProvider invalidArrayKeys
*/
public function testSetMultipleInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$values = function () use ($key) {
yield 'key1' => 'foo';
yield $key => 'bar';
yield 'key2' => 'baz';
};
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->setMultiple($values());
}
public function testSetMultipleNoIterable()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->setMultiple('key');
}
/**
* @dataProvider invalidKeys
*/
public function testHasInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->has($key);
}
/**
* @dataProvider invalidKeys
*/
public function testDeleteInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->delete($key);
}
/**
* @dataProvider invalidKeys
*/
public function testDeleteMultipleInvalidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->deleteMultiple(['key1', $key, 'key2']);
}
public function testDeleteMultipleNoIterable()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->deleteMultiple('key');
}
/**
* @dataProvider invalidTtl
*/
public function testSetInvalidTtl($ttl)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->set('key', 'value', $ttl);
}
/**
* @dataProvider invalidTtl
*/
public function testSetMultipleInvalidTtl($ttl)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->expectException('Psr\SimpleCache\InvalidArgumentException');
$this->cache->setMultiple(['key' => 'value'], $ttl);
}
public function testNullOverwrite()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key', 5);
$this->cache->set('key', null);
$this->assertNull($this->cache->get('key'), 'Setting null to a key must overwrite previous value');
}
public function testDataTypeString()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key', '5');
$result = $this->cache->get('key');
$this->assertTrue('5' === $result, 'Wrong data type. If we store a string we must get an string back.');
$this->assertTrue(is_string($result), 'Wrong data type. If we store a string we must get an string back.');
}
public function testDataTypeInteger()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key', 5);
$result = $this->cache->get('key');
$this->assertTrue(5 === $result, 'Wrong data type. If we store an int we must get an int back.');
$this->assertTrue(is_int($result), 'Wrong data type. If we store an int we must get an int back.');
}
public function testDataTypeFloat()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$float = 1.23456789;
$this->cache->set('key', $float);
$result = $this->cache->get('key');
$this->assertTrue(is_float($result), 'Wrong data type. If we store float we must get an float back.');
$this->assertEquals($float, $result);
}
public function testDataTypeBoolean()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key', false);
$result = $this->cache->get('key');
$this->assertTrue(is_bool($result), 'Wrong data type. If we store boolean we must get an boolean back.');
$this->assertFalse($result);
$this->assertTrue($this->cache->has('key'), 'has() should return true when true are stored. ');
}
public function testDataTypeArray()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$array = ['a' => 'foo', 2 => 'bar'];
$this->cache->set('key', $array);
$result = $this->cache->get('key');
$this->assertTrue(is_array($result), 'Wrong data type. If we store array we must get an array back.');
$this->assertEquals($array, $result);
}
public function testDataTypeObject()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$object = new \stdClass();
$object->a = 'foo';
$this->cache->set('key', $object);
$result = $this->cache->get('key');
$this->assertTrue(is_object($result), 'Wrong data type. If we store object we must get an object back.');
$this->assertEquals($object, $result);
}
public function testBinaryData()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$data = '';
for ($i = 0; $i < 256; $i++) {
$data .= chr($i);
}
$array = ['a' => 'foo', 2 => 'bar'];
$this->cache->set('key', $data);
$result = $this->cache->get('key');
$this->assertTrue($data === $result, 'Binary data must survive a round trip.');
}
/**
* @dataProvider validKeys
*/
public function testSetValidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set($key, 'foobar');
$this->assertEquals('foobar', $this->cache->get($key));
}
/**
* @dataProvider validKeys
*/
public function testSetMultipleValidKeys($key)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->setMultiple([$key => 'foobar']);
$result = $this->cache->getMultiple([$key]);
$keys = [];
foreach ($result as $i => $r) {
$keys[] = $i;
$this->assertEquals($key, $i);
$this->assertEquals('foobar', $r);
}
$this->assertSame([$key], $keys);
}
/**
* @dataProvider validData
*/
public function testSetValidData($data)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->set('key', $data);
$this->assertEquals($data, $this->cache->get('key'));
}
/**
* @dataProvider validData
*/
public function testSetMultipleValidData($data)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->setMultiple(['key' => $data]);
$result = $this->cache->getMultiple(['key']);
$keys = [];
foreach ($result as $i => $r) {
$keys[] = $i;
$this->assertEquals($data, $r);
}
$this->assertSame(['key'], $keys);
}
public function testObjectAsDefaultValue()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$obj = new \stdClass();
$obj->foo = 'value';
$this->assertEquals($obj, $this->cache->get('key', $obj));
}
public function testObjectDoesNotChangeInCache()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$obj = new \stdClass();
$obj->foo = 'value';
$this->cache->set('key', $obj);
$obj->foo = 'changed';
$cacheObject = $this->cache->get('key');
$this->assertEquals('value', $cacheObject->foo, 'Object in cache should not have their values changed.');
}
}
integration-tests-0.17.0/src/TaggableCachePoolTest.php 0000664 0000000 0000000 00000022037 13750251207 0022714 0 ustar 00root root 0000000 0000000 , Tobias Nyholm
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace Cache\IntegrationTests;
use Cache\TagInterop\TaggableCacheItemPoolInterface;
use PHPUnit\Framework\TestCase;
/**
* @author Tobias Nyholm
*/
abstract class TaggableCachePoolTest extends TestCase
{
/**
* @type array with functionName => reason.
*/
protected $skippedTests = [];
/**
* @type TaggableCacheItemPoolInterface
*/
protected $cache;
/**
* @return TaggableCacheItemPoolInterface that is used in the tests
*/
abstract public function createCachePool();
/**
* @before
*/
public function setupService()
{
$this->cache = $this->createCachePool();
}
/**
* @after
*/
public function tearDownService()
{
if ($this->cache !== null) {
$this->cache->clear();
}
}
public function invalidKeys()
{
return CachePoolTest::invalidKeys();
}
public function testMultipleTags()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$this->cache->save($this->cache->getItem('key1')->set('value')->setTags(['tag1', 'tag2']));
$this->cache->save($this->cache->getItem('key2')->set('value')->setTags(['tag1', 'tag3']));
$this->cache->save($this->cache->getItem('key3')->set('value')->setTags(['tag2', 'tag3']));
$this->cache->save($this->cache->getItem('key4')->set('value')->setTags(['tag4', 'tag3']));
$this->cache->invalidateTags(['tag1']);
$this->assertFalse($this->cache->hasItem('key1'));
$this->assertFalse($this->cache->hasItem('key2'));
$this->assertTrue($this->cache->hasItem('key3'));
$this->assertTrue($this->cache->hasItem('key4'));
$this->cache->invalidateTags(['tag2']);
$this->assertFalse($this->cache->hasItem('key1'));
$this->assertFalse($this->cache->hasItem('key2'));
$this->assertFalse($this->cache->hasItem('key3'));
$this->assertTrue($this->cache->hasItem('key4'));
}
public function testPreviousTag()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$tags = $item->getPreviousTags();
$this->assertTrue(is_array($tags));
$this->assertCount(0, $tags);
$item->setTags(['tag0']);
$this->assertCount(0, $item->getPreviousTags());
$this->cache->save($item);
$this->assertCount(0, $item->getPreviousTags());
$item = $this->cache->getItem('key');
$this->assertCount(1, $item->getPreviousTags());
}
public function testPreviousTagDeferred()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag0']);
$this->assertCount(0, $item->getPreviousTags());
$this->cache->saveDeferred($item);
$this->assertCount(0, $item->getPreviousTags());
$item = $this->cache->getItem('key');
$this->assertCount(1, $item->getPreviousTags());
}
public function testTagAccessorWithEmptyTag()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$this->expectException('Psr\Cache\InvalidArgumentException');
$item->setTags(['']);
}
/**
* @dataProvider invalidKeys
*/
public function testTagAccessorWithInvalidTag($tag)
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$this->expectException('Psr\Cache\InvalidArgumentException');
$item->setTags([$tag]);
}
public function testTagAccessorDuplicateTags()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag', 'tag', 'tag']);
$this->cache->save($item);
$item = $this->cache->getItem('key');
$this->assertCount(1, $item->getPreviousTags());
}
/**
* The tag must be removed whenever we remove an item. If not, when creating a new item
* with the same key will get the same tags.
*/
public function testRemoveTagWhenItemIsRemoved()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag1']);
// Save the item and then delete it
$this->cache->save($item);
$this->cache->deleteItem('key');
// Create a new item (same key) (no tags)
$item = $this->cache->getItem('key')->set('value');
$this->cache->save($item);
// Clear the tag, The new item should not be cleared
$this->cache->invalidateTags(['tag1']);
$this->assertTrue($this->cache->hasItem('key'), 'Item key should be removed from the tag list when the item is removed');
}
public function testClearPool()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag1']);
$this->cache->save($item);
// Clear the pool
$this->cache->clear();
// Create a new item (no tags)
$item = $this->cache->getItem('key')->set('value');
$this->cache->save($item);
$this->cache->invalidateTags(['tag1']);
$this->assertTrue($this->cache->hasItem('key'), 'Tags should be removed when the pool was cleared.');
}
public function testInvalidateTag()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag1', 'tag2']);
$this->cache->save($item);
$item = $this->cache->getItem('key2')->set('value');
$item->setTags(['tag1']);
$this->cache->save($item);
$this->cache->invalidateTag('tag2');
$this->assertFalse($this->cache->hasItem('key'), 'Item should be cleared when tag is invalidated');
$this->assertTrue($this->cache->hasItem('key2'), 'Item should be cleared when tag is invalidated');
// Create a new item (no tags)
$item = $this->cache->getItem('key')->set('value');
$this->cache->save($item);
$this->cache->invalidateTags(['tag2']);
$this->assertTrue($this->cache->hasItem('key'), 'Item key list should be removed when clearing the tags');
$this->cache->invalidateTags(['tag1']);
$this->assertTrue($this->cache->hasItem('key'), 'Item key list should be removed when clearing the tags');
}
public function testInvalidateTags()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$item = $this->cache->getItem('key')->set('value');
$item->setTags(['tag1', 'tag2']);
$this->cache->save($item);
$item = $this->cache->getItem('key2')->set('value');
$item->setTags(['tag1']);
$this->cache->save($item);
$this->cache->invalidateTags(['tag1', 'tag2']);
$this->assertFalse($this->cache->hasItem('key'), 'Item should be cleared when tag is invalidated');
$this->assertFalse($this->cache->hasItem('key2'), 'Item should be cleared when tag is invalidated');
// Create a new item (no tags)
$item = $this->cache->getItem('key')->set('value');
$this->cache->save($item);
$this->cache->invalidateTags(['tag1']);
$this->assertTrue($this->cache->hasItem('key'), 'Item k list should be removed when clearing the tags');
}
/**
* When an item is overwritten we need to clear tags for original item.
*/
public function testTagsAreCleanedOnSave()
{
if (isset($this->skippedTests[__FUNCTION__])) {
$this->markTestSkipped($this->skippedTests[__FUNCTION__]);
}
$pool = $this->cache;
$i = $pool->getItem('key')->set('value');
$pool->save($i->setTags(['foo']));
$i = $pool->getItem('key');
$pool->save($i->setTags(['bar']));
$pool->invalidateTags(['foo']);
$this->assertTrue($pool->getItem('key')->isHit());
}
}
integration-tests-0.17.0/tests/ 0000775 0000000 0000000 00000000000 13750251207 0016426 5 ustar 00root root 0000000 0000000 integration-tests-0.17.0/tests/StashTest.php 0000664 0000000 0000000 00000001363 13750251207 0021064 0 ustar 00root root 0000000 0000000 , Tobias Nyholm
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
use Cache\IntegrationTests\CachePoolTest as BaseTest;
use Stash\Driver\Redis;
use Stash\Pool;
class StashTest extends BaseTest
{
private $client = null;
public function createCachePool()
{
return new Pool($this->getClient());
}
private function getClient()
{
if ($this->client === null) {
$this->client = new Redis(['servers' => [['server' => '127.0.0.1', 'port' => '6379']]]);
}
return $this->client;
}
}