| <?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 Apache\Ignite\Cache\CacheKeyConfiguration; |
| use Apache\Ignite\Cache\QueryField; |
| use Apache\Ignite\Cache\QueryEntity; |
| use Apache\Ignite\Cache\QueryIndex; |
| use PHPUnit\Framework\TestCase; |
| use Apache\Ignite\Cache\CacheInterface; |
| use Apache\Ignite\Cache\CacheConfiguration; |
| use Apache\Ignite\Exception\OperationException; |
| use Apache\Ignite\Exception\ClientException; |
| |
| final class CacheTestCase extends TestCase |
| { |
| const CACHE_NAME = '__php_test_cache'; |
| const CACHE_NAME2 = '__php_test_cache2'; |
| const CACHE_NAME3 = '__php_test_cache3'; |
| const CACHE_NAME4 = '__php_test_cache4'; |
| |
| public static function setUpBeforeClass(): void |
| { |
| TestingHelper::init(); |
| self::cleanUp(); |
| } |
| |
| public static function tearDownAfterClass(): void |
| { |
| self::cleanUp(); |
| TestingHelper::cleanUp(); |
| } |
| |
| public function testCreateCache(): void |
| { |
| $client = TestingHelper::$client; |
| $cache = $client->getCache(self::CACHE_NAME); |
| $this->checkCache($cache, false); |
| $cache = $client->createCache(self::CACHE_NAME); |
| $this->checkCache($cache, true); |
| $cache = $client->getCache(self::CACHE_NAME); |
| $this->checkCache($cache, true); |
| $client->destroyCache(self::CACHE_NAME); |
| } |
| |
| public function testCreateCacheTwice(): void |
| { |
| $client = TestingHelper::$client; |
| try { |
| $client->getOrCreateCache(self::CACHE_NAME); |
| $this->expectException(OperationException::class); |
| $client->createCache(self::CACHE_NAME); |
| } finally { |
| $client->destroyCache(self::CACHE_NAME); |
| } |
| } |
| |
| public function testGetOrCreateCache(): void |
| { |
| $client = TestingHelper::$client; |
| $cache = $client->getCache(self::CACHE_NAME); |
| $this->checkCache($cache, false); |
| $cache = $client->getOrCreateCache(self::CACHE_NAME); |
| $this->checkCache($cache, true); |
| $cache = $client->getCache(self::CACHE_NAME); |
| $this->checkCache($cache, true); |
| $client->destroyCache(self::CACHE_NAME); |
| } |
| |
| public function testGetCacheNames(): void |
| { |
| $client = TestingHelper::$client; |
| $client->getOrCreateCache(self::CACHE_NAME); |
| $client->getOrCreateCache(self::CACHE_NAME2); |
| $cacheNames = $client->cacheNames(); |
| $this->assertContains(self::CACHE_NAME, $cacheNames); |
| $this->assertContains(self::CACHE_NAME2, $cacheNames); |
| $client->destroyCache(self::CACHE_NAME); |
| $client->destroyCache(self::CACHE_NAME2); |
| } |
| |
| public function testDestroyCache(): void |
| { |
| $client = TestingHelper::$client; |
| $client->getOrCreateCache(self::CACHE_NAME); |
| $client->destroyCache(self::CACHE_NAME); |
| |
| $this->expectException(OperationException::class); |
| $client->destroyCache(self::CACHE_NAME); |
| } |
| |
| public function testCreateCacheWithConfiguration(): void |
| { |
| $client = TestingHelper::$client; |
| $cacheCfg = (new CacheConfiguration())-> |
| setQueryEntities( |
| (new QueryEntity())-> |
| setKeyTypeName('INT')-> |
| setValueTypeName('Person')-> |
| setTableName('Person')-> |
| setKeyFieldName('id')-> |
| setValueFieldName('salary')-> |
| setFields( |
| (new QueryField('id', 'INT'))->setIsKeyField(true), |
| (new QueryField('firstName', 'VARCHAR'))->setIsNotNull(true), |
| (new QueryField('lastName', 'VARCHAR'))->setDefaultValue('lastName'), |
| (new QueryField('salary', 'DOUBLE'))->setPrecision(10)->setScale(10))-> |
| setAliases(['id' => 'id', 'firstName' => 'firstName'])-> |
| setIndexes( |
| (new QueryIndex('id_idx', QueryIndex::TYPE_SORTED))-> |
| setName('id_idx')-> |
| setType(QueryIndex::TYPE_SORTED)-> |
| setInlineSize(10)-> |
| setFields(['id' => true, 'firstName' => false])))-> |
| setKeyConfigurations((new CacheKeyConfiguration('Person', 'Person'))-> |
| setTypeName('Person')-> |
| setAffinityKeyFieldName('Person')); |
| |
| $cache = $client->createCache(self::CACHE_NAME3, $cacheCfg); |
| $cfg = $client->getCacheConfiguration(self::CACHE_NAME3); |
| $client->destroyCache(self::CACHE_NAME3); |
| $keyConfig = $cfg->getKeyConfigurations()[0]; |
| $queryEntity = $cfg->getQueryEntities()[0]; |
| $queryField = $queryEntity->getFields()[0]; |
| $queryIndex = $queryEntity->getIndexes()[0]; |
| $cfg-> |
| setName($cfg->getName())-> |
| setAtomicityMode($cfg->getAtomicityMode())-> |
| setBackups($cfg->getBackups())-> |
| setCacheMode($cfg->getCacheMode())-> |
| setCopyOnRead($cfg->getCopyOnRead())-> |
| setDataRegionName($cfg->getDataRegionName())-> |
| setEagerTtl($cfg->getEagerTtl())-> |
| setStatisticsEnabled($cfg->getStatisticsEnabled())-> |
| setGroupName($cfg->getGroupName())-> |
| setDefaultLockTimeout($cfg->getDefaultLockTimeout())-> |
| setMaxConcurrentAsyncOperations($cfg->getMaxConcurrentAsyncOperations())-> |
| setMaxQueryIterators($cfg->getMaxQueryIterators())-> |
| setIsOnheapCacheEnabled($cfg->getIsOnheapCacheEnabled())-> |
| setPartitionLossPolicy($cfg->getPartitionLossPolicy())-> |
| setQueryDetailMetricsSize($cfg->getQueryDetailMetricsSize())-> |
| setQueryParallelism($cfg->getQueryParallelism())-> |
| setReadFromBackup($cfg->getReadFromBackup())-> |
| setRebalanceBatchSize($cfg->getRebalanceBatchSize())-> |
| setRebalanceBatchesPrefetchCount($cfg->getRebalanceBatchesPrefetchCount())-> |
| setRebalanceDelay($cfg->getRebalanceDelay())-> |
| setRebalanceMode($cfg->getRebalanceMode())-> |
| setRebalanceOrder($cfg->getRebalanceOrder())-> |
| setRebalanceThrottle($cfg->getRebalanceThrottle())-> |
| setRebalanceTimeout($cfg->getRebalanceTimeout())-> |
| setSqlEscapeAll($cfg->getSqlEscapeAll())-> |
| setSqlIndexInlineMaxSize($cfg->getSqlIndexInlineMaxSize())-> |
| setSqlSchema($cfg->getSqlSchema())-> |
| setWriteSynchronizationMode($cfg->getWriteSynchronizationMode())-> |
| setKeyConfigurations((new CacheKeyConfiguration())-> |
| setTypeName($keyConfig->getTypeName())-> |
| setAffinityKeyFieldName($keyConfig->getAffinityKeyFieldName()))-> |
| setQueryEntities((new QueryEntity())-> |
| setKeyTypeName($queryEntity->getKeyTypeName())-> |
| setValueTypeName($queryEntity->getValueTypeName())-> |
| setTableName($queryEntity->getTableName())-> |
| setKeyFieldName($queryEntity->getKeyFieldName())-> |
| setValueFieldName($queryEntity->getValueFieldName())-> |
| setFields( |
| (new QueryField())-> |
| setName($queryField->getName())-> |
| setTypeName($queryField->getTypeName())-> |
| setIsKeyField($queryField->getIsKeyField())-> |
| setIsNotNull($queryField->getIsNotNull())-> |
| setDefaultValue($queryField->getDefaultValue())-> |
| setPrecision($queryField->getPrecision())-> |
| setScale($queryField->getScale()), |
| $queryEntity->getFields()[1], |
| $queryEntity->getFields()[2], |
| $queryEntity->getFields()[3])-> |
| setAliases($queryEntity->getAliases())-> |
| setIndexes((new QueryIndex())-> |
| setName($queryIndex->getName())-> |
| setType($queryIndex->getType())-> |
| setInlineSize($queryIndex->getInlineSize())-> |
| setFields($queryIndex->getFields()))); |
| $cache = $client->getOrCreateCache(self::CACHE_NAME4, $cfg); |
| $cfg2 = $client->getCacheConfiguration(self::CACHE_NAME4); |
| $client->destroyCache(self::CACHE_NAME4); |
| $this->assertTrue(true); |
| } |
| |
| public function testCreateCacheWithWrongArgs(): void |
| { |
| $client = TestingHelper::$client; |
| $this->expectException(ClientException::class); |
| $client->createCache(''); |
| } |
| |
| public function testGetOrCreateCacheWithWrongArgs(): void |
| { |
| $client = TestingHelper::$client; |
| $this->expectException(ClientException::class); |
| $client->getOrCreateCache(''); |
| } |
| |
| public function testGetCacheWithWrongArgs(): void |
| { |
| $client = TestingHelper::$client; |
| $this->expectException(ClientException::class); |
| $client->getCache(''); |
| } |
| |
| private function checkCache(CacheInterface $cache, bool $cacheExists): void |
| { |
| if (!$cacheExists) { |
| $this->expectException(OperationException::class); |
| } |
| $cache->put(0, 0); |
| } |
| |
| private static function cleanUp(): void |
| { |
| TestingHelper::destroyCache(self::CACHE_NAME); |
| TestingHelper::destroyCache(self::CACHE_NAME2); |
| TestingHelper::destroyCache(self::CACHE_NAME3); |
| TestingHelper::destroyCache(self::CACHE_NAME4); |
| } |
| } |