RedisLockStrategyTest::tearDown() - Code Metrics - Inspection of "re-implementation with a REDIS list as a synchroni..." - tourstream/typo3-redis-lock-strategy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

unknown

created 2017-12-15 00:17 UTC

RedisLockStrategyTest::tearDown() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	0

<?php

namespace Tourstream\RedisLockStrategy\Tests;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2017 Alexander Miehe ([email protected])
 *  All rights reserved
 *
 *  You may not remove or change the name of the author above. See:
 *  http://www.gnu.org/licenses/gpl-faq.html#IWantCredit
 *
 *  This script is part of the Typo3 project. The Typo3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *  A copy is found in the LICENSE and distributed with these scripts.
 *
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use TYPO3\CMS\Core\Locking\LockFactory;
use TYPO3\CMS\Core\Locking\LockingStrategyInterface;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\TestingFramework\Core\Functional\FunctionalTestCase;

/**
 * @author Alexander Miehe <[email protected]>
 *
 * @covers \Tourstream\RedisLockStrategy\RedisLockStrategy
 */
class RedisLockStrategyTest extends FunctionalTestCase
{
    /**
     * @var LockFactory
     */
    private $lockFactory;
    private $redisHost;
    private $redisDatabase;

    /**
     * @test
     * @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
     * @expectedExceptionMessage no configuration for redis lock strategy found
     */
    public function shouldThrowExceptionBecauseConfigIsMissing()
    {
        $this->lockFactory->createLocker('test');
    }

    /**
     * @test
     * @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
     * @expectedExceptionMessage no configuration for redis lock strategy found
     */
    public function shouldThrowExceptionBecauseConfigIsNotAnArray()
    {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = 'test';
        $this->lockFactory->createLocker('test');
    }

    /**
     * @test
     * @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
     * @expectedExceptionMessage no host for redis lock strategy found
     */
    public function shouldThrowExceptionBecauseConfigHasNoHost()
    {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [];

        $this->lockFactory->createLocker('test');
    }

    /**
     * @test
     * @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
     * @expectedExceptionMessage no database for redis lock strategy found
     */
    public function shouldThrowExceptionBecauseConfigHasNoDatabase()
    {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [
            'host' => $this->redisHost,
        ];

        $this->lockFactory->createLocker('test');
    }

    /**
     * @test
     */
    public function shouldConnectAndAcquireAExistingLock()
    {
        $subject = uniqid();

        $locker = $this->getLocker($subject);

        self::assertTrue($locker->acquire());
    }


    /**
     * @test
     */
    public function shouldConnectAndAcquireALock()
    {
        $subject = uniqid();

        $locker = $this->getLocker($subject);

        $redis = $this->getRedisClient();

        self::assertTrue($redis->exists($subject));

        self::assertTrue($locker->acquire());
    }

    /**
     * @test
     */
    public function shouldConnectAndCheckIfLockIsAcquired()
    {
        $subject = uniqid();

        $locker = $this->getLocker($subject);

        $locker->acquire();

        self::assertTrue($locker->isAcquired());
    }

    /**
     * @test
     */
    public function shouldConnectAndDestroyALock()
    {
        $subject = uniqid();

        $locker = $this->getLocker($subject);

        $redis = $this->getRedisClient();

        $redis->set($subject, 'testvalue');

        $locker->destroy();

        self::assertFalse($redis->exists($subject));
    }

    /**
     * @test
     */
    public function shouldConnectAndDestroyANotExistingLock()
    {
        $subject = uniqid();

        $locker = $this->getLocker($subject);

        $redis = $this->getRedisClient();

        $locker->destroy();

        self::assertFalse($redis->exists($subject));
    }

