Code Duplication - CMProductions/cache - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 116-116 lines in 2 locations

features/bootstrap/FeatureContext.php 1 location


use Behat\Behat\Context\SnippetAcceptingContext;
use Cmp\Cache\Infrastructure\RedisCache;

class FeatureContext implements SnippetAcceptingContext
{
    /**
     * @var \Redis
     */
    private $redis;

    /**
     * @var RedisCache
     */
    private $backend;

    /**
     * @var string
     */
    private $result;

    /**
     * FeatureContext constructor.
     */
    public function __construct()
    {
        $this->redis = new \Redis();
        $this->redis->connect($_SERVER['REDIS_HOST'], 6379);
        $this->backend = new RedisCache($this->redis);
    }

    /**
     * @BeforeScenario
     */
    public function reset()
    {
        $this->redis->flushDB();
    }

    /**
     * @Given The cache is empty
     */
    public function theCacheIsEmpty()
    {
        $this->redis->flushDB();
    }

    /**
     * @Given I store a an item in the cache
     */
    public function iStoreAAnItemInTheCache()
    {
        $this->backend->set('foo', 'bar');
    }

    /**
     * @When I retrieve it
     */
    public function whenIRetrieved()
    {
        $this->result = $this->backend->get('foo');
    }

    /**
     * @Then I should get the same item
     */
    public function iShouldGetTheSameItem()
    {
        if ($this->result !== 'bar') {
            throw new \RuntimeException("The retrieve item is not the same");
        }
    }

    /**
     * @param $timeToLive
     *
     * @Given I store a an item in the cache for :timeToLive second
     */
    public function iStoreAAnItemInTheCacheForSecond($timeToLive)
    {
        $this->backend->set('foo', 'bar', $timeToLive);
    }

    /**
     * @param $seconds
     *
     * @When I wait :seconds seconds
     */
    public function iWaitSeconds($seconds)
    {
        sleep($seconds);
    }

    /**
     * @Then I should not be able to retrieve it
     */
    public function iShouldNotBeAbleToRetrieveIt()
    {
        if ($this->backend->has('foo')) {
            throw new \RuntimeException("Redis still has the item stored");
        }
    }

    /**
     * @When I delete the item from the cache
     */
    public function iDeleteTheItemFromTheCache()
    {
        $this->backend->delete('foo');
    }

    /**
     * @When I flush all the items item from the cache
     */
    public function iFlushAllTheItemsItemFromTheCache()
    {
        $this->backend->flush();
    }

}

tests/features/bootstrap/FeatureContextBack.php 1 location


use Behat\Behat\Context\SnippetAcceptingContext;
use Cmp\Cache\Infrastructure\RedisCache;

class FeatureContextBackup implements SnippetAcceptingContext
{
    /**
     * @var \Redis
     */
    private $redis;

    /**
     * @var RedisCache
     */
    private $backend;

    /**
     * @var string
     */
    private $result;

    /**
     * FeatureContext constructor.
     */
    public function __construct()
    {
        $this->redis = new \Redis();
        $this->redis->connect($_SERVER['REDIS_HOST'], 6379);
        $this->backend = new RedisCache($this->redis); 
    }

    /**
     * @BeforeScenario
     */
    public function reset()
    {
        $this->redis->flushDB();
    }

    /**
     * @Given The cache is empty
     */
    public function theCacheIsEmpty()
    {
        $this->redis->flushDB();
    }

    /**
     * @Given I store a an item in the cache
     */
    public function iStoreAAnItemInTheCache()
    {
        $this->backend->set('foo', 'bar');
    }

    /**
     * @When I retrieve it
     */
    public function whenIRetrieved()
    {
        $this->result = $this->backend->get('foo');
    }

    /**
     * @Then I should get the same item
     */
    public function iShouldGetTheSameItem()
    {
        if ($this->result !== 'bar') {
            throw new \RuntimeException("The retrieve item is not the same");
        }
    }

    /**
     * @param $timeToLive
     * 
     * @Given I store a an item in the cache for :timeToLive second
     */
    public function iStoreAAnItemInTheCacheForSecond($timeToLive)
    {
        $this->backend->set('foo', 'bar', $timeToLive);
    }

    /**
     * @param $seconds
     * 
     * @When I wait :seconds seconds
     */
    public function iWaitSeconds($seconds)
    {
        sleep($seconds);
    }

    /**
     * @Then I should not be able to retrieve it
     */
    public function iShouldNotBeAbleToRetrieveIt()
    {
        if ($this->backend->has('foo')) {
            throw new \RuntimeException("Redis still has the item stored");
        }
    }

    /**
     * @When I delete the item from the cache
     */
    public function iDeleteTheItemFromTheCache()
    {
        $this->backend->delete('foo');
    }

    /**
     * @When I flush all the items item from the cache
     */
    public function iFlushAllTheItemsItemFromTheCache()
    {
        $this->backend->flush();
    }

}

		@@ 6-121 (lines=116) @@
