FeatureContext

Complexity

Total Complexity

20

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes	5
Bugs	1	Features	2

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	reset()	0	4	1
A	iStoreAAnItemInTheCache()	0	4	1
A	whenIRetrieved()	0	4	1
A	iShouldGetTheSameItem()	0	6	2
A	iStoreAAnItemInTheCacheForSecond()	0	4	1
A	iWaitSeconds()	0	4	1
A	iShouldNotBeAbleToRetrieveIt()	0	6	2
A	iDeleteTheItemFromTheCache()	0	4	1
A	iStoreTwoItemsInTheCache()	0	5	1
A	iDeleteTheTwoItemsFromTheCache()	0	4	1
A	iShouldNotBeAbleToRetrieveAnyOfThem()	0	8	3
A	iFlushAllTheItemsItemFromTheCache()	0	4	1
A	iRequestANewRedisCacheInstanceToTheFactory()	0	10	2
A	doNothing()	0	4	1

<?php

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

/**
 * Class FeatureContext
 */
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 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->demand('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');
    }

    /**
     * @Given I store two items in the cache
     */
    public function iStoreTwoItemsInTheCache()
    {
        $this->backend->set('foo', 'bar');
        $this->backend->set('bar', 'foo');
    }

    /**
     * @When I delete the two items from the cache
     */
    public function iDeleteTheTwoItemsFromTheCache()
    {
        $this->backend->deleteItems(['foo', 'bar']);
    }

    /**
     * @Then I should not be able to retrieve any of them
     */
    public function iShouldNotBeAbleToRetrieveAnyOfThem()
    {
        $items = $this->backend->getItems(['foo', 'bar']);

        if ($items['foo'] !== null || $items['bar'] !== null) {
            throw new RuntimeException("There should not be any item on the cache");
        }
    }

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

    /**
     * @When I request a new redis cache instance to the factory
     */
    public function iRequestANewRedisCacheInstanceToTheFactory()
    {
        $redis = (new \Cmp\Cache\Factory\CacheBuilder())
            ->withRedisCacheFromParams($_SERVER['REDIS_HOST'], 6379, 1)
            ->build();

        if (!$redis instanceof RedisCache) {
            throw new RuntimeException("The factory could not create a RedisCache");
        }
    }

    /**
     * @Given I have the connection parameters for redis
     * @Then I should receive a redis cache already connected
     */
    public function doNothing()
    {

    }
}