    /**
     * @test
     */
    public function shouldAcquireNonBlockingAndReleaseMoreLocks()
    {
        $subject = uniqid();
$a = "a";
$ab = "ab";
$abc = "abc";
        $capabilities = LockingStrategyInterface::LOCK_CAPABILITY_EXCLUSIVE | LockingStrategyInterface::LOCK_CAPABILITY_NOBLOCK;


        $locker1 = $this->getLocker($subject);
        $locker2 = $this->getLocker($subject);
        $locker3 = $this->getLocker($subject);

        self::assertTrue($locker1->acquire($capabilities));
        self::expectException('\TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException') && $locker2->acquire($capabilities);

        self::expectException('\TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException') && $locker3->acquire($capabilities);


        self::assertTrue($locker1->isAcquired());
        self::assertFalse($locker2->isAcquired());
        self::assertFalse($locker3->isAcquired());

        self::assertTrue($locker1->release());
        self::assertTrue($locker2->acquire($capabilities));
        self::assertTrue($locker3->release());

        self::assertTrue($locker1->acquire($capabilities);

        self::assertTrue($locker2->release());
        self::assertTrue($locker3->acquire($capabilities));

        self::assertTrue($locker1->isAcquired());
        self::assertFalse($locker2->isAcquired());
        self::assertTrue($locker3->isAcquired());
    }

    protected function setUp()
    {
        $this->testExtensionsToLoad[] = 'typo3conf/ext/redis_lock_strategy';
        $this->redisHost              = getenv('typo3RedisHost');
        $this->redisDatabase          = getenv('typo3RedisDatabase');

        parent::setUp();

        $this->lockFactory = GeneralUtility::makeInstance(LockFactory::class);
    }

    protected function tearDown()
    {
        parent::tearDown();

        $this->getRedisClient()->flushDB();
    }

    /**
     * @return \Redis
     */
    private function getRedisClient()
    {
        $redis = new \Redis();
        $redis->connect($this->redisHost);
        $redis->select($this->redisDatabase);

        return $redis;
    }

    /**
     * @param string $id Locker id
     *
     * @return \TYPO3\CMS\Core\Locking\LockingStrategyInterface
     */
    private function getLocker($id)
    {
        $GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [
            'host'     => $this->redisHost,
            'port'     => 6379,
            'database' => $this->redisDatabase,
        ];

        return $this->lockFactory->createLocker($id);
    }

}


1			<?php
2
3			namespace Tourstream\RedisLockStrategy\Tests;
4
5			/***************************************************************
6			* Copyright notice
7			*
8			* (c) 2017 Alexander Miehe ([email protected])
9			* All rights reserved
10			*
11			* You may not remove or change the name of the author above. See:
12			* http://www.gnu.org/licenses/gpl-faq.html#IWantCredit
13			*
14			* This script is part of the Typo3 project. The Typo3 project is
15			* free software; you can redistribute it and/or modify
16			* it under the terms of the GNU General Public License as published by
17			* the Free Software Foundation; either version 3 of the License, or
18			* (at your option) any later version.
19			*
20			* The GNU General Public License can be found at
21			* http://www.gnu.org/copyleft/gpl.html.
22			* A copy is found in the LICENSE and distributed with these scripts.
23			*
24			*
25			* This script is distributed in the hope that it will be useful,
26			* but WITHOUT ANY WARRANTY; without even the implied warranty of
27			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28			* GNU General Public License for more details.
29			*
30			* This copyright notice MUST APPEAR in all copies of the script!
31			***************************************************************/
32
33			use TYPO3\CMS\Core\Locking\LockFactory;
34			use TYPO3\CMS\Core\Locking\LockingStrategyInterface;
35			use TYPO3\CMS\Core\Utility\GeneralUtility;
36			use TYPO3\TestingFramework\Core\Functional\FunctionalTestCase;
37
38			/**
39			* @author Alexander Miehe <[email protected]>
40			*
41			* @covers \Tourstream\RedisLockStrategy\RedisLockStrategy
42			*/
43			class RedisLockStrategyTest extends FunctionalTestCase
44			{
45			/**
46			* @var LockFactory
47			*/
48			private $lockFactory;
49			private $redisHost;
50			private $redisDatabase;
51
52			/**
53			* @test
54			* @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
55			* @expectedExceptionMessage no configuration for redis lock strategy found
56			*/
57			public function shouldThrowExceptionBecauseConfigIsMissing()
58			{
59			$this->lockFactory->createLocker('test');
60			}
61
62			/**
63			* @test
64			* @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
65			* @expectedExceptionMessage no configuration for redis lock strategy found
66			*/
67			public function shouldThrowExceptionBecauseConfigIsNotAnArray()
68			{
69			$GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = 'test';
70			$this->lockFactory->createLocker('test');
71			}
72
73			/**
74			* @test
75			* @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
76			* @expectedExceptionMessage no host for redis lock strategy found
77			*/
78			public function shouldThrowExceptionBecauseConfigHasNoHost()
79			{
80			$GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [];
81
82			$this->lockFactory->createLocker('test');
83			}
84
85			/**
86			* @test
87			* @expectedException \TYPO3\CMS\Core\Locking\Exception\LockCreateException
88			* @expectedExceptionMessage no database for redis lock strategy found
89			*/
90			public function shouldThrowExceptionBecauseConfigHasNoDatabase()
91			{
92			$GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [
93			'host' => $this->redisHost,
94			];
95
96			$this->lockFactory->createLocker('test');
97			}
98
99			/**
100			* @test
101			*/
102			public function shouldConnectAndAcquireAExistingLock()
103			{
104			$subject = uniqid();
105
106			$locker = $this->getLocker($subject);
107
108			self::assertTrue($locker->acquire());
109			}
110
111
112			/**
113			* @test
114			*/
115			public function shouldConnectAndAcquireALock()
116			{
117			$subject = uniqid();
118
119			$locker = $this->getLocker($subject);
120
121			$redis = $this->getRedisClient();
122
123			self::assertTrue($redis->exists($subject));
124
125			self::assertTrue($locker->acquire());
126			}
127
128			/**
129			* @test
130			*/
131			public function shouldConnectAndCheckIfLockIsAcquired()
132			{
133			$subject = uniqid();
134
135			$locker = $this->getLocker($subject);
136
137			$locker->acquire();
138
139			self::assertTrue($locker->isAcquired());
140			}
141
142			/**
143			* @test
144			*/
145			public function shouldConnectAndDestroyALock()
146			{
147			$subject = uniqid();
148
149			$locker = $this->getLocker($subject);
150
151			$redis = $this->getRedisClient();
152
153			$redis->set($subject, 'testvalue');
154
155			$locker->destroy();
156
157			self::assertFalse($redis->exists($subject));
158			}
159
160			/**
161			* @test
162			*/
163			public function shouldConnectAndDestroyANotExistingLock()
164			{
165			$subject = uniqid();
166
167			$locker = $this->getLocker($subject);
168
169			$redis = $this->getRedisClient();
170
171			$locker->destroy();
172
173			self::assertFalse($redis->exists($subject));
174			}
175
176			/**
177			* @test
178			*/
179			public function shouldAcquireNonBlockingAndReleaseMoreLocks()
180			{
181			$subject = uniqid();
			0 ignored issues – show Coding Style introduced 2017-12-14 23:58 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
182			$capabilities = LockingStrategyInterface::LOCK_CAPABILITY_EXCLUSIVE \| LockingStrategyInterface::LOCK_CAPABILITY_NOBLOCK;
			0 ignored issues – show Coding Style introduced 2017-12-14 23:58 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 128 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
183
184			$locker1 = $this->getLocker($subject);
185			$locker2 = $this->getLocker($subject);
186			$locker3 = $this->getLocker($subject);
187
188			self::assertTrue($locker1->acquire($capabilities));
189			self::expectException('\TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException') && $locker2->acquire($capabilities);
			0 ignored issues – show Coding Style introduced 2017-12-15 00:10 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 134 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
190			self::expectException('\TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException') && $locker3->acquire($capabilities);
			0 ignored issues – show Coding Style introduced 2017-12-15 00:10 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 134 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
191
192			self::assertTrue($locker1->isAcquired());
193			self::assertFalse($locker2->isAcquired());
194			self::assertFalse($locker3->isAcquired());
195
196			self::assertTrue($locker1->release());
197			self::assertTrue($locker2->acquire($capabilities));
198			self::assertTrue($locker3->release());
199
200			self::assertTrue($locker1->acquire($capabilities);
			0 ignored issues – show Bug introduced 2017-12-15 00:18 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected ';', expecting ',' or ')' Loading history...
201			self::assertTrue($locker2->release());
202			self::assertTrue($locker3->acquire($capabilities));
203
204			self::assertTrue($locker1->isAcquired());
205			self::assertFalse($locker2->isAcquired());
206			self::assertTrue($locker3->isAcquired());
207			}
208
209			protected function setUp()
210			{
211			$this->testExtensionsToLoad[] = 'typo3conf/ext/redis_lock_strategy';
212			$this->redisHost = getenv('typo3RedisHost');
213			$this->redisDatabase = getenv('typo3RedisDatabase');
214
215			parent::setUp();
216
217			$this->lockFactory = GeneralUtility::makeInstance(LockFactory::class);
218			}
219
220			protected function tearDown()
221			{
222			parent::tearDown();
223
224			$this->getRedisClient()->flushDB();
225			}
226
227			/**
228			* @return \Redis
229			*/
230			private function getRedisClient()
231			{
232			$redis = new \Redis();
233			$redis->connect($this->redisHost);
234			$redis->select($this->redisDatabase);
235
236			return $redis;
237			}
238
239			/**
240			* @param string $id Locker id
241			*
242			* @return \TYPO3\CMS\Core\Locking\LockingStrategyInterface
243			*/
244			private function getLocker($id)
245			{
246			$GLOBALS['TYPO3_CONF_VARS']['SYS']['redis_lock'] = [
247			'host' => $this->redisHost,
248			'port' => 6379,
249			'database' => $this->redisDatabase,
250			];
251
252			return $this->lockFactory->createLocker($id);
253			}
254
255			}
256

tourstream / typo3-redis-lock-strategy

Pull Request — master (#8)

RedisLockStrategyTest::tearDown() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like