DataSimpleSelectLoaderTest::shouldRemoveDBALForEntity() - Code Metrics - Inspection of "finalized test-suite; MSI is now at 100%" - addiks/symfony_rdm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7e6070...203e38 )

by Gerrit

created 2018-02-18 17:00 UTC

shouldRemoveDBALForEntity() A

↳ Parent: DataSimpleSelectLoaderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\RDMBundle\Tests\DataLoader;

use Addiks\RDMBundle\DataLoader\SimpleSelectDataLoader;
use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface;
use Addiks\RDMBundle\Mapping\EntityMapping;
use Addiks\RDMBundle\Tests\Hydration\EntityExample;
use Addiks\RDMBundle\Mapping\ChoiceMapping;
use Addiks\RDMBundle\ValueResolver\ValueResolverInterface;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Query\QueryBuilder;
use Doctrine\ORM\Query\Expr;
use Doctrine\DBAL\Driver\Statement;
use PHPUnit\Framework\TestCase;
use Addiks\RDMBundle\Mapping\ServiceMapping;
use Doctrine\ORM\UnitOfWork;
use Addiks\RDMBundle\Tests\Hydration\ServiceExample;

final class DataSimpleSelectLoaderTest extends TestCase
{

    /**
     * @var SimpleSelectDataLoader
     */
    private $dataLoader;

    /**
     * @var MappingDriverInterface
     */
    private $mappingDriver;

    /**
     * @var ValueResolverInterface
     */
    private $valueResolver;

    /**
     * @var ClassMetadata
     */
    private $classMetaData;

    /**
     * @var Connection
     */
    private $connection;

    /**
     * @var QueryBuilder
     */
    private $queryBuilder;

    /**
     * @var Expr
     */
    private $expr;

    /**
     * @var Statement
     */
    private $statement;

    /**
     * @var EntityManagerInterface
     */
    private $entityManager;

    /**
     * @var UnitOfWork
     */
    private $unitOfWork;

    /**
     * @var EntityMapping
     */
    private $entityMapping;

    /**
     * @var ChoiceMapping
     */
    private $mappings = array();

    public function setUp()
    {
        $this->mappingDriver = $this->createMock(MappingDriverInterface::class);

        $this->valueResolver = $this->createMock(ValueResolverInterface::class);

        $this->connection = $this->createMock(Connection::class);

        $this->queryBuilder = $this->createMock(QueryBuilder::class);

        $this->expr = $this->createMock(Expr::class);

        $this->statement = $this->createMock(Statement::class);

        $this->entityManager = $this->createMock(EntityManagerInterface::class);

        $this->unitOfWork = $this->createMock(UnitOfWork::class);


        $this->dataLoader = new SimpleSelectDataLoader(
            $this->mappingDriver,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->valueResolver,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            1
        );

        $this->classMetaData = new ClassMetadata(EntityExample::class);
        $this->classMetaData->table = ['name' => 'some_table'];
        $this->classMetaData->identifier = ["id"];
        $this->classMetaData->fieldMappings = [
            "id" => [
                'columnName' => 'id'
            ]
        ];

        $this->mappings['foo'] = new ChoiceMapping('foo_column', []);
        $this->mappings['bar'] = new ChoiceMapping('bar_column', []);

        $this->entityMapping = new EntityMapping(EntityExample::class, $this->mappings);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->mappingDriver->method("loadRDMMetadataForClass")->willReturn($this->entityMapping);
        $this->entityManager->method("getClassMetadata")->willReturn($this->classMetaData);
        $this->entityManager->method("getConnection")->willReturn($this->connection);
        $this->entityManager->method("getUnitOfWork")->willReturn($this->unitOfWork);
        $this->connection->method('createQueryBuilder')->willReturn($this->queryBuilder);
        $this->queryBuilder->method('expr')->willReturn($this->expr);
        $this->queryBuilder->method('execute')->willReturn($this->statement);
    }

    /**
     * @test
     */
    public function loadsDataFromDatabase()
    {
        /** @var array $expectedData */
        $expectedData = array(
            'foo_column' => 'Lorem ipsum',
            'bar_column' => 'dolor sit amet'
        );

        $this->classMetaData->identifier = ["id", "faz"];
        $this->classMetaData->fieldMappings = [
            "id"  => ['columnName' => 'id'],
            "faz" => ['columnName' => 'faz']
        ];

        $this->queryBuilder->expects($this->once())->method('from')->with($this->equalTo('some_table'));

        $this->queryBuilder->expects($this->exactly(2))->method('andWhere')->with($this->equalTo("*eq-return*"));

        $this->queryBuilder->expects($this->exactly(2))->method('addSelect');

        $this->queryBuilder->expects($this->once())->method('setMaxResults')->with($this->equalTo(1));


        $this->statement->method('fetch')->willReturn($expectedData);


        /** @var ServiceExample $fazService */
        $fazService = $this->createMock(ServiceExample::class);

        $entity = new EntityExample(null, null, null, $fazService);
        $entity->id = "some_id";

        $this->expr->method("eq")->willReturn("*eq-return*");


        /** @var array $actualData */
        $actualData = $this->dataLoader->loadDBALDataForEntity($entity, $this->entityManager);

        $this->assertEquals($expectedData, $actualData);
    }

