Knp\FriendlyContexts\Context\EntityContext

Complexity

Total Complexity

27

Size/Duplication

Total Lines	239
Duplicated Lines	3.35 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes	11
Bugs	5	Features	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	beforeScenario()	0	17	4
A	getMetadata()	0	4	1
A	getEntityManagers()	0	4	1
A	getConnections()	0	4	1
B	theFollowing()	8	32	3
A	thereIs()	0	21	2
B	thereIsLikeFollowing()	0	27	2
B	entitiesShouldHaveBeen()	0	41	3
A	existLikeFollowing()	0	21	3
A	afterScenario()	0	6	1
A	compareArray()	0	11	3
A	getDefaultOptions()	0	6	1
A	clean()	0	4	2

<?php

namespace Knp\FriendlyContexts\Context;

use Behat\Gherkin\Node\TableNode;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\SchemaTool;

class EntityContext extends Context
{
    /**
     * @Given /^the following ([\w ]+):?$/
     */
    public function theFollowing($name, TableNode $table)
    {
        $entityName = $this->resolveEntity($name)->getName();

        $rows = $table->getRows();

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $headers = array_shift($rows);

        foreach ($rows as $row) {
            $values     = array_combine($headers, $row);
            $entity     = new $entityName;
            $reflection = new \ReflectionClass($entity);

            do {

This code seems to be duplicated across your project.

                $this
                    ->getRecordBag()
                    ->getCollection($reflection->getName())
                    ->attach($entity, $values)
                ;
                $reflection = $reflection->getParentClass();
            } while (false !== $reflection);

            $this
                ->getEntityHydrator()
                ->hydrate($this->getEntityManager(), $entity, $values)
                ->completeRequired($this->getEntityManager(), $entity)
            ;

            $this->getEntityManager()->persist($entity);
        }

        $this->getEntityManager()->flush();
    }

    /**
     * @Given /^there (?:is|are) (\d+) ((?!\w* like)\w*)$/
     */
    public function thereIs($nbr, $name)
    {
        $entityName = $this->resolveEntity($name)->getName();

        for ($i = 0; $i < $nbr; $i++) {
            $entity = new $entityName;
            $this
                ->getRecordBag()
                ->getCollection($entityName)
                ->attach($entity)
            ;
            $this
                ->getEntityHydrator()
                ->completeRequired($this->getEntityManager(), $entity)
            ;

            $this->getEntityManager()->persist($entity);
        }

        $this->getEntityManager()->flush();
    }

    /**
     * @Given /^there (?:is|are) (\d+) (.*) like:?$/
     */
    public function thereIsLikeFollowing($nbr, $name, TableNode $table)
    {
        $entityName = $this->resolveEntity($name)->getName();

        $rows = $table->getRows();

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $headers = array_shift($rows);

        for ($i = 0; $i < $nbr; $i++) {
            $row = $rows[$i % count($rows)];

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

            $values = array_combine($headers, $row);
            $entity = new $entityName;
            $this
                ->getRecordBag()
                ->getCollection($entityName)
                ->attach($entity, $values)
            ;
            $this
                ->getEntityHydrator()
                ->hydrate($this->getEntityManager(), $entity, $values)
                ->completeRequired($this->getEntityManager(), $entity)
            ;

            $this->getEntityManager()->persist($entity);
        }

        $this->getEntityManager()->flush();
    }

    /**
     * @Given /^(\w+) (.+) should have been (created|deleted)$/
     */
    public function entitiesShouldHaveBeen($expected, $entity, $state)
    {
        $expected = (int) $expected;

        $entityName = $this->resolveEntity($entity)->getName();
        $collection = $this
            ->getRecordBag()
            ->getCollection($entityName)
        ;

        $records = array_map(function ($e) { return $e->getEntity(); }, $collection->all());
        $entities = $this
            ->getEntityManager()
            ->getRepository($entityName)
            ->createQueryBuilder('o')
            ->resetDQLParts()
            ->select('o')
            ->from($entityName, ' o')
            ->getQuery()
            ->getResult()
        ;

        if ($state === 'created') {
            $diff = $this->compareArray($entities, $records);
            foreach ($diff as $e) {
                $collection->attach($e);
            }
        } else {
            $diff = $this->compareArray($records, $entities);
        }
        $real = count($diff);

        $this
            ->getAsserter()
            ->assertEquals(
                $real,
                $expected,
                sprintf('%s %s should have been %s, %s actually', $expected, $entity, $state, $real)
            )
        ;
    }

    /**
     * @Then /^should be (\d+) (.*) like:?$/
     */
    public function existLikeFollowing($nbr, $name, TableNode $table)
    {
        $entityName = $this->resolveEntity($name)->getName();

        $rows = $table->getRows();

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $headers = array_shift($rows);

        for ($i = 0; $i < $nbr; $i++) {
            $row = $rows[$i % count($rows)];

            $values = array_map(array($this, 'clean'), array_combine($headers, $row));
            $object = $this->getEntityManager()
                ->getRepository($entityName)
                ->findOneBy($values);

            if (is_null($object)) {
                throw new \Exception(sprintf("There is no object for the following criteria: %s", json_encode($values)));

The string literal There is no object for the following criteria: %s does not require double quotes, as per coding-style, please use single quotes.

            }
            $this->getEntityManager()->refresh($object);
        }
    }

    /**
     * @BeforeScenario
     */
    public function beforeScenario($event)
    {
        $this->storeTags($event);

        if ($this->hasTags([ 'reset-schema', '~not-reset-schema' ])) {
            foreach ($this->getEntityManagers() as $entityManager) {
                $metadata = $this->getMetadata($entityManager);

                if (!empty($metadata)) {
                    $tool = new SchemaTool($entityManager);
                    $tool->dropSchema($metadata);
                    $tool->createSchema($metadata);
                }
            }
        }

    }

    /**
     * @AfterScenario
     */
    public function afterScenario($event)

The parameter $event is not used and could be removed.

    {
        $this->getRecordBag()->clear();
        $this->getUniqueCache()->clear();
        $this->getEntityManager()->clear();
    }

    protected function compareArray(array $a1, array $a2)
    {
        $diff = [];
        foreach ($a1 as $e) {
            if (!in_array($e, $a2)) {
                $diff[] = $e;
            }
        }

        return $diff;
    }

    protected function getMetadata(EntityManager $entityManager)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $entityManager->getMetadataFactory()->getAllMetadata();
    }

    protected function getEntityManagers()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->get('doctrine')->getManagers();
    }

    protected function getConnections()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->get('doctrine')->getConnections();
    }

    protected function getDefaultOptions()
    {
        return [
            'Entities' => [''],
        ];
    }

    /**
     * @param string|int $value
     *
     * @return string|null

Should the return type not be string|integer?

     */
    protected function clean($value)
    {
        return empty(trim($value)) ? null : $value;
    }
}