3		use Behat\Behat\Context\SnippetAcceptingContext;
4		use Cmp\Cache\Infrastructure\RedisCache;
5
6		class FeatureContext implements SnippetAcceptingContext
7		{
8		/**
9		* @var \Redis
10		*/
11		private $redis;
12
13		/**
14		* @var RedisCache
15		*/
16		private $backend;
17
18		/**
19		* @var string
20		*/
21		private $result;
22
23		/**
24		* FeatureContext constructor.
25		*/
26		public function __construct()
27		{
28		$this->redis = new \Redis();
29		$this->redis->connect($_SERVER['REDIS_HOST'], 6379);
30		$this->backend = new RedisCache($this->redis);
31		}
32
33		/**
34		* @BeforeScenario
35		*/
36		public function reset()
37		{
38		$this->redis->flushDB();
39		}
40
41		/**
42		* @Given The cache is empty
43		*/
44		public function theCacheIsEmpty()
45		{
46		$this->redis->flushDB();
47		}
48
49		/**
50		* @Given I store a an item in the cache
51		*/
52		public function iStoreAAnItemInTheCache()
53		{
54		$this->backend->set('foo', 'bar');
55		}
56
57		/**
58		* @When I retrieve it
59		*/
60		public function whenIRetrieved()
61		{
62		$this->result = $this->backend->get('foo');
63		}
64
65		/**
66		* @Then I should get the same item
67		*/
68		public function iShouldGetTheSameItem()
69		{
70		if ($this->result !== 'bar') {
71		throw new \RuntimeException("The retrieve item is not the same");
72		}
73		}
74
75		/**
76		* @param $timeToLive
77		*
78		* @Given I store a an item in the cache for :timeToLive second
79		*/
80		public function iStoreAAnItemInTheCacheForSecond($timeToLive)
81		{
82		$this->backend->set('foo', 'bar', $timeToLive);
83		}
84
85		/**
86		* @param $seconds
87		*
88		* @When I wait :seconds seconds
89		*/
90		public function iWaitSeconds($seconds)
91		{
92		sleep($seconds);
93		}
94
95		/**
96		* @Then I should not be able to retrieve it
97		*/
98		public function iShouldNotBeAbleToRetrieveIt()
99		{
100		if ($this->backend->has('foo')) {
101		throw new \RuntimeException("Redis still has the item stored");
102		}
103		}
104
105		/**
106		* @When I delete the item from the cache
107		*/
108		public function iDeleteTheItemFromTheCache()
109		{
110		$this->backend->delete('foo');
111		}
112
113		/**
114		* @When I flush all the items item from the cache
115		*/
116		public function iFlushAllTheItemsItemFromTheCache()
117		{
118		$this->backend->flush();
119		}
120
121		}

		@@ 8-123 (lines=116) @@
5		use Behat\Behat\Context\SnippetAcceptingContext;
6		use Cmp\Cache\Infrastructure\RedisCache;
7
8		class FeatureContextBackup implements SnippetAcceptingContext
9		{
10		/**
11		* @var \Redis
12		*/
13		private $redis;
14
15		/**
16		* @var RedisCache
17		*/
18		private $backend;
19
20		/**
21		* @var string
22		*/
23		private $result;
24
25		/**
26		* FeatureContext constructor.
27		*/
28		public function __construct()
29		{
30		$this->redis = new \Redis();
31		$this->redis->connect($_SERVER['REDIS_HOST'], 6379);
32		$this->backend = new RedisCache($this->redis);
33		}
34
35		/**
36		* @BeforeScenario
37		*/
38		public function reset()
39		{
40		$this->redis->flushDB();
41		}
42
43		/**
44		* @Given The cache is empty
45		*/
46		public function theCacheIsEmpty()
47		{
48		$this->redis->flushDB();
49		}
50
51		/**
52		* @Given I store a an item in the cache
53		*/
54		public function iStoreAAnItemInTheCache()
55		{
56		$this->backend->set('foo', 'bar');
57		}
58
59		/**
60		* @When I retrieve it
61		*/
62		public function whenIRetrieved()
63		{
64		$this->result = $this->backend->get('foo');
65		}
66
67		/**
68		* @Then I should get the same item
69		*/
70		public function iShouldGetTheSameItem()
71		{
72		if ($this->result !== 'bar') {
73		throw new \RuntimeException("The retrieve item is not the same");
74		}
75		}
76
77		/**
78		* @param $timeToLive
79		*
80		* @Given I store a an item in the cache for :timeToLive second
81		*/
82		public function iStoreAAnItemInTheCacheForSecond($timeToLive)
83		{
84		$this->backend->set('foo', 'bar', $timeToLive);
85		}
86
87		/**
88		* @param $seconds
89		*
90		* @When I wait :seconds seconds
91		*/
92		public function iWaitSeconds($seconds)
93		{
94		sleep($seconds);
95		}
96
97		/**
98		* @Then I should not be able to retrieve it
99		*/
100		public function iShouldNotBeAbleToRetrieveIt()
101		{
102		if ($this->backend->has('foo')) {
103		throw new \RuntimeException("Redis still has the item stored");
104		}
105		}
106
107		/**
108		* @When I delete the item from the cache
109		*/
110		public function iDeleteTheItemFromTheCache()
111		{
112		$this->backend->delete('foo');
113		}
114
115		/**
116		* @When I flush all the items item from the cache
117		*/
118		public function iFlushAllTheItemsItemFromTheCache()
119		{
120		$this->backend->flush();
121		}
122
123		}

CMProductions / cache

GitHub Access Token became invalid

Code Duplication Length = 116-116 lines in 2 locations

features/bootstrap/FeatureContext.php 1 location

tests/features/bootstrap/FeatureContextBack.php 1 location