Rename LockTest to LockTestCase

diff --git a/tests/LockTestCase.php b/tests/LockTestCase.php
new file mode 100644 (file)
index 0000000..9ce8649
--- /dev/null
+++ b/tests/LockTestCase.php
@@ -0,0 +1,208 @@
+<?php
+
+// Copyright (C) 2010-2024, the Friendica project
+// SPDX-FileCopyrightText: 2010-2024 the Friendica project
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+namespace Friendica\Test;
+
+use Friendica\Core\Lock\Capability\ICanLock;
+use Friendica\Test\MockedTestCase;
+
+abstract class LockTestCase extends MockedTestCase
+{
+       /**
+        * @var int Start time of the mock (used for time operations)
+        */
+       protected $startTime = 1417011228;
+
+       /**
+        * @var ICanLock
+        */
+       protected $instance;
+
+       abstract protected function getInstance();
+
+       protected function setUp(): void
+       {
+               parent::setUp();
+
+               $this->instance = $this->getInstance();
+               $this->instance->releaseAll(true);
+       }
+
+       protected function tearDown(): void
+       {
+               $this->instance->releaseAll(true);
+               parent::tearDown();
+       }
+
+       /**
+        * @small
+        */
+       public function testLock()
+       {
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->isLocked('foo'));
+               self::assertFalse($this->instance->isLocked('bar'));
+       }
+
+       /**
+        * @small
+        */
+       public function testDoubleLock()
+       {
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->isLocked('foo'));
+               // We already locked it
+               self::assertTrue($this->instance->acquire('foo', 1));
+       }
+
+       /**
+        * @small
+        */
+       public function testReleaseLock()
+       {
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->isLocked('foo'));
+               $this->instance->release('foo');
+               self::assertFalse($this->instance->isLocked('foo'));
+       }
+
+       /**
+        * @small
+        */
+       public function testReleaseAll()
+       {
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->acquire('bar', 1));
+               self::assertTrue($this->instance->acquire('nice', 1));
+
+               self::assertTrue($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('bar'));
+               self::assertTrue($this->instance->isLocked('nice'));
+
+               self::assertTrue($this->instance->releaseAll());
+
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertFalse($this->instance->isLocked('bar'));
+               self::assertFalse($this->instance->isLocked('nice'));
+       }
+
+       /**
+        * @small
+        */
+       public function testReleaseAfterUnlock()
+       {
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertFalse($this->instance->isLocked('bar'));
+               self::assertFalse($this->instance->isLocked('nice'));
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->acquire('bar', 1));
+               self::assertTrue($this->instance->acquire('nice', 1));
+
+               self::assertTrue($this->instance->release('foo'));
+
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('bar'));
+               self::assertTrue($this->instance->isLocked('nice'));
+
+               self::assertTrue($this->instance->releaseAll());
+
+               self::assertFalse($this->instance->isLocked('bar'));
+               self::assertFalse($this->instance->isLocked('nice'));
+       }
+
+       /**
+        * @small
+        */
+       public function testReleaseWitTTL()
+       {
+               self::assertFalse($this->instance->isLocked('test'));
+               self::assertTrue($this->instance->acquire('test', 1, 10));
+               self::assertTrue($this->instance->isLocked('test'));
+               self::assertTrue($this->instance->release('test'));
+               self::assertFalse($this->instance->isLocked('test'));
+       }
+
+       /**
+        * @small
+        */
+       public function testGetLocks()
+       {
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->acquire('bar', 1));
+               self::assertTrue($this->instance->acquire('nice', 1));
+
+               self::assertTrue($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('bar'));
+               self::assertTrue($this->instance->isLocked('nice'));
+
+               $locks = $this->instance->getLocks();
+
+               self::assertContains('foo', $locks);
+               self::assertContains('bar', $locks);
+               self::assertContains('nice', $locks);
+       }
+
+       /**
+        * @small
+        */
+       public function testGetLocksWithPrefix()
+       {
+               self::assertTrue($this->instance->acquire('foo', 1));
+               self::assertTrue($this->instance->acquire('test1', 1));
+               self::assertTrue($this->instance->acquire('test2', 1));
+
+               self::assertTrue($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('test1'));
+               self::assertTrue($this->instance->isLocked('test2'));
+
+               $locks = $this->instance->getLocks('test');
+
+               self::assertContains('test1', $locks);
+               self::assertContains('test2', $locks);
+               self::assertNotContains('foo', $locks);
+       }
+
+       /**
+        * @medium
+        */
+       public function testLockTTL()
+       {
+               static::markTestSkipped('taking too much time without mocking');
+
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertFalse($this->instance->isLocked('bar'));
+
+               // TODO [nupplaphil] - Because of the Datetime-Utils for the database, we have to wait a FULL second between the checks to invalidate the db-locks/cache
+               self::assertTrue($this->instance->acquire('foo', 2, 1));
+               self::assertTrue($this->instance->acquire('bar', 2, 3));
+
+               self::assertTrue($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('bar'));
+
+               sleep(2);
+
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertTrue($this->instance->isLocked('bar'));
+
+               sleep(2);
+
+               self::assertFalse($this->instance->isLocked('foo'));
+               self::assertFalse($this->instance->isLocked('bar'));
+       }
+
+       /**
+        * Test if releasing a non-existing lock doesn't throw errors
+        */
+       public function testReleaseLockWithoutLock()
+       {
+               self::assertFalse($this->instance->isLocked('wrongLock'));
+               self::assertFalse($this->instance->release('wrongLock'));
+       }
+}

