FeatureContext

Complexity

Total Complexity

13

Size/Duplication

Total Lines	116
Duplicated Lines	100 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	6	6	1
A	reset()	4	4	1
A	theCacheIsEmpty()	4	4	1
A	iStoreAAnItemInTheCache()	4	4	1
A	whenIRetrieved()	4	4	1
A	iShouldGetTheSameItem()	6	6	2
A	iStoreAAnItemInTheCacheForSecond()	4	4	1
A	iWaitSeconds()	4	4	1
A	iShouldNotBeAbleToRetrieveIt()	6	6	2
A	iDeleteTheItemFromTheCache()	4	4	1
A	iFlushAllTheItemsItemFromTheCache()	4	4	1

<?php

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

class FeatureContext implements SnippetAcceptingContext

This class seems to be duplicated in your project.

{
    /**
     * @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();
    }

}