Add tests

Author: amirhshokri

tests/Cache/CacheFileStoreTest.php

@@ -10,6 +10,7 @@
 use Illuminate\Support\Str;
 use Mockery as m;
 use PHPUnit\Framework\TestCase;
+use RuntimeException;
 
 class CacheFileStoreTest extends TestCase
 {
@@ -402,6 +403,40 @@ public function testFlushingLocksIgnoreNonExistingDirectory()
         $this->assertFalse($result, 'Flushing locks should not clean locks directory');
     }
 
+    public function testHasSeparateLockStoreReturnsTrueWhenLockDirectoryDiffers()
+    {
+        $store = new FileStore(new Filesystem, __DIR__);
+        $store->setLockDirectory('/locks');
+
+        $this->assertTrue($store->hasSeparateLockStore());
+    }
+
+    public function testHasSeparateLockStoreReturnsFalseWhenLockDirectoryIsSame()
+    {
+        $store = new FileStore(new Filesystem, __DIR__);
+        $store->setLockDirectory(__DIR__);
+
+        $this->assertFalse($store->hasSeparateLockStore());
+    }
+
+    public function testHasSeparateLockStoreReturnsFalseWhenLockDirectoryIsNull()
+    {
+        $store = new FileStore(new Filesystem, __DIR__);
+        $store->setLockDirectory(null);
+
+        $this->assertFalse($store->hasSeparateLockStore());
+    }
+
+    public function testFlushLocksThrowsExceptionWhenLockDirectoryIsSame()
+    {
+        $store = new FileStore(new Filesystem, __DIR__);
+        $store->setLockDirectory(__DIR__);
+
+        $this->expectException(RuntimeException::class);
+
+        $store->flushLocks();
+    }
+
     public function testItHandlesForgettingNonFlexibleKeys()
     {
         $store = new FileStore(new Filesystem, __DIR__);

tests/Cache/CacheRepositoryTest.php

@@ -464,6 +464,16 @@ public function testNonFlushableLockRepositoryDoesNotSupportFlushingLocks()
         $this->assertFalse($nonFlushableRepo->supportsFlushingLocks());
     }
 
+    public function testItThrowsExceptionWhenStoreDoesNotSupportFlushingLocks()
+    {
+        $this->expectException(BadMethodCallException::class);
+
+        $nonFlushable = m::mock(MemcachedStore::class);
+        $nonFlushableRepo = new Repository($nonFlushable);
+
+        $nonFlushableRepo->flushLocks();
+    }
+
     public function testTouchWithNullTTLRemembersItemForever(): void
     {
         $key = 'key';

tests/Integration/Cache/RedisStoreTest.php

@@ -12,6 +12,7 @@
 use Orchestra\Testbench\TestCase;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use PHPUnit\Framework\Attributes\TestWith;
+use RuntimeException;
 
 #[RequiresPhpExtension('redis')]
 class RedisStoreTest extends TestCase
@@ -314,4 +315,36 @@ public function testLocksCanBeFlushed()
         $this->assertTrue($store->lock('lock-2', 60)->acquire());
         $this->assertTrue($store->lock('lock-3', 60)->acquire());
     }
+
+    public function testHasSeparateLockStoreReturnsTrueWhenLockConnectionDiffers()
+    {
+        /** @var \Illuminate\Cache\RedisStore $store */
+        $store = Cache::store('redis');
+        $store->setConnection('default');
+        $store->setLockConnection('locks');
+
+        $this->assertTrue($store->hasSeparateLockStore());
+    }
+
+    public function testHasSeparateLockStoreReturnsFalseWhenLockConnectionIsSame()
+    {
+        /** @var \Illuminate\Cache\RedisStore $store */
+        $store = Cache::store('redis');
+        $store->setConnection('default');
+        $store->setLockConnection('default');
+
+        $this->assertFalse($store->hasSeparateLockStore());
+    }
+
+    public function testFlushLocksThrowsExceptionWhenLockConnectionIsSame()
+    {
+        /** @var \Illuminate\Cache\RedisStore $store */
+        $store = Cache::store('redis');
+        $store->setConnection('default');
+        $store->setLockConnection('default');
+
+        $this->expectException(RuntimeException::class);
+
+        $store->flushLocks();
+    }
 }

tests/Integration/Database/DatabaseCacheStoreTest.php

@@ -2,11 +2,13 @@
 
 namespace Illuminate\Tests\Integration\Database;
 
+use Illuminate\Cache\DatabaseStore;
 use Illuminate\Database\SQLiteConnection;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\DB;
 use Orchestra\Testbench\Attributes\WithMigration;
+use RuntimeException;
 
 #[WithMigration('cache')]
 class DatabaseCacheStoreTest extends DatabaseTestCase
@@ -291,6 +293,41 @@ public function testFlushLocksRemovesExpiredLocksToo()
         $this->assertDatabaseMissing($this->getLocksTableName(), ['key' => $this->withCachePrefix('stale-lock')]);
     }
 
+    public function testHasSeparateLockStoreReturnsTrueWhenTablesAreDifferent()
+    {
+        $store = new DatabaseStore(
+            connection: DB::connection(),
+            table: $this->getCacheTableName(),
+            lockTable: $this->getLocksTableName(),
+        );
+
+        $this->assertTrue($store->hasSeparateLockStore());
+    }
+
+    public function testHasSeparateLockStoreReturnsFalseWhenTablesAreTheSame()
+    {
+        $store = new DatabaseStore(
+            connection: DB::connection(),
+            table: $this->getCacheTableName(),
+            lockTable: $this->getCacheTableName(),
+        );
+
+        $this->assertFalse($store->hasSeparateLockStore());
+    }
+
+    public function testFlushLocksThrowsExceptionWhenTablesAreTheSame()
+    {
+        $store = new DatabaseStore(
+            connection: DB::connection(),
+            table: $this->getCacheTableName(),
+            lockTable: $this->getCacheTableName(),
+        );
+
+        $this->expectException(RuntimeException::class);
+
+        $store->flushLocks();
+    }
+
     /**
      * @return \Illuminate\Cache\DatabaseStore
      */