diff --git a/tests/src/Core/Lock/APCuCacheLockTest.php b/tests/src/Core/Lock/APCuCacheLockTest.php
index f0ac1a0ec6269e1751748e4b5740b5e0838a97c2..3ee0d09661aa4899e669c8a912ec64bb2cceb7d8 100644 (file)
--- a/tests/src/Core/Lock/APCuCacheLockTest.php
+++ b/tests/src/Core/Lock/APCuCacheLockTest.php
@@ -9,11 +9,12 @@ namespace Friendica\Test\src\Core\Lock;
 
 use Friendica\Core\Cache\Type\APCuCache;
 use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\LockTestCase;
 
 /**
  * @group APCU
  */
-class APCuCacheLockTest extends LockTest
+class APCuCacheLockTest extends LockTestCase
 {
        protected function setUp(): void
        {
@@ -26,6 +27,6 @@ class APCuCacheLockTest extends LockTest
 
        protected function getInstance()
        {
-               return new \Friendica\Core\Lock\Type\CacheLock(new APCuCache('localhost'));
+               return new CacheLock(new APCuCache('localhost'));
        }
 }

diff --git a/tests/src/Core/Lock/ArrayCacheLockTest.php b/tests/src/Core/Lock/ArrayCacheLockTest.php
index 0c09b004f827733ed42c34654066446a88349579..19ac7925c61ef803d43a6a45fb2d79d733350dde 100644 (file)
--- a/tests/src/Core/Lock/ArrayCacheLockTest.php
+++ b/tests/src/Core/Lock/ArrayCacheLockTest.php
@@ -9,12 +9,13 @@ namespace Friendica\Test\src\Core\Lock;
 
 use Friendica\Core\Cache\Type\ArrayCache;
 use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\LockTestCase;
 
-class ArrayCacheLockTest extends LockTest
+class ArrayCacheLockTest extends LockTestCase
 {
        protected function getInstance()
        {
-               return new \Friendica\Core\Lock\Type\CacheLock(new ArrayCache('localhost'));
+               return new CacheLock(new ArrayCache('localhost'));
        }
 
        /**

diff --git a/tests/src/Core/Lock/DatabaseLockDriverTest.php b/tests/src/Core/Lock/DatabaseLockDriverTest.php
index b4dc526b890a183c8b6c516e483e2656b5ec1a5d..ebc2b0090fbf7438ef0b71824ebce4c41eb52000 100644 (file)
--- a/tests/src/Core/Lock/DatabaseLockDriverTest.php
+++ b/tests/src/Core/Lock/DatabaseLockDriverTest.php
@@ -8,9 +8,10 @@
 namespace Friendica\Test\src\Core\Lock;
 
 use Friendica\Core\Lock\Type\DatabaseLock;
+use Friendica\Test\LockTestCase;
 use Friendica\Test\Util\CreateDatabaseTrait;
 
-class DatabaseLockDriverTest extends LockTest
+class DatabaseLockDriverTest extends LockTestCase
 {
        use CreateDatabaseTrait;
 

diff --git a/tests/src/Core/Lock/LockTest.php b/tests/src/Core/Lock/LockTest.php
deleted file mode 100644 (file)
index c32f50e..0000000
--- a/tests/src/Core/Lock/LockTest.php
+++ /dev/null
@@ -1,208 +0,0 @@
-<?php
-
-// Copyright (C) 2010-2024, the Friendica project
-// SPDX-FileCopyrightText: 2010-2024 the Friendica project
-//
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-namespace Friendica\Test\src\Core\Lock;
-
-use Friendica\Core\Lock\Capability\ICanLock;
-use Friendica\Test\MockedTestCase;
-
-abstract class LockTest extends MockedTestCase
-{
-       /**
-        * @var int Start time of the mock (used for time operations)
-        */
-       protected $startTime = 1417011228;
-
-       /**
-        * @var ICanLock
-        */
-       protected $instance;
-
-       abstract protected function getInstance();
-
-       protected function setUp(): void
-       {
-               parent::setUp();
-
-               $this->instance = $this->getInstance();
-               $this->instance->releaseAll(true);
-       }
-
-       protected function tearDown(): void
-       {
-               $this->instance->releaseAll(true);
-               parent::tearDown();
-       }
-
-       /**
-        * @small
-        */
-       public function testLock()
-       {
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->isLocked('foo'));
-               self::assertFalse($this->instance->isLocked('bar'));
-       }
-
-       /**
-        * @small
-        */
-       public function testDoubleLock()
-       {
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->isLocked('foo'));
-               // We already locked it
-               self::assertTrue($this->instance->acquire('foo', 1));
-       }
-
-       /**
-        * @small
-        */
-       public function testReleaseLock()
-       {
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->isLocked('foo'));
-               $this->instance->release('foo');
-               self::assertFalse($this->instance->isLocked('foo'));
-       }
-
-       /**
-        * @small
-        */
-       public function testReleaseAll()
-       {
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->acquire('bar', 1));
-               self::assertTrue($this->instance->acquire('nice', 1));
-
-               self::assertTrue($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('bar'));
-               self::assertTrue($this->instance->isLocked('nice'));
-
-               self::assertTrue($this->instance->releaseAll());
-
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertFalse($this->instance->isLocked('bar'));
-               self::assertFalse($this->instance->isLocked('nice'));
-       }
-
-       /**
-        * @small
-        */
-       public function testReleaseAfterUnlock()
-       {
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertFalse($this->instance->isLocked('bar'));
-               self::assertFalse($this->instance->isLocked('nice'));
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->acquire('bar', 1));
-               self::assertTrue($this->instance->acquire('nice', 1));
-
-               self::assertTrue($this->instance->release('foo'));
-
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('bar'));
-               self::assertTrue($this->instance->isLocked('nice'));
-
-               self::assertTrue($this->instance->releaseAll());
-
-               self::assertFalse($this->instance->isLocked('bar'));
-               self::assertFalse($this->instance->isLocked('nice'));
-       }
-
-       /**
-        * @small
-        */
-       public function testReleaseWitTTL()
-       {
-               self::assertFalse($this->instance->isLocked('test'));
-               self::assertTrue($this->instance->acquire('test', 1, 10));
-               self::assertTrue($this->instance->isLocked('test'));
-               self::assertTrue($this->instance->release('test'));
-               self::assertFalse($this->instance->isLocked('test'));
-       }
-
-       /**
-        * @small
-        */
-       public function testGetLocks()
-       {
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->acquire('bar', 1));
-               self::assertTrue($this->instance->acquire('nice', 1));
-
-               self::assertTrue($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('bar'));
-               self::assertTrue($this->instance->isLocked('nice'));
-
-               $locks = $this->instance->getLocks();
-
-               self::assertContains('foo', $locks);
-               self::assertContains('bar', $locks);
-               self::assertContains('nice', $locks);
-       }
-
-       /**
-        * @small
-        */
-       public function testGetLocksWithPrefix()
-       {
-               self::assertTrue($this->instance->acquire('foo', 1));
-               self::assertTrue($this->instance->acquire('test1', 1));
-               self::assertTrue($this->instance->acquire('test2', 1));
-
-               self::assertTrue($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('test1'));
-               self::assertTrue($this->instance->isLocked('test2'));
-
-               $locks = $this->instance->getLocks('test');
-
-               self::assertContains('test1', $locks);
-               self::assertContains('test2', $locks);
-               self::assertNotContains('foo', $locks);
-       }
-
-       /**
-        * @medium
-        */
-       public function testLockTTL()
-       {
-               static::markTestSkipped('taking too much time without mocking');
-
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertFalse($this->instance->isLocked('bar'));
-
-               // TODO [nupplaphil] - Because of the Datetime-Utils for the database, we have to wait a FULL second between the checks to invalidate the db-locks/cache
-               self::assertTrue($this->instance->acquire('foo', 2, 1));
-               self::assertTrue($this->instance->acquire('bar', 2, 3));
-
-               self::assertTrue($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('bar'));
-
-               sleep(2);
-
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertTrue($this->instance->isLocked('bar'));
-
-               sleep(2);
-
-               self::assertFalse($this->instance->isLocked('foo'));
-               self::assertFalse($this->instance->isLocked('bar'));
-       }
-
-       /**
-        * Test if releasing a non-existing lock doesn't throw errors
-        */
-       public function testReleaseLockWithoutLock()
-       {
-               self::assertFalse($this->instance->isLocked('wrongLock'));
-               self::assertFalse($this->instance->release('wrongLock'));
-       }
-}

