laravel
diff --git a/‎src/Illuminate/Cache/MemoizedStore.php
Copy file name to clipboardExpand all lines: src/Illuminate/Cache/MemoizedStore.php
+36-1Lines changed: 36 additions & 1 deletion b/‎src/Illuminate/Cache/MemoizedStore.php
Copy file name to clipboardExpand all lines: src/Illuminate/Cache/MemoizedStore.php
+36-1Lines changed: 36 additions & 1 deletion
diff --git a/‎tests/Integration/Cache/MemoizedStoreTest.php
Copy file name to clipboardExpand all lines: tests/Integration/Cache/MemoizedStoreTest.php
+85Lines changed: 85 additions & 0 deletions b/‎tests/Integration/Cache/MemoizedStoreTest.php
Copy file name to clipboardExpand all lines: tests/Integration/Cache/MemoizedStoreTest.php
+85Lines changed: 85 additions & 0 deletions
@@ -2,9 +2,11 @@
 
 namespace Illuminate\Cache;
 
+use BadMethodCallException;
+use Illuminate\Contracts\Cache\LockProvider;
 use Illuminate\Contracts\Cache\Store;
 
-class MemoizedStore implements Store
+class MemoizedStore implements LockProvider, Store
 {
     /**
      * The memoized cache values.
@@ -160,6 +162,39 @@ public function forever($key, $value)
         return $this->repository->forever($key, $value);
     }
 
+    /**
+     * Get a lock instance.
+     *
+     * @param  string  $name
+     * @param  int  $seconds
+     * @param  string|null  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function lock($name, $seconds = 0, $owner = null)
+    {
+        if (! $this->repository->getStore() instanceof LockProvider) {
+            throw new BadMethodCallException('This cache store does not support locks.');
+        }
+
+        return $this->repository->getStore()->lock(...func_get_args());
+    }
+
+    /**
+     * Restore a lock instance using the owner identifier.
+     *
+     * @param  string  $name
+     * @param  string  $owner
+     * @return \Illuminate\Contracts\Cache\Lock
+     */
+    public function restoreLock($name, $owner)
+    {
+        if (! $this->repository instanceof LockProvider) {
+            throw new BadMethodCallException('This cache store does not support locks.');
+        }
+
+        return $this->repository->resoreLock(...func_get_args());
+    }
+
     /**
      * Remove an item from the cache.
      *
 
@@ -2,6 +2,7 @@
 
 namespace Illuminate\Tests\Integration\Cache;
 
+use BadMethodCallException;
 use Illuminate\Cache\Events\CacheEvent;
 use Illuminate\Cache\Events\CacheMissed;
 use Illuminate\Cache\Events\ForgettingKey;
@@ -10,12 +11,16 @@
 use Illuminate\Cache\Events\RetrievingKey;
 use Illuminate\Cache\Events\RetrievingManyKeys;
 use Illuminate\Cache\Events\WritingKey;
+use Illuminate\Contracts\Cache\Store;
 use Illuminate\Foundation\Testing\Concerns\InteractsWithRedis;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\Exceptions;
 use Illuminate\Support\Facades\Redis;
+use Illuminate\Support\Facades\Route;
 use Orchestra\Testbench\TestCase;
+use Throwable;
 
 class MemoizedStoreTest extends TestCase
 {
@@ -406,4 +411,84 @@ public function test_it_resets_cache_store_with_scoped_instances()
         $this->assertSame('Taylor', $live);
         $this->assertSame('Taylor', $memoized);
     }
+
+    public function test_it_throws_when_underlying_store_does_not_support_locks()
+    {
+        $this->freezeTime();
+        $exceptions = [];
+        Exceptions::reportable(function (Throwable $e) use (&$exceptions) {
+            $exceptions[] = $e;
+        });
+        Config::set('cache.stores.no-lock', ['driver' => 'no-lock']);
+        Cache::extend('no-lock', fn () => Cache::repository(new class implements Store {
+            public function get($key)
+            {
+                return Cache::get(...func_get_args());
+            }
+
+            public function many(array $keys) 
+            {
+                return Cache::many(...func_get_args());
+            }
+
+            public function put($key, $value, $seconds) {
+
+                return Cache::put(...func_get_args());
+            }
+
+            public function putMany(array $values, $seconds) {
+                return Cache::putMany(...func_get_args());
+            }
+
+            public function increment($key, $value = 1) {
+
+                return Cache::increment(...func_get_args());
+            }
+
+            public function decrement($key, $value = 1) {
+                return Cache::decrement(...func_get_args());
+            }
+
+            public function forever($key, $value) {
+                return Cache::forever(...func_get_args());
+
+            }
+
+            public function forget($key) {
+                return Cache::forget(...func_get_args());
+            }
+
+            public function flush() {
+                return Cache::flush(...func_get_args());
+
+            }
+
+            public function getPrefix() {
+                return Cache::getPrefix(...func_get_args());
+            }
+        }));
+        Cache::flexible('key', [10, 20], 'value-1');
+
+        $this->travel(11)->seconds();
+        Cache::memo('no-lock')->flexible('key', [10, 20], 'value-2');
+        defer()->invoke();
+        $value = Cache::get('key');
+
+        $this->assertCount(1, $exceptions);
+        $this->assertInstanceOf(BadMethodCallException::class, $exceptions[0]);
+        $this->assertSame('This cache store does not support locks.', $exceptions[0]->getMessage());
+    }
+
+    public function test_it_supports_with_flexible()
+    {
+        $this->freezeTime();
+        Cache::flexible('key', [10, 20], 'value-1');
+
+        $this->travel(11)->seconds();
+        Cache::memo()->flexible('key', [10, 20], 'value-2');
+        defer()->invoke();
+        $value = Cache::get('key');
+
+        $this->assertSame('value-2', $value);
+    }
 }