    /**
     * @test
     */
    public function shouldNotLoadEntityWithoutId()
    {
        /** @var array $expectedData */
        $expectedData = array();

        $this->classMetaData->identifier = [];

        $this->queryBuilder->expects($this->never())->method('from');


        $this->statement->method('fetch')->willReturn($expectedData);


        $entity = new EntityExample();
        $entity->id = "some_id";

        $this->expr->method("eq")->willReturn("*eq-return*");


        /** @var array $actualData */
        $actualData = $this->dataLoader->loadDBALDataForEntity($entity, $this->entityManager);

        $this->assertEquals($expectedData, $actualData);
    }

    /**
     * @test
     */
    public function storesDataInDatabase()
    {
        $this->mappings['faz'] = new ChoiceMapping('faz_column', []);

        $this->setUp();

        $this->classMetaData->identifier = ["id", "faz"];
        $this->classMetaData->fieldMappings = [
            "id"  => ['columnName' => 'id'],
            "faz" => ['columnName' => 'faz']
        ];

        /** @var ServiceExample $fazService */
        $fazService = $this->createMock(ServiceExample::class);

        $entity = new EntityExample(null, null, null, $fazService);
        $entity->id = "some_id";
        $entity->foo = "some_ipsum_service";

        $entity->bar = "some_dolor_service";


        $this->valueResolver->method("revertValue")->will($this->returnValueMap([

            [$this->mappings['foo'], $entity, "some_ipsum_service", ["foo_column" => "ipsum"]],
            [$this->mappings['bar'], $entity, "some_dolor_service", ["bar_column" => "dolor"]],
            [$this->mappings['faz'], $entity, $fazService,          ["faz_column" => "sit"]],
        ]));

        $this->connection->expects($this->once())->method("update")->with(

            $this->equalTo("some_table"),
            $this->equalTo([
                'foo_column' => 'ipsum',
                'bar_column' => 'dolor',
                'faz_column' => 'sit'
            ]),
            $this->equalTo([
                'id'  => "some_id",
                'faz' => $fazService
            ])
        );

        $this->dataLoader->storeDBALDataForEntity($entity, $this->entityManager);
    }

    /**
     * @test
     */
    public function shouldNotUpdateIfDataDidNotChange()
    {
        $entity = new EntityExample();
        $entity->id = "some_id";
        $entity->foo = "some_ipsum_service";

        $entity->bar = "some_dolor_service";


        $this->valueResolver->method("revertValue")->will($this->returnValueMap([

            [$this->mappings['foo'], $entity, "some_ipsum_service", ["foo_column" => "ipsum"]],
            [$this->mappings['bar'], $entity, "some_dolor_service", ["bar_column" => "dolor"]],
        ]));

        $this->connection->expects($this->never())->method("update");


        /** @var array $expectedData */
        $expectedData = [
            'foo_column' => 'ipsum',
            'bar_column' => 'dolor'
        ];

        $this->statement->method('fetch')->willReturn($expectedData);


        $this->dataLoader->loadDBALDataForEntity($entity, $this->entityManager);
        $this->dataLoader->storeDBALDataForEntity($entity, $this->entityManager);
    }

    /**
     * @test
     */
    public function shouldRemoveDBALForEntity()
    {
        $this->dataLoader->removeDBALDataForEntity(new EntityExample(), $this->entityManager);
        $this->assertTrue(true);
    }

    /**
     * @test
     */
    public function shouldPrepareOnMetadataLoad()
    {
        $this->dataLoader->prepareOnMetadataLoad($this->entityManager, $this->classMetaData);
        $this->assertTrue(true);
    }

}


1			<?php
2			/**
3			* Copyright (C) 2018 Gerrit Addiks.
4			* This package (including this file) was released under the terms of the GPL-3.0.
5			* You should have received a copy of the GNU General Public License along with this program.
6			* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7			* @license GPL-3.0
8			* @author Gerrit Addiks <[email protected]>
9			*/
10
11			namespace Addiks\RDMBundle\Tests\DataLoader;
12
13			use Addiks\RDMBundle\DataLoader\SimpleSelectDataLoader;
14			use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface;
15			use Addiks\RDMBundle\Mapping\EntityMapping;
16			use Addiks\RDMBundle\Tests\Hydration\EntityExample;
17			use Addiks\RDMBundle\Mapping\ChoiceMapping;
18			use Addiks\RDMBundle\ValueResolver\ValueResolverInterface;
19			use Doctrine\ORM\EntityManagerInterface;
20			use Doctrine\ORM\Mapping\ClassMetadata;
21			use Doctrine\DBAL\Connection;
22			use Doctrine\DBAL\Query\QueryBuilder;
23			use Doctrine\ORM\Query\Expr;
24			use Doctrine\DBAL\Driver\Statement;
25			use PHPUnit\Framework\TestCase;
26			use Addiks\RDMBundle\Mapping\ServiceMapping;
27			use Doctrine\ORM\UnitOfWork;
28			use Addiks\RDMBundle\Tests\Hydration\ServiceExample;
29
30			final class DataSimpleSelectLoaderTest extends TestCase
31			{
32
33			/**
34			* @var SimpleSelectDataLoader
35			*/
36			private $dataLoader;
37
38			/**
39			* @var MappingDriverInterface
40			*/

addiks / symfony_rdm

Push — master ( 7e6070...203e38 )

shouldRemoveDBALForEntity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like