diff --git a/tests/src/Core/Lock/MemcacheCacheLockTest.php b/tests/src/Core/Lock/MemcacheCacheLockTest.php
index f23870779a89dbadfa842d9ec345c8640ce09a37..2bb0595cff3738a8ca0fd38863d1576b1ea5a5c1 100644 (file)
--- a/tests/src/Core/Lock/MemcacheCacheLockTest.php
+++ b/tests/src/Core/Lock/MemcacheCacheLockTest.php
@@ -11,13 +11,14 @@ use Exception;
 use Friendica\Core\Cache\Type\MemcacheCache;
 use Friendica\Core\Config\Capability\IManageConfigValues;
 use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\LockTestCase;
 use Mockery;
 
 /**
  * @requires extension Memcache
  * @group MEMCACHE
  */
-class MemcacheCacheLockTest extends LockTest
+class MemcacheCacheLockTest extends LockTestCase
 {
        protected function getInstance()
        {
@@ -39,7 +40,7 @@ class MemcacheCacheLockTest extends LockTest
 
                try {
                        $cache = new MemcacheCache($host, $configMock);
-                       $lock = new \Friendica\Core\Lock\Type\CacheLock($cache);
+                       $lock = new CacheLock($cache);
                } catch (Exception $e) {
                        static::markTestSkipped('Memcache is not available');
                }

diff --git a/tests/src/Core/Lock/MemcachedCacheLockTest.php b/tests/src/Core/Lock/MemcachedCacheLockTest.php
index 2936bfec9a6504e1c69b439f8e5a6b0073500b5d..fb38ec3312b12fc407bc25f7bddf77ed2498dae3 100644 (file)
--- a/tests/src/Core/Lock/MemcachedCacheLockTest.php
+++ b/tests/src/Core/Lock/MemcachedCacheLockTest.php
@@ -11,6 +11,7 @@ use Exception;
 use Friendica\Core\Cache\Type\MemcachedCache;
 use Friendica\Core\Config\Capability\IManageConfigValues;
 use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\LockTestCase;
 use Mockery;
 use Psr\Log\NullLogger;
 
@@ -18,7 +19,7 @@ use Psr\Log\NullLogger;
  * @requires extension memcached
  * @group MEMCACHED
  */
-class MemcachedCacheLockTest extends LockTest
+class MemcachedCacheLockTest extends LockTestCase
 {
        protected function getInstance()
        {

diff --git a/tests/src/Core/Lock/RedisCacheLockTest.php b/tests/src/Core/Lock/RedisCacheLockTest.php
index 834d2bb8c4bb173605cc18cb141dec56630b26ed..d0237682c3d5065404fd9d73d261a7dcd150a766 100644 (file)
--- a/tests/src/Core/Lock/RedisCacheLockTest.php
+++ b/tests/src/Core/Lock/RedisCacheLockTest.php
@@ -11,13 +11,14 @@ use Exception;
 use Friendica\Core\Cache\Type\RedisCache;
 use Friendica\Core\Config\Capability\IManageConfigValues;
 use Friendica\Core\Lock\Type\CacheLock;
+use Friendica\Test\LockTestCase;
 use Mockery;
 
 /**
  * @requires extension redis
  * @group REDIS
  */
-class RedisCacheLockTest extends LockTest
+class RedisCacheLockTest extends LockTestCase
 {
        protected function getInstance()
        {
@@ -48,7 +49,7 @@ class RedisCacheLockTest extends LockTest
 
                try {
                        $cache = new RedisCache($host, $configMock);
-                       $lock = new \Friendica\Core\Lock\Type\CacheLock($cache);
+                       $lock = new CacheLock($cache);
                } catch (Exception $e) {
                        static::markTestSkipped('Redis is not available. Error: ' . $e->getMessage());
                }

diff --git a/tests/src/Core/Lock/SemaphoreLockTest.php b/tests/src/Core/Lock/SemaphoreLockTest.php
index 407e68afaf46da25f055aa765c2e407591a06343..06b4e02f46a57568a0204960b89fce81c51afecb 100644 (file)
--- a/tests/src/Core/Lock/SemaphoreLockTest.php
+++ b/tests/src/Core/Lock/SemaphoreLockTest.php
@@ -12,12 +12,14 @@ use Friendica\App;
 use Friendica\Core\Config\Capability\IManageConfigValues;
 use Friendica\Core\Config\Model\ReadOnlyFileConfig;
 use Friendica\Core\Config\ValueObject\Cache;
+use Friendica\Core\Lock\Type\SemaphoreLock;
 use Friendica\Core\System;
 use Friendica\DI;
+use Friendica\Test\LockTestCase;
 use Mockery;
 use Mockery\MockInterface;
 
-class SemaphoreLockTest extends LockTest
+class SemaphoreLockTest extends LockTestCase
 {
        protected function setUp(): void
        {
@@ -40,7 +42,7 @@ class SemaphoreLockTest extends LockTest
 
        protected function getInstance()
        {
-               return new \Friendica\Core\Lock\Type\SemaphoreLock();
+               return new SemaphoreLock();
        }
 
        /**