This commit is contained in:
2026-09-15 10:26:34 +08:00
commit ecf36afa56
10493 changed files with 1404888 additions and 0 deletions
@@ -0,0 +1,242 @@
<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);
namespace Magento\GraphQlResolverCache\Model\Plugin\Resolver;
use Magento\Framework\App\Cache\State as CacheState;
use Magento\GraphQl\Service\GraphQlRequest;
use Magento\GraphQlResolverCache\Model\Plugin\Resolver\Cache as CachePlugin;
use Magento\GraphQlResolverCache\Model\Resolver\Result\Cache\IdentityInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\Calculator;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\GenericFactorProviderInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\ResolverIdentityClassProvider;
use Magento\GraphQlResolverCache\Model\Resolver\Result\Type;
use Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver;
use Magento\TestFramework\Helper\Bootstrap;
use Magento\TestFramework\Interception\PluginList;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
/**
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
*/
class CacheTest extends TestCase
{
/**
* @var \Magento\TestFramework\ObjectManager
*/
private $objectManager;
/**
* @var GraphQlRequest
*/
private $graphQlRequest;
/**
* @var CacheState
*/
private $cacheState;
/**
* @var bool
*/
private $origCacheEnabled;
/**
* @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject
*/
private $loggerMock;
/**
* @var Type|\PHPUnit\Framework\MockObject\MockObject
*/
private $graphqlResolverCacheMock;
/**
* @var Type
*/
private $graphQlResolverCache;
/**
* @var GenericFactorProviderInterface|\PHPUnit\Framework\MockObject\MockObject
*/
private $keyFactorMock;
/**
* @inheritdoc
*/
public function setUp(): void
{
$this->objectManager = Bootstrap::getObjectManager();
$this->graphQlRequest = $this->objectManager->create(GraphQlRequest::class);
$this->cacheState = $this->objectManager->get(CacheState::class);
$this->origCacheEnabled = $this->cacheState->isEnabled(Type::TYPE_IDENTIFIER);
if (!$this->origCacheEnabled) {
$this->cacheState->setEnabled(Type::TYPE_IDENTIFIER, true);
$this->cacheState->persist();
}
$this->graphQlResolverCache = $this->objectManager->get(Type::class);
$this->graphQlResolverCache->clean();
}
/**
* @inheritdoc
*/
public function tearDown(): void
{
$this->cacheState->setEnabled(Type::TYPE_IDENTIFIER, $this->origCacheEnabled);
$this->cacheState->persist();
$this->graphQlResolverCache->clean();
parent::tearDown();
}
/**
* @magentoAppArea graphql
*/
public function testCachingSkippedOnKeyCalculationFailure()
{
$this->preconfigureMocks();
$this->configurePlugin();
$this->keyFactorMock->expects($this->any())
->method('getFactorValue')
->willThrowException(new \Exception("Test key factor exception"));
$this->graphqlResolverCacheMock->expects($this->never())
->method('load');
$this->graphqlResolverCacheMock->expects($this->never())
->method('save');
$this->graphQlRequest->send($this->getTestQuery());
}
/**
* @magentoAppArea graphql
*/
public function testCachingNotSkippedWhenKeysOk()
{
$this->preconfigureMocks();
$this->configurePlugin();
$this->loggerMock->expects($this->never())->method('warning');
$this->graphqlResolverCacheMock->expects($this->once())
->method('load')
->willReturn(false);
$this->graphqlResolverCacheMock->expects($this->once())
->method('save');
$this->graphQlRequest->send($this->getTestQuery());
}
/**
* Configure mocks and object manager for test.
*
* @return void
*/
private function preconfigureMocks()
{
$this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
->disableOriginalConstructor()
->onlyMethods(['warning'])
->setMockClassName('CacheLoggerMockForTest')
->getMockForAbstractClass();
$this->graphqlResolverCacheMock = $this->getMockBuilder(Type::class)
->disableOriginalConstructor()
->onlyMethods(['load', 'save'])
->setMockClassName('GraphqlResolverCacheMockForTest')
->getMock();
$this->keyFactorMock = $this->getMockBuilder(GenericFactorProviderInterface::class)
->disableOriginalConstructor()
->onlyMethods(['getFactorValue', 'getFactorName'])
->setMockClassName('TestFailingKeyFactor')
->getMock();
$this->objectManager->addSharedInstance($this->keyFactorMock, 'TestFailingKeyFactor');
$this->objectManager->configure(
[
Calculator::class => [
'arguments' => [
'factorProviders' => [
'test_failing' => 'TestFailingKeyFactor'
]
]
]
]
);
$this->objectManager->configure(
[
\Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\Calculator\Provider::class => [
'arguments' => [
'factorProviders' => [
\Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver::class => [
'test_failing' => 'TestFailingKeyFactor'
]
]
]
]
]
);
$identityProviderMock = $this->getMockBuilder(IdentityInterface::class)
->disableOriginalConstructor()
->onlyMethods(['getIdentities'])
->setMockClassName('TestIdentityProvider')
->getMock();
$identityProviderMock->expects($this->any())
->method('getIdentities')
->willReturn(['test_identity']);
$this->objectManager->addSharedInstance($identityProviderMock, 'TestIdentityProvider');
$this->objectManager->configure(
[
ResolverIdentityClassProvider::class => [
'arguments' => [
'cacheableResolverClassNameIdentityMap' => [
StoreConfigResolver::class => 'TestIdentityProvider'
]
]
]
]
);
}
private function getTestQuery()
{
return <<<QUERY
{
storeConfig {
id,
code,
store_code,
store_name
}
}
QUERY;
}
/**
* Reset plugin for the resolver.
*
* @return void
*/
private function configurePlugin()
{
// need to reset plugins list to inject new plugin with mocks as it is cached at runtime
/** @var PluginList $pluginList */
$pluginList = $this->objectManager->get(PluginList::class);
$pluginList->reset();
$this->objectManager->removeSharedInstance(CachePlugin::class);
$this->objectManager->addSharedInstance(
$this->objectManager->create(CachePlugin::class, [
'logger' => $this->loggerMock,
'graphQlResolverCache' => $this->graphqlResolverCacheMock
]),
CachePlugin::class
);
}
}
@@ -0,0 +1,253 @@
<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);
namespace Magento\GraphQlResolverCache\Model\Resolver\Result\Cache\KeyCalculator;
use Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\CustomerGroup;
use Magento\CustomerGraphQl\Model\Resolver\Customer;
use Magento\CustomerGraphQl\Model\Resolver\CustomerAddresses;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\GraphQl\Query\ResolverInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\Calculator\Provider;
use Magento\StoreGraphQl\CacheIdFactorProviders\CurrencyProvider;
use Magento\StoreGraphQl\CacheIdFactorProviders\StoreProvider;
use Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver;
use Magento\TestFramework\Helper\Bootstrap;
/**
* Test for Graphql Resolver-level cache key provider.
* @magentoAppArea graphql
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
*/
class ProviderTest extends \PHPUnit\Framework\TestCase
{
/**
* @var \Magento\TestFramework\ObjectManager
*/
private $objectManager;
/**
* @var Provider
*/
private $provider;
/**
* Dev docs link
*/
private const DEV_DOCS = "https://developer.adobe.com/commerce/webapi/graphql/develop";
/**
* @inheritdoc
*/
public function setUp(): void
{
$this->objectManager = Bootstrap::getObjectManager();
parent::setUp();
}
/**
* Test that missing config triggers an exception.
*
* @magentoAppArea graphql
*
* @return void
*/
public function testProviderNotConfigured()
{
$this->provider = $this->objectManager->create(Provider::class);
$resolver = $this->getMockBuilder(ResolverInterface::class)
->disableOriginalConstructor()
->getMock();
$this->expectException(\InvalidArgumentException::class);
$resolverClass = get_class($resolver);
$devDocs = self::DEV_DOCS;
$this->expectExceptionMessage(
"GraphQL Resolver Cache key factors are not determined for {$resolverClass} or its parents. " .
"See {$devDocs} for information about configuring cache key factors for a resolver."
);
$this->provider->getKeyCalculatorForResolver($resolver);
}
/**
* Test that empty provided config is handled properly.
*
* @magentoAppArea graphql
*
* @return void
*/
public function testProviderEmptyConfig()
{
$this->provider = $this->objectManager->create(
Provider::class,
[
'factorProviders' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [],
]
]
);
$resolver = $this->getMockBuilder(\Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver::class)
->disableOriginalConstructor()
->getMock();
$calc = $this->provider->getKeyCalculatorForResolver($resolver);
$this->assertNull($calc->calculateCacheKey());
}
/**
* Test that customized provider returns a key calculator that provides factors in certain order.
*
* @magentoAppArea graphql
*
* @return void
*/
public function testProviderKeyFactorsConfigured()
{
$this->provider = $this->objectManager->create(Provider::class, [
'factorProviders' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [
'store' => 'Magento\StoreGraphQl\Model\Resolver\CacheKey\FactorProvider\Store',
'currency' => 'Magento\StoreGraphQl\Model\Resolver\CacheKey\FactorProvider\Currency'
],
'StoreConfigDerivedMock' => [
'customer_group' => 'Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\CustomerGroup'
]
]
]);
$resolver = $this->getMockBuilder(StoreConfigResolver::class)
->disableOriginalConstructor()
->setMockClassName('StoreConfigDerivedMock')
->getMock();
$storeFactorMock = $this->getMockBuilder(StoreProvider::class)
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMock();
$currencyFactorMock = $this->getMockBuilder(CurrencyProvider::class)
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMock();
$customerGroupFactorMock = $this->getMockBuilder(CustomerGroup::class)
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMock();
$storeFactorMock->expects($this->any())
->method('getFactorName')
->withAnyParameters()
->willReturn(StoreProvider::NAME);
$storeFactorMock->expects($this->any())
->method('getFactorValue')
->withAnyParameters()
->willReturn('default');
$currencyFactorMock->expects($this->any())
->method('getFactorName')
->withAnyParameters()
->willReturn(CurrencyProvider::NAME);
$currencyFactorMock->expects($this->any())
->method('getFactorValue')
->withAnyParameters()->willReturn('USD');
$customerGroupFactorMock->expects($this->any())
->method('getFactorName')
->withAnyParameters()
->willReturn('CUSTOMER_GROUP');
$customerGroupFactorMock->expects($this->any())
->method('getFactorValue')
->withAnyParameters()
->willReturn('1');
$this->objectManager->addSharedInstance($storeFactorMock, StoreProvider::class);
$this->objectManager->addSharedInstance($currencyFactorMock, CurrencyProvider::class);
$this->objectManager->addSharedInstance($customerGroupFactorMock, CustomerGroup::class);
$salt = $this->objectManager->get(DeploymentConfig::class)
->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
$expectedKey = hash(
'sha256',
strtoupper(implode('|', ['CURRENCY' => 'USD', 'CUSTOMER_GROUP' => '1', 'STORE' => 'default'])) . "|$salt"
);
$calc = $this->provider->getKeyCalculatorForResolver($resolver);
$key = $calc->calculateCacheKey();
$this->assertNotEmpty($key);
$this->assertEquals($expectedKey, $key);
$this->objectManager->removeSharedInstance(StoreProvider::class);
$this->objectManager->removeSharedInstance(CurrencyProvider::class);
$this->objectManager->removeSharedInstance(CustomerGroup::class);
}
/**
* Test that if different resolvers have same custom key calculator it is not instantiated again.
*
* @magentoAppArea graphql
*
* @return void
*/
public function testProviderSameKeyCalculatorsForDifferentResolvers()
{
$this->provider = $this->objectManager->create(
Provider::class,
[
'factorProviders' => [
'Magento\CustomerGraphQl\Model\Resolver\Customer' => [
'customer_id' =>
'Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\CurrentCustomerId',
'is_logged_in' => 'Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\IsLoggedIn'
],
'Magento\CustomerGraphQl\Model\Resolver\CustomerAddresses' => [
'customer_id' =>
'Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\CurrentCustomerId',
'is_logged_in' => 'Magento\CustomerGraphQl\Model\Resolver\CacheKey\FactorProvider\IsLoggedIn'
]
]
]
);
$customerResolver = $this->getMockBuilder(Customer::class)
->disableOriginalConstructor()
->getMock();
$customerAddressResolver = $this->getMockBuilder(CustomerAddresses::class)
->disableOriginalConstructor()
->getMock();
$calcCustomer = $this->provider->getKeyCalculatorForResolver($customerResolver);
$calcAddress = $this->provider->getKeyCalculatorForResolver($customerAddressResolver);
$this->assertSame($calcCustomer, $calcAddress);
}
/**
* Test that different key calculators with intersecting factors are not being reused.
*
* @magentoAppArea graphql
*
* @return void
*/
public function testProviderDifferentKeyCalculatorsForDifferentResolvers()
{
$this->provider = $this->objectManager->create(Provider::class, [
'factorProviders' => [
'Magento\CustomerGraphQl\Model\Resolver\Customer' => [
'customer_id' =>
'Magento\CustomerGraphQl\Model\Resolver\Cache\KeyFactorProvider\CurrentCustomerId',
'is_logged_in' => 'Magento\CustomerGraphQl\CacheIdFactorProviders\IsLoggedInProvider'
],
'Magento\CustomerGraphQl\Model\Resolver\CustomerAddresses' => [
'customer_id' =>
'Magento\CustomerGraphQl\Model\Resolver\Cache\KeyFactorProvider\CurrentCustomerId',
]
]
]);
$customerResolver = $this->getMockBuilder(Customer::class)
->disableOriginalConstructor()
->getMock();
$customerAddressResolver = $this->getMockBuilder(CustomerAddresses::class)
->disableOriginalConstructor()
->getMock();
$calcCustomer = $this->provider->getKeyCalculatorForResolver($customerResolver);
$calcAddress = $this->provider->getKeyCalculatorForResolver($customerAddressResolver);
$this->assertNotSame($calcCustomer, $calcAddress);
}
}
@@ -0,0 +1,431 @@
<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);
namespace Magento\GraphQlResolverCache\Model\Resolver\Result\Cache;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\GraphQl\Model\Query\ContextFactoryInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\CalculationException;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\Calculator;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\ParentValueFactorProviderInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\CacheKey\GenericFactorProviderInterface;
use Magento\GraphQlResolverCache\Model\Resolver\Result\ValueProcessorInterface;
use Magento\TestFramework\Helper\Bootstrap;
/**
* Test for graphql resolver-level cache key calculator.
*/
class KeyCalculatorTest extends \PHPUnit\Framework\TestCase
{
/**
* @var \Magento\TestFramework\ObjectManager
*/
private $objectManager;
/**
* @var ContextFactoryInterface
*/
private $contextFactory;
/**
* @inheritdoc
*/
public function setUp(): void
{
$this->objectManager = Bootstrap::getObjectManager();
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
parent::setUp();
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testKeyCalculatorException()
{
$this->expectException(CalculationException::class);
$this->expectExceptionMessage("Test message");
$exceptionMessage = "Test message";
$mock = $this->getMockBuilder(GenericFactorProviderInterface::class)
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMock();
$mock->expects($this->once())
->method('getFactorName')
->willThrowException(new \Exception($exceptionMessage));
$mock->expects($this->never())
->method('getFactorValue')
->willReturn('value');
$this->objectManager->addSharedInstance($mock, 'TestFactorProviderMock');
/** @var Calculator $keyCalculator */
$keyCalculator = $this->objectManager->create(
Calculator::class,
[
'factorProviders' => [
'test' => 'TestFactorProviderMock'
]
]
);
$keyCalculator->calculateCacheKey();
}
/**
* @param array $factorDataArray
* @param array|null $parentResolverData
* @param string|null $expectedCacheKey
*
* @return void
*
* @magentoAppArea graphql
*
* @dataProvider keyFactorDataProvider
*/
public function testKeyCalculator(array $factorDataArray, ?array $parentResolverData, $expectedCacheKey)
{
$this->initMocksForObjectManager($factorDataArray, $parentResolverData);
$keyFactorProvidersConfig = [];
foreach ($factorDataArray as $factorData) {
$keyFactorProvidersConfig[$factorData['name']] = $this->prepareFactorClassName($factorData);
}
/** @var Calculator $keyCalculator */
$keyCalculator = $this->objectManager->create(
Calculator::class,
[
'factorProviders' => $keyFactorProvidersConfig
]
);
$key = $keyCalculator->calculateCacheKey($parentResolverData);
$this->assertEquals($expectedCacheKey, $key);
$this->resetMocksForObjectManager($factorDataArray);
}
/**
* Helper method to initialize object manager with mocks from given test data.
*
* @param array $factorDataArray
* @param array|null $parentResolverData
* @return void
*/
private function initMocksForObjectManager(array $factorDataArray, ?array $parentResolverData)
{
foreach ($factorDataArray as $factor) {
if ($factor['interface'] == GenericFactorProviderInterface::class) {
$mock = $this->getMockBuilder($factor['interface'])
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMock();
$mock->expects($this->once())
->method('getFactorName')
->willReturn($factor['name']);
$mock->expects($this->once())
->method('getFactorValue')
->willReturn($factor['value']);
} else {
$mock = $this->getMockBuilder($factor['interface'])
->disableOriginalConstructor()
->onlyMethods(['getFactorName', 'getFactorValue', 'getFactorValueForParentResolvedData'])
->getMock();
$mock->expects($this->once())
->method('getFactorName')
->willReturn($factor['name']);
$mock->expects($this->never())
->method('getFactorValue')
->willReturn($factor['name']);
$mock->expects($this->once())
->method('getFactorValueForParentResolvedData')
->with($this->contextFactory->get(), $parentResolverData)
->willReturn($factor['value']);
}
$this->objectManager->addSharedInstance($mock, $this->prepareFactorClassName($factor));
}
}
/**
* Get class name from factor data.
*
* @param array $factor
* @return string
*/
private function prepareFactorClassName(array $factor)
{
return $factor['name'] . 'TestFactorMock';
}
/**
* Reset all mocks for the object manager by given factor data.
*
* @param array $factorDataArray
* @return void
*/
private function resetMocksForObjectManager(array $factorDataArray)
{
foreach ($factorDataArray as $factor) {
$this->objectManager->removeSharedInstance($this->prepareFactorClassName($factor));
}
}
/**
* Test data provider.
*
* @return array[]
*/
public function keyFactorDataProvider()
{
$salt = Bootstrap::getObjectManager()->get(DeploymentConfig::class)
->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
return [
'no factors' => [
'factorProviders' => [],
'parentResolverData' => null,
'expectedCacheKey' => null
],
'single factor' => [
'factorProviders' => [
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'test',
'value' => 'testValue'
],
],
'parentResolverData' => null,
'expectedCacheKey' => hash('sha256', strtoupper('testValue') . "|$salt"),
],
'unsorted multiple factors' => [
'factorProviders' => [
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'ctest',
'value' => 'c_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'atest',
'value' => 'a_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'btest',
'value' => 'b_testValue'
],
],
'parentResolverData' => null,
'expectedCacheKey' => hash(
'sha256',
strtoupper('a_testValue|b_testValue|c_testValue') . "|$salt"
),
],
'unsorted multiple factors with parent data' => [
'factorProviders' => [
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'ctest',
'value' => 'c_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'atest',
'value' => 'a_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'btest',
'value' => 'object_123'
],
],
'parentResolverData' => [
'object_id' => 123
],
'expectedCacheKey' => hash(
'sha256',
strtoupper('a_testValue|object_123|c_testValue') . "|$salt"
),
],
'unsorted multifactor with no parent data and parent factored interface' => [
'factorProviders' => [
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'ctest',
'value' => 'c_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'atest',
'value' => 'a_testValue'
],
[
'interface' => GenericFactorProviderInterface::class,
'name' => 'btest',
'value' => 'some value'
],
],
'parentResolverData' => null,
'expectedCacheKey' => hash(
'sha256',
strtoupper('a_testValue|some value|c_testValue') . "|$salt"
),
],
];
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testValueProcessingIsCalledForParentValueFromCache()
{
$value = [
'data' => 'some data',
ValueProcessorInterface::VALUE_PROCESSING_REFERENCE_KEY => 'preprocess me'
];
$this->initFactorMocks();
$valueProcessorMock = $this->getMockBuilder(ValueProcessorInterface::class)
->disableOriginalConstructor()
->onlyMethods(['preProcessParentValue'])
->getMockForAbstractClass();
$valueProcessorMock->expects($this->once())
->method('preProcessParentValue')
->with($value);
/** @var Calculator $keyCalculator */
$keyCalculator = $this->objectManager->create(Calculator::class, [
'valueProcessor' => $valueProcessorMock,
'factorProviders' => [
'context' => 'TestContextFactorMock',
'parent_value' => 'TestValueFactorMock',
'parent_processed_value' => 'TestProcessedValueFactorMock'
]
]);
$key = $keyCalculator->calculateCacheKey($value);
$salt = Bootstrap::getObjectManager()->get(DeploymentConfig::class)
->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
$expectedResult = hash('sha256', "|$salt");
$this->assertEquals($expectedResult, $key);
$this->objectManager->removeSharedInstance('TestValueFactorMock');
$this->objectManager->removeSharedInstance('TestContextFactorMock');
}
/**
* @return void
*/
private function initFactorMocks()
{
$mockContextFactor = $this->getMockBuilder(GenericFactorProviderInterface::class)
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMockForAbstractClass();
$mockPlainParentValueFactor = $this->getMockBuilder(ParentValueFactorProviderInterface::class)
->onlyMethods(['getFactorName', 'getFactorValue', 'isRequiredOrigData'])
->getMockForAbstractClass();
$mockPlainParentValueFactor->expects($this->any())->method('isRequiredOrigData')->willReturn(false);
$mockProcessedParentValueFactor = $this->getMockBuilder(ParentValueFactorProviderInterface::class)
->onlyMethods(['getFactorName', 'getFactorValue', 'isRequiredOrigData'])
->getMockForAbstractClass();
$mockProcessedParentValueFactor->expects($this->any())->method('isRequiredOrigData')->willReturn(true);
$this->objectManager->addSharedInstance($mockPlainParentValueFactor, 'TestValueFactorMock');
$this->objectManager->addSharedInstance($mockProcessedParentValueFactor, 'TestProcessedValueFactorMock');
$this->objectManager->addSharedInstance($mockContextFactor, 'TestContextFactorMock');
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testValueProcessingIsNotCalledForParentValueFromResolver()
{
$value = [
'data' => 'some data'
];
$this->initFactorMocks();
$valueProcessorMock = $this->getMockBuilder(ValueProcessorInterface::class)
->disableOriginalConstructor()
->onlyMethods(['preProcessParentValue'])
->getMockForAbstractClass();
$valueProcessorMock->expects($this->never())
->method('preProcessParentValue');
/** @var Calculator $keyCalculator */
$keyCalculator = $this->objectManager->create(Calculator::class, [
'valueProcessor' => $valueProcessorMock,
'factorProviders' => [
'context' => 'TestContextFactorMock',
'parent_value' => 'TestValueFactorMock',
'parent_processed_value' => 'TestProcessedValueFactorMock'
]
]);
$key = $keyCalculator->calculateCacheKey($value);
$salt = Bootstrap::getObjectManager()->get(DeploymentConfig::class)
->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
$expectedResult = hash('sha256', "|$salt");
$this->assertEquals($expectedResult, $key);
$this->objectManager->removeSharedInstance('TestValueFactorMock');
$this->objectManager->removeSharedInstance('TestContextFactorMock');
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testValueProcessingIsSkippedForContextOnlyFactors()
{
$mockContextFactor = $this->getMockBuilder(GenericFactorProviderInterface::class)
->onlyMethods(['getFactorName', 'getFactorValue'])
->getMockForAbstractClass();
$value = ['data' => 'some data'];
$this->objectManager->addSharedInstance($mockContextFactor, 'TestContextFactorMock');
$valueProcessorMock = $this->getMockBuilder(ValueProcessorInterface::class)
->disableOriginalConstructor()
->onlyMethods(['preProcessParentValue'])
->getMockForAbstractClass();
$valueProcessorMock->expects($this->never())
->method('preProcessParentValue');
/** @var Calculator $keyCalculator */
$keyCalculator = $this->objectManager->create(Calculator::class, [
'valueProcessor' => $valueProcessorMock,
'factorProviders' => [
'context' => 'TestContextFactorMock',
]
]);
$key = $keyCalculator->calculateCacheKey($value);
$salt = Bootstrap::getObjectManager()->get(DeploymentConfig::class)
->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
$expectedResult = hash('sha256', "|$salt");
$this->assertEquals($expectedResult, $key);
$this->objectManager->removeSharedInstance('TestContextFactorMock');
}
}
@@ -0,0 +1,261 @@
<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
declare(strict_types=1);
namespace Magento\GraphQlResolverCache\Model\Resolver\Result;
use Magento\CatalogGraphQl\Model\Resolver\Cache\Product\MediaGallery\ProductModelHydrator;
use Magento\Framework\DataObject;
use Magento\Framework\GraphQl\Query\ResolverInterface;
use Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver;
use Magento\TestFramework\Helper\Bootstrap;
use PHPUnit\Framework\TestCase;
class HydratorDehydratorProviderTest extends TestCase
{
/**
* @var \Magento\TestFramework\ObjectManager
*/
private $objectManager;
/**
* @var HydratorDehydratorProvider
*/
private $provider;
/**
* @inheritdoc
*/
public function setUp(): void
{
$this->objectManager = Bootstrap::getObjectManager();
$this->provider = $this->objectManager->create(
HydratorDehydratorProvider::class,
$this->getTestProviderConfig()
);
parent::setUp();
}
/**
* @return array
*/
private function getTestProviderConfig()
{
return [
'hydratorConfig' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [
'nested_items_hydrator' => [
'sortOrder' => 15,
'class' => 'TestResolverNestedItemsHydrator'
],
],
'StoreConfigResolverDerivedMock' => [
'model_hydrator' => [
'sortOrder' => 10,
'class' => 'TestResolverModelHydrator'
],
]
],
'dehydratorConfig' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [
'simple_dehydrator' => [
'sortOrder' => 10,
'class' => 'TestResolverModelDehydrator'
],
]
]
];
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testHydratorChainProvider()
{
$resolver = $this->getMockBuilder(StoreConfigResolver::class)
->disableOriginalConstructor()
->setMockClassName('StoreConfigResolverDerivedMock')
->getMockForAbstractClass();
$testResolverData = [
'id' => 2,
'name' => 'test name',
'model' => new DataObject(
[
'some_field' => 'some_data_value',
'id' => 2,
'name' => 'test name',
]
)
];
$testModelDehydrator = $this->getMockBuilder(DehydratorInterface::class)
->disableOriginalConstructor()
->setMockClassName('TestResolverModelDehydrator')
->onlyMethods(['dehydrate'])
->getMock();
$testModelDehydrator->expects($this->once())
->method('dehydrate')
->willReturnCallback(function (&$resolverData) {
$resolverData['model_data'] = $resolverData['model']->getData();
unset($resolverData['model']);
});
$testModelHydrator = $this->getMockBuilder(ProductModelHydrator::class)
->disableOriginalConstructor()
->setMockClassName('TestResolverModelHydrator')
->onlyMethods(['hydrate', 'prehydrate'])
->getMock();
$testModelHydrator->expects($this->once())
->method('hydrate')
->willReturnCallback(function (&$resolverData) {
$do = new DataObject($resolverData['model_data']);
$resolverData['model'] = $do;
$resolverData['sortOrderTest_field'] = 'some data';
});
$testNestedHydrator = $this->getMockBuilder(HydratorInterface::class)
->disableOriginalConstructor()
->setMockClassName('TestResolverNestedItemsHydrator')
->onlyMethods(['hydrate'])
->getMock();
$testNestedHydrator->expects($this->once())
->method('hydrate')
->willReturnCallback(function (&$resolverData) {
$resolverData['model']->setData('nested_data', ['test_nested_data']);
$resolverData['sortOrderTest_field'] = 'other data';
});
$this->objectManager->addSharedInstance($testModelHydrator, 'TestResolverModelHydrator');
$this->objectManager->addSharedInstance($testNestedHydrator, 'TestResolverNestedItemsHydrator');
$this->objectManager->addSharedInstance($testModelDehydrator, 'TestResolverModelDehydrator');
$dehydrator = $this->provider->getDehydratorForResolver($resolver);
$dehydrator->dehydrate($testResolverData);
/** @var HydratorInterface $hydrator */
$hydrator = $this->provider->getHydratorForResolver($resolver);
$hydrator->hydrate($testResolverData);
// assert that data object is instantiated
$this->assertInstanceOf(DataObject::class, $testResolverData['model']);
// assert object fields
$this->assertEquals(2, $testResolverData['model']->getId());
$this->assertEquals('test name', $testResolverData['model']->getName());
// assert mode nested data from second hydrator
$this->assertEquals(['test_nested_data'], $testResolverData['model']->getNestedData());
$this->assertEquals('some_data_value', $testResolverData['model']->getData('some_field'));
//verify that hydrators were invoked in designated order
$this->assertEquals('other data', $testResolverData['sortOrderTest_field']);
// verify that hydrator instance is not recreated
$this->assertSame($hydrator, $this->provider->getHydratorForResolver($resolver));
$this->objectManager->removeSharedInstance('TestResolverModelHydrator');
$this->objectManager->removeSharedInstance('TestResolverNestedItemsHydrator');
$this->objectManager->removeSharedInstance('TestResolverModelDehydrator');
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testHydratorDoesNotExist()
{
$resolver = $this->getMockBuilder(ResolverInterface::class)
->disableOriginalConstructor()
->getMockForAbstractClass();
$this->assertNull($this->provider->getHydratorForResolver($resolver));
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testHydratorClassMismatch()
{
$this->expectExceptionMessage('Hydrator TestResolverModelDehydrator configured for resolver '
. 'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver must implement '
. 'Magento\GraphQlResolverCache\Model\Resolver\Result\HydratorInterface.');
$testModelDehydrator = $this->getMockBuilder(DehydratorInterface::class)
->disableOriginalConstructor()
->setMockClassName('TestResolverModelDehydrator')
->onlyMethods(['dehydrate'])
->getMock();
$this->objectManager->addSharedInstance($testModelDehydrator, 'TestResolverModelDehydrator');
$this->provider = $this->objectManager->create(
HydratorDehydratorProvider::class,
[
'hydratorConfig' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [
'simple_dehydrator' => [
'sortOrder' => 10,
'class' => 'TestResolverModelDehydrator'
],
]
]
]
);
$resolver = $this->getMockBuilder(StoreConfigResolver::class)
->disableOriginalConstructor()
->getMockForAbstractClass();
$this->assertNull($this->provider->getHydratorForResolver($resolver));
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testDehydratorClassMismatch()
{
$this->expectExceptionMessage('Dehydrator TestResolverModelHydrator configured for resolver '
. 'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver must implement '
. 'Magento\GraphQlResolverCache\Model\Resolver\Result\DehydratorInterface.');
$hydrator = $this->getMockBuilder(HydratorInterface::class)
->disableOriginalConstructor()
->setMockClassName('TestResolverModelHydrator')
->getMock();
$this->objectManager->addSharedInstance($hydrator, 'TestResolverModelHydrator');
$this->provider = $this->objectManager->create(
HydratorDehydratorProvider::class,
[
'dehydratorConfig' => [
'Magento\StoreGraphQl\Model\Resolver\StoreConfigResolver' => [
'simple_dehydrator' => [
'sortOrder' => 10,
'class' => 'TestResolverModelHydrator'
],
]
]
]
);
$resolver = $this->getMockBuilder(StoreConfigResolver::class)
->disableOriginalConstructor()
->getMockForAbstractClass();
$this->assertNull($this->provider->getDehydratorForResolver($resolver));
}
/**
* @magentoAppArea graphql
*
* @return void
*/
public function testDehydratorDoesNotExist()
{
$resolver = $this->getMockBuilder(ResolverInterface::class)
->disableOriginalConstructor()
->getMockForAbstractClass();
$this->assertNull($this->provider->getDehydratorForResolver($resolver));
}
}