| <?php |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| namespace Apache\Ignite\Tests; |
| |
| use PHPUnit\Framework\TestCase; |
| use Apache\Ignite\Exception\ClientException; |
| use Apache\Ignite\Cache\CacheEntry; |
| use Apache\Ignite\Cache\CacheConfiguration; |
| use Apache\Ignite\Cache\CacheInterface; |
| |
| final class CacheKeyValueOpsTestCase extends TestCase |
| { |
| const CACHE_NAME = '__php_test_cache'; |
| |
| public static function setUpBeforeClass(): void |
| { |
| TestingHelper::init(); |
| self::cleanUp(); |
| TestingHelper::$client->getOrCreateCache(self::CACHE_NAME); |
| } |
| |
| public static function tearDownAfterClass(): void |
| { |
| self::cleanUp(); |
| TestingHelper::cleanUp(); |
| } |
| |
| public function testCacheGet(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->get(1); |
| $this->assertEquals($value, null); |
| $cache->put(1, 2); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function cacheWrongKeys(): array |
| { |
| return array( |
| array(null) |
| ); |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeys |
| */ |
| public function testCacheGetWrongArgs($cacheKey): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->get($cacheKey); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetAll(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| for ($i = 0; $i < 5; $i++) { |
| $cache->put($i, $i * 2); |
| } |
| $entries = $cache->getAll([3, 4, 5, 6, 7]); |
| $this->assertCount(2, $entries); |
| foreach ($entries as $entry) { |
| $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4); |
| $this->assertEquals($entry->getValue(), $entry->getKey() * 2); |
| } |
| $entries = $cache->getAll([6, 7, 8]); |
| $this->assertCount(0, $entries); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function cacheGetAllWrongKeys(): array |
| { |
| return array( |
| array([]) |
| ); |
| } |
| |
| /** |
| * @dataProvider cacheGetAllWrongKeys |
| */ |
| public function testCacheGetAllWrongArgs($keys): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getAll($keys); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCachePut(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->get(1); |
| $this->assertEquals($value, null); |
| $cache->put(1, 2); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| $cache->put(1, 4); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 4); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function cacheWrongKeyValues(): array |
| { |
| return array( |
| array(null, 1), |
| array(1, null), |
| array(null, null) |
| ); |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCachePutWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->put($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCachePutAll(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cacheEntries = array(); |
| for ($i = 0; $i < 5; $i++) { |
| array_push($cacheEntries, new CacheEntry($i, $i * 2)); |
| } |
| $cache->putAll($cacheEntries); |
| $entries = $cache->getAll([3, 4, 5, 6, 7]); |
| $this->assertCount(2, $entries); |
| foreach ($entries as $entry) { |
| $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4); |
| $this->assertEquals($entry->getValue(), $entry->getKey() * 2); |
| } |
| $entries = $cache->getAll([-2, -1, 0, 1, 2, 3, 4, 5, 6, 7]); |
| $this->assertCount(5, $entries); |
| foreach ($entries as $entry) { |
| $this->assertTrue($entry->getKey() >= 0 && $entry->getKey() <= 4); |
| $this->assertEquals($entry->getValue(), $entry->getKey() * 2); |
| } |
| $entries = $cache->getAll([6, 7, 8]); |
| $this->assertCount(0, $entries); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function cachePutAllWrongArgs(): array |
| { |
| return array( |
| array([]), |
| array([new CacheConfiguration]) |
| ); |
| } |
| |
| /** |
| * @dataProvider cachePutAllWrongArgs |
| */ |
| public function testCachePutAllWrongArgs($entries): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->putAll($entries); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testContainsKey(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->containsKey(1); |
| $this->assertFalse($result); |
| $cache->put(1, 2); |
| $result = $cache->containsKey(1); |
| $this->assertTrue($result); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeys |
| */ |
| public function testContainsKeyWrongArgs($cacheKey): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->containsKey($cacheKey); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheContainsKeys(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->containsKeys([1, 2, 3]); |
| $this->assertFalse($result); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4)]); |
| $result = $cache->containsKeys([1, 2, 3]); |
| $this->assertFalse($result); |
| $cache->put(3, 6); |
| $result = $cache->containsKeys([1, 2, 3]); |
| $this->assertTrue($result); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheGetAllWrongKeys |
| */ |
| public function testCacheContainsKeysWrongArgs($keys): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->containsKeys($keys); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetAndPut(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->getAndPut(1, 2); |
| $this->assertEquals($value, null); |
| $value = $cache->getAndPut(1, 4); |
| $this->assertEquals($value, 2); |
| $cache->put(1, 6); |
| $value = $cache->getAndPut(1, 8); |
| $this->assertEquals($value, 6); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 8); |
| |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCacheGetAndPutWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getAndPut($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetAndReplace(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->getAndReplace(1, 2); |
| $this->assertEquals($value, null); |
| $cache->put(1, 4); |
| $value = $cache->getAndReplace(1, 6); |
| $this->assertEquals($value, 4); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 6); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCacheGetAndReplaceWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getAndReplace($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetAndRemove(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->getAndRemove(1); |
| $this->assertEquals($value, null); |
| $cache->put(1, 2); |
| $value = $cache->getAndRemove(1); |
| $this->assertEquals($value, 2); |
| $value = $cache->get(1); |
| $this->assertEquals($value, null); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeys |
| */ |
| public function testCacheGetAndRemoveWrongArgs($cacheKey): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getAndRemove($cacheKey); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCachePutIfAbsent(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->putIfAbsent(1, 2); |
| $this->assertTrue($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| $result = $cache->putIfAbsent(1, 4); |
| $this->assertFalse($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCachePutIfAbsentWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->putIfAbsent($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetAndPutIfAbsent(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $value = $cache->getAndPutIfAbsent(1, 2); |
| $this->assertEquals($value, null); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| $value = $cache->getAndPutIfAbsent(1, 4); |
| $this->assertEquals($value, 2); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 2); |
| |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCacheGetAndPutIfAbsentWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getAndPutIfAbsent($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheReplace(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->replace(1, 2); |
| $this->assertFalse($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, null); |
| $cache->put(1, 1); |
| $result = $cache->replace(1, 4); |
| $this->assertTrue($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 4); |
| |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testCacheReplaceWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->replace($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheReplaceIfEquals(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->replaceIfEquals(1, 2, 3); |
| $this->assertFalse($result); |
| $cache->put(1, 4); |
| $result = $cache->replaceIfEquals(1, 2, 3); |
| $this->assertFalse($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 4); |
| $result = $cache->replaceIfEquals(1, 4, 3); |
| $this->assertTrue($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, 3); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function cacheWrongReplaceIfEqualsArgs(): array |
| { |
| return array( |
| array(null, 1, 1), |
| array(null, 1, null), |
| array(1, null, 1), |
| array(1, null, null), |
| array(null, null, null) |
| ); |
| } |
| |
| /** |
| * @dataProvider cacheWrongReplaceIfEqualsArgs |
| */ |
| public function testCacheReplaceIfEqualsWrongArgs($key, $value, $newValue): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->replaceIfEquals($key, $value, $newValue); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheClear(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cache->clear(); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $cache->clear(); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $entries = $cache->getAll([1, 2, 3]); |
| $this->assertCount(0, $entries); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheClearKeys(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cache->clearKeys([1, 2, 3]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $cache->clearKeys([1, 2, 7, 8]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 1); |
| $value = $cache->get(3); |
| $this->assertEquals($value, 6); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheGetAllWrongKeys |
| */ |
| public function testCacheClearKeysWrongArgs($keys): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->clearKeys($keys); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheClearKey(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cache->clearKey(1); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $cache->clearKey(1); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 2); |
| $value = $cache->get(2); |
| $this->assertEquals($value, 4); |
| $value = $cache->get(3); |
| $this->assertEquals($value, 6); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeys |
| */ |
| public function testCacheClearKeyWrongArgs($cacheKey): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->clearKey($cacheKey); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheRemoveKey(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->removeKey(1); |
| $this->assertFalse($result); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $result = $cache->removeKey(1); |
| $this->assertTrue($result); |
| $result = $cache->removeKey(1); |
| $this->assertFalse($result); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 2); |
| $value = $cache->get(2); |
| $this->assertEquals($value, 4); |
| $value = $cache->get(3); |
| $this->assertEquals($value, 6); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeys |
| */ |
| public function testCacheRemoveKeyWrongArgs($cacheKey): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->removeKey($cacheKey); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testRemoveIfEquals(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->removeIfEquals(1, 2); |
| $this->assertFalse($result); |
| $cache->put(1, 4); |
| $result = $cache->removeIfEquals(1, 2); |
| $this->assertFalse($result); |
| $result = $cache->removeIfEquals(1, 4); |
| $this->assertTrue($result); |
| $value = $cache->get(1); |
| $this->assertEquals($value, null); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheWrongKeyValues |
| */ |
| public function testRemoveIfEqualsWrongArgs($key, $value): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->removeIfEquals($key, $value); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheRemoveKeys(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cache->removeKeys([1, 2, 3]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $cache->removeKeys([1, 2, 7, 8]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 1); |
| $value = $cache->get(3); |
| $this->assertEquals($value, 6); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| /** |
| * @dataProvider cacheGetAllWrongKeys |
| */ |
| public function testCacheRemoveKeysWrongArgs($keys): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->removeKeys($keys); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheRemoveAll(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $cache->removeAll(); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $cache->removeAll(); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $entries = $cache->getAll([1, 2, 3]); |
| $this->assertCount(0, $entries); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function testCacheGetSize(): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 0); |
| $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]); |
| $result = $cache->getSize(); |
| $this->assertEquals($result, 3); |
| $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL); |
| $this->assertEquals($result, 3); |
| $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL, CacheInterface::PEEK_MODE_ALL); |
| $this->assertEquals($result, 3); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| public function getSizeWrongArgs(): array |
| { |
| return array( |
| array(-1, -2), |
| array(4, 5, 6, 0) |
| ); |
| } |
| |
| /** |
| * @dataProvider getSizeWrongArgs |
| */ |
| public function testCacheGetSizeWrongArgs($modes): void |
| { |
| $cache = TestingHelper::$client->getCache(self::CACHE_NAME); |
| try { |
| $this->expectException(ClientException::class); |
| $cache->getSize($modes); |
| } finally { |
| $cache->removeAll(); |
| } |
| } |
| |
| private static function cleanUp(): void |
| { |
| TestingHelper::destroyCache(self::CACHE_NAME); |
| } |
| } |