Add Lock test

diff --git a/src/Console/Lock.php b/src/Console/Lock.php
index fe9132b7cb86ca3388ea5633f22a02b9e739b839..46826cc8c92a384981daef2c055b5e11ccc0af0a 100644 (file)
--- a/src/Console/Lock.php
+++ b/src/Console/Lock.php
@@ -32,7 +32,7 @@ class Lock extends \Asika\SimpleConsole\Console
        protected function getHelp()
        {
                $help = <<<HELP
-console cache - Manage node cache
+console lock - Manage node locks
 Synopsis
        bin/console lock list [<prefix>] [-h|--help|-?] [-v]
        bin/console lock set <lock> [<timeout> [<ttl>]] [-h|--help|-?] [-v]
@@ -131,9 +131,9 @@ HELP;
        private function executeDel()
        {
                if (count($this->args) >= 2) {
-                       $lock   = $this->getArgument(1);
+                       $lock = $this->getArgument(1);
 
-                       if ($this->lock->releaseLock($lock, true)){
+                       if ($this->lock->releaseLock($lock, true)) {
                                $this->out(sprintf('Lock \'%s\' released.', $lock));
                        } else {
                                $this->out(sprintf('Couldn\'t release Lock \'%s\'', $lock));
@@ -147,11 +147,11 @@ HELP;
        private function executeSet()
        {
                if (count($this->args) >= 2) {
-                       $lock      = $this->getArgument(1);
+                       $lock    = $this->getArgument(1);
                        $timeout = intval($this->getArgument(2, false));
-                       $ttl = intval($this->getArgument(3, false));
+                       $ttl     = intval($this->getArgument(3, false));
 
-                       if (is_array($this->lock->isLocked($lock))) {
+                       if ($this->lock->isLocked($lock)) {
                                throw new RuntimeException(sprintf('\'%s\' is already set.', $lock));
                        }
 
@@ -166,7 +166,7 @@ HELP;
                        if ($result) {
                                $this->out(sprintf('Lock \'%s\' acquired.', $lock));
                        } else {
-                               $this->out(sprintf('Unable to lock \'%s\'', $lock));
+                               throw new RuntimeException(sprintf('Unable to lock \'%s\'.', $lock));
                        }
                } else {
                        throw new CommandArgsException('Too few arguments for set.');
@@ -177,9 +177,9 @@ HELP;
        {
                $result = $this->lock->releaseAll(true);
                if ($result) {
-                       $this->out('Locks successfully cleared,');
+                       $this->out('Locks successfully cleared.');
                } else {
-                       $this->out('Unable to clear the locks.');
+                       throw new RuntimeException('Unable to clear the locks.');
                }
        }
 }

diff --git a/tests/src/Console/LockConsoleTest.php b/tests/src/Console/LockConsoleTest.php
new file mode 100644 (file)
index 0000000..51c05b5
--- /dev/null
+++ b/tests/src/Console/LockConsoleTest.php
@@ -0,0 +1,215 @@
+<?php
+
+namespace Friendica\Test\src\Console;
+
+use Friendica\App;
+use Friendica\App\Mode;
+use Friendica\Console\Lock;
+use Friendica\Core\Lock\ILock;
+use Mockery\MockInterface;
+
+class LockConsoleTest extends ConsoleTest
+{
+       /**
+        * @var App\Mode|MockInterface $appMode
+        */
+       private $appMode;
+
+       /**
+        * @var ILock|MockInterface
+        */
+       private $lockMock;
+
+       protected function setUp()
+       {
+               parent::setUp();
+
+               \Mockery::getConfiguration()->setConstantsMap([
+                       Mode::class => [
+                               'DBCONFIGAVAILABLE' => 0
+                       ]
+               ]);
+
+               $this->appMode = \Mockery::mock(App\Mode::class);
+               $this->appMode->shouldReceive('has')
+                       ->andReturn(true);
+
+               $this->lockMock = \Mockery::mock(ILock::class);
+       }
+
+       public function testList()
+       {
+               $this->lockMock
+                       ->shouldReceive('getLocks')
+                       ->andReturn(['test', 'test2'])
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'list');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Listing all Locks:\ntest\ntest2\n2 locks found\n", $txt);
+       }
+
+       public function testListPrefix()
+       {
+               $this->lockMock
+                       ->shouldReceive('getLocks')
+                       ->with('test')
+                       ->andReturn(['test', 'test2'])
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'list');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Listing all Locks starting with \"test\":\ntest\ntest2\n2 locks found\n", $txt);
+       }
+
+       public function testDelLock()
+       {
+               $this->lockMock
+                       ->shouldReceive('releaseLock')
+                       ->with('test', true)
+                       ->andReturn(true)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'del');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Lock 'test' released.\n", $txt);
+       }
+
+       public function testDelUnknownLock()
+       {
+               $this->lockMock
+                       ->shouldReceive('releaseLock')
+                       ->with('test', true)
+                       ->andReturn(false)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'del');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Couldn't release Lock 'test'\n", $txt);
+       }
+
+       public function testSetLock()
+       {
+               $this->lockMock
+                       ->shouldReceive('isLocked')
+                       ->with('test')
+                       ->andReturn(false)
+                       ->once();
+               $this->lockMock
+                       ->shouldReceive('acquireLock')
+                       ->with('test')
+                       ->andReturn(true)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'set');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Lock 'test' acquired.\n", $txt);
+       }
+
+       public function testSetLockIsLocked()
+       {
+               $this->lockMock
+                       ->shouldReceive('isLocked')
+                       ->with('test')
+                       ->andReturn(true)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'set');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("[Error] 'test' is already set.\n", $txt);
+       }
+
+       public function testSetLockNotWorking()
+       {
+               $this->lockMock
+                       ->shouldReceive('isLocked')
+                       ->with('test')
+                       ->andReturn(false)
+                       ->once();
+               $this->lockMock
+                       ->shouldReceive('acquireLock')
+                       ->with('test')
+                       ->andReturn(false)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'set');
+               $console->setArgument(1, 'test');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("[Error] Unable to lock 'test'.\n", $txt);
+       }
+
+       public function testReleaseAll()
+       {
+               $this->lockMock
+                       ->shouldReceive('releaseAll')
+                       ->andReturn(true)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'clear');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("Locks successfully cleared.\n", $txt);
+       }
+
+       public function testReleaseAllFailed()
+       {
+               $this->lockMock
+                       ->shouldReceive('releaseAll')
+                       ->andReturn(false)
+                       ->once();
+
+               $console = new Lock($this->appMode, $this->lockMock, $this->consoleArgv);
+               $console->setArgument(0, 'clear');
+               $txt = $this->dumpExecute($console);
+               $this->assertEquals("[Error] Unable to clear the locks.\n", $txt);
+       }
+
+       public function testGetHelp()
+       {
+               // Usable to purposely fail if new commands are added without taking tests into account
+               $theHelp = <<<HELP
+console lock - Manage node locks
+Synopsis
+       bin/console lock list [<prefix>] [-h|--help|-?] [-v]
+       bin/console lock set <lock> [<timeout> [<ttl>]] [-h|--help|-?] [-v]
+       bin/console lock del <lock> [-h|--help|-?] [-v]
+       bin/console lock clear [-h|--help|-?] [-v]
+
+Description
+       bin/console lock list [<prefix>]
+               List all locks, optionally filtered by a prefix
+
+       bin/console lock set <lock> [<timeout> [<ttl>]]
+               Sets manually a lock, optionally with the provided TTL (time to live) with a default of five minutes.
+
+       bin/console lock del <lock>
+               Deletes a lock.
+
+       bin/console lock clear
+               Clears all locks
+
+Options
+    -h|--help|-? Show help information
+    -v           Show more debug information.
+
+HELP;
+               $console = new Lock($this->appMode, $this->lockMock, [$this->consoleArgv]);
+               $console->setOption('help', true);
+
+               $txt = $this->dumpExecute($console);
+
+               $this->assertEquals($txt, $theHelp);
+       }
+}