merge magento/2.4-develop into magento-trigger/trigger-pr-1

Author: magento-mts-svc

lib/internal/Magento/Framework/Cache/LockGuardedCacheLoader.php

@@ -116,7 +116,7 @@ public function lockedLoadData(
         callable $dataSaver
     ) {
         $cachedData = $dataLoader(); //optimistic read
-        $deadline = microtime(true) + $this->loadTimeout / 100;
+        $deadline = microtime(true) + $this->loadTimeout / 1000;
 
         if (empty($this->allowParallelGenerationConfigValue)) {
             $cacheConfig = $this

lib/internal/Magento/Framework/Cache/Test/Unit/Backend/RemoteSynchronizedCacheTest.php

@@ -61,11 +61,13 @@ protected function setUp(): void
     }
 
     /**
+     * Test that exception is thrown if cache is not configured.
+     *
      * @param array $options
      *
      * @dataProvider initializeWithExceptionDataProvider
      */
-    public function testInitializeWithException($options)
+    public function testInitializeWithException($options): void
     {
         $this->expectException('Zend_Cache_Exception');
         $this->objectManager->getObject(
@@ -79,7 +81,7 @@ public function testInitializeWithException($options)
     /**
      * @return array
      */
-    public function initializeWithExceptionDataProvider()
+    public function initializeWithExceptionDataProvider(): array
     {
         return [
             'empty_backend_option' => [
@@ -104,11 +106,13 @@ public function initializeWithExceptionDataProvider()
     }
 
     /**
+     * Test that exception is not thrown if cache is configured.
+     *
      * @param array $options
      *
      * @dataProvider initializeWithOutExceptionDataProvider
      */
-    public function testInitializeWithOutException($options)
+    public function testInitializeWithOutException($options): void
     {
         $result = $this->objectManager->getObject(
             RemoteSynchronizedCache::class,
@@ -122,7 +126,7 @@ public function testInitializeWithOutException($options)
     /**
      * @return array
      */
-    public function initializeWithOutExceptionDataProvider()
+    public function initializeWithOutExceptionDataProvider(): array
     {
         $connectionMock = $this->getMockBuilder(Mysql::class)
             ->disableOriginalConstructor()
@@ -151,9 +155,11 @@ public function initializeWithOutExceptionDataProvider()
     }
 
     /**
-     * Test that load will always return newest data.
+     * Test that load will return the newest data.
+     *
+     * @return void
      */
-    public function testLoadWithLocalData()
+    public function testLoad(): void
     {
         $localData = 1;
         $remoteData = 2;
@@ -182,7 +188,12 @@ public function testLoadWithLocalData()
         $this->assertEquals($remoteData, $this->remoteSyncCacheInstance->load(1));
     }
 
-    public function testLoadWithNoLocalAndNoRemoteData()
+    /**
+     * Test that load will not return data when no local data and no remote data exist.
+     *
+     * @return void
+     */
+    public function testLoadWithNoLocalAndNoRemoteData(): void
     {
         $localData = false;
         $remoteData = false;
@@ -197,10 +208,15 @@ public function testLoadWithNoLocalAndNoRemoteData()
             ->method('load')
             ->willReturn($remoteData);
 
-        $this->assertEquals($remoteData, $this->remoteSyncCacheInstance->load(1));
+        $this->assertEquals(false, $this->remoteSyncCacheInstance->load(1));
     }
 
-    public function testLoadWithNoLocalAndRemoteData()
+    /**
+     * Test that load will return the newest data when only remote data exists.
+     *
+     * @return void
+     */
+    public function testLoadWithNoLocalAndWithRemoteData(): void
     {
         $localData = false;
         $remoteData = 1;
@@ -223,7 +239,109 @@ public function testLoadWithNoLocalAndRemoteData()
         $this->assertEquals($remoteData, $this->remoteSyncCacheInstance->load(1));
     }
 
-    public function testRemove()
+    /**
+     * Test that load will return the newest data when local data and remote data are the same.
+     *
+     * @return void
+     */
+    public function testLoadWithEqualLocalAndRemoteData(): void
+    {
+        $localData = 1;
+        $remoteData = 1;
+
+        $this->localCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn($localData);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn(\hash('sha256', (string)$remoteData));
+
+        $this->assertEquals($localData, $this->remoteSyncCacheInstance->load(1));
+    }
+
+    /**
+     * Test that load will return stale cache.
+     *
+     * @return void
+     */
+    public function testLoadWithStaleCache(): void
+    {
+        $localData = 1;
+
+        $this->localCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn($localData);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn(false);
+
+        $closure = \Closure::bind(function ($cacheInstance) {
+            $cacheInstance->_options['use_stale_cache'] = true;
+        }, null, $this->remoteSyncCacheInstance);
+        $closure($this->remoteSyncCacheInstance);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(2))
+            ->method('load')
+            ->willReturn(true);
+
+        $this->assertEquals($localData, $this->remoteSyncCacheInstance->load(1));
+    }
+
+    /**
+     * Test that load will generate data on the first attempt.
+     *
+     * @return void
+     */
+    public function testLoadWithoutStaleCache(): void
+    {
+        $localData = 1;
+
+        $this->localCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn($localData);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(0))
+            ->method('load')
+            ->willReturn(false);
+
+        $closure = \Closure::bind(function ($cacheInstance) {
+            $cacheInstance->_options['use_stale_cache'] = true;
+        }, null, $this->remoteSyncCacheInstance);
+        $closure($this->remoteSyncCacheInstance);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(2))
+            ->method('load')
+            ->willReturn(false);
+
+        $closure = \Closure::bind(function ($cacheInstance) {
+            return $cacheInstance->lockSign;
+        }, null, $this->remoteSyncCacheInstance);
+        $lockSign = $closure($this->remoteSyncCacheInstance);
+
+        $this->remoteCacheMockExample
+            ->expects($this->at(4))
+            ->method('load')
+            ->willReturn($lockSign);
+
+        $this->assertEquals(false, $this->remoteSyncCacheInstance->load(1));
+    }
+
+    /**
+     * Test data remove.
+     *
+     * @return void
+     */
+    public function testRemove(): void
     {
         $this->remoteCacheMockExample
             ->expects($this->exactly(2))
@@ -238,7 +356,12 @@ public function testRemove()
         $this->remoteSyncCacheInstance->remove(1);
     }
 
-    public function testClean()
+    /**
+     * Test data clean.
+     *
+     * @return void
+     */
+    public function testClean(): void
     {
         $this->remoteCacheMockExample
             ->expects($this->exactly(1))
@@ -248,7 +371,12 @@ public function testClean()
         $this->remoteSyncCacheInstance->clean();
     }
 
-    public function testSaveWithEqualRemoteData()
+    /**
+     * Test data save when remote data exist.
+     *
+     * @return void
+     */
+    public function testSaveWithEqualRemoteData(): void
     {
         $remoteData = 1;
 
@@ -285,7 +413,12 @@ public function testSaveWithMismatchedRemoteData()
         $this->remoteSyncCacheInstance->save(2, 1);
     }
 
-    public function testSaveWithoutRemoteData()
+    /**
+     * Test data save when remote data is not exist.
+     *
+     * @return void
+     */
+    public function testSaveWithoutRemoteData(): void
     {
         $this->remoteCacheMockExample
             ->expects($this->at(0))