EntityMappingTest::shouldStoreDBALColumn() - Code Metrics - addiks/symfony_rdm - Measure and Improve Code Quality continuously with Scrutinizer

EntityMappingTest::shouldStoreDBALColumn() A
last analyzed 2024-11-12 10:58 UTC

↳ Parent: EntityMappingTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * Copyright (C) 2017  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\Mapping;

use PHPUnit\Framework\TestCase;
use Addiks\RDMBundle\Mapping\EntityMapping;
use Addiks\RDMBundle\Tests\Hydration\EntityExample;
use Doctrine\DBAL\Schema\Column;
use Doctrine\DBAL\Types\Type;
use Addiks\RDMBundle\Mapping\MappingInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Addiks\RDMBundle\Hydration\HydrationContextInterface;

final class EntityMappingTest extends TestCase
{

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

    /**
     * @var MappingInterface
     */
    private $fieldMappingA;

    /**
     * @var MappingInterface
     */
    private $fieldMappingB;

    public function setUp(): void
    {
        $this->fieldMappingA = $this->createMock(MappingInterface::class);

        $this->fieldMappingB = $this->createMock(MappingInterface::class);


        $this->entityMapping = new EntityMapping(EntityExample::class, [
            'fieldA' => $this->fieldMappingA,
            'fieldB' => $this->fieldMappingB,
        ]);
    }

    /**
     * @test
     */
    public function shouldStoreEntityName()
    {
        $this->assertEquals(EntityExample::class, $this->entityMapping->getEntityClassName());
    }

    /**
     * @test
     */
    public function shouldStoreClassName()
    {
        $this->assertEquals(EntityExample::class, $this->entityMapping->getClassName());
    }

    /**
     * @test
     */
    public function shouldHaveNoFactoryOrSerializer()
    {
        $this->assertSame(null, $this->entityMapping->getFactory());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $this->assertSame(null, $this->entityMapping->getSerializer());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @test
     */
    public function shouldStoreFieldMappings()
    {
        $this->assertEquals([
            'fieldA' => $this->fieldMappingA,
            'fieldB' => $this->fieldMappingB,
        ], $this->entityMapping->getFieldMappings());
    }

    /**
     * @test
     */
    public function shouldDescribeOrigin()
    {
        $this->assertEquals(EntityExample::class, $this->entityMapping->describeOrigin());
    }

    /**
     * @test
     */
    public function shouldCollectColumns()
    {
        $columnA = new Column("column_a", Type::getType("string"), []);
        $columnB = new Column("column_b", Type::getType("string"), []);

        /** @var array<Column> $expectedColumns */
        $expectedColumns = [$columnA, $columnB];

        $this->fieldMappingA->method('collectDBALColumns')->willReturn([$columnA]);
                              method('collectDBALColumns')->willReturn([$columnA]);
        $this->fieldMappingB->method('collectDBALColumns')->willReturn([$columnB]);

        $this->assertEquals($expectedColumns, $this->entityMapping->collectDBALColumns());
    }

    /**
     * @test
     */
    public function shouldStoreDBALColumn()
    {
        $this->assertNull($this->entityMapping->getDBALColumn());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @test
     */
    public function shouldStoreId()
    {
        $this->assertNull($this->entityMapping->getId());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @test
     */
    public function shouldStoreReferenceId()
    {
        $this->assertNull($this->entityMapping->getReferencedId());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @test
     */
    public function shouldNotResolveValue()
    {
        $this->assertEquals(
            [
                'fieldA' => null,
                'fieldB' => null
            ],
            $this->entityMapping->resolveValue(
                $this->createMock(HydrationContextInterface::class),
                []
            )
        );
    }

    /**
     * @test
     */
    public function shouldNotRevertValue()
    {
        $this->assertEmpty($this->entityMapping->revertValue(
            $this->createMock(HydrationContextInterface::class),
            null
        ));
    }

    /**
     * @test
     */
    public function shouldNotAssertValue()
    {
        $this->assertNull($this->entityMapping->assertValue(
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            $this->createMock(HydrationContextInterface::class),
            [],
            null
        ));
    }

    /**
     * @test
     */
    public function shouldWakeUpInnerMapping()
    {
        /** @var ContainerInterface $container */
        $container = $this->createMock(ContainerInterface::class);

        $this->fieldMappingA->expects($this->once())->method("wakeUpMapping")->with(
                              expects($this->once())->method("wakeUpMapping")->with(
            $this->equalTo($container)
        );

        $this->fieldMappingB->expects($this->once())->method("wakeUpMapping")->with(
            $this->equalTo($container)
        );

        $this->entityMapping->wakeUpMapping($container);
    }

}


addiks / symfony_rdm

EntityMappingTest::shouldStoreDBALColumn() A last analyzed 2024-11-12 10:58 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

EntityMappingTest::shouldStoreDBALColumn() A
last analyzed 2024-11-12 10:58 UTC