Doctrine\Tests\ORM\Functional\Ticket\GH7767ParentEntity

Complexity

Total Complexity

2

Size/Duplication

Total Lines	29
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	addChild()	0	4	1
A	getChildren()	0	3	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional\Ticket;

use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\PersistentCollection;
use Doctrine\Tests\OrmFunctionalTestCase;

/**
 * Tests sorting mechanism of Selectable::matching() of PersistentCollection
 */
class GH7767Test extends OrmFunctionalTestCase
{
    /**
     * @group 7767
     */
    public function testMatchingRespectsCollectionOrdering(): void
    {
        $this->createFixture();

        $query = $this->_em->createQuery('select p from Doctrine\Tests\ORM\Functional\Ticket\GH7767ParentEntity p');
        $result = $query->getResult();
        $parent = $result[0];

        assert($parent instanceof GH7767ParentEntity);

        $children = $parent
            ->getChildren()
            ->matching(
                Criteria::create()
            );

        self::assertEquals(100, $children[0]->position);
        self::assertEquals(200, $children[1]->position);
        self::assertEquals(300, $children[2]->position);
    }

    /**
     * @group 7767
     */
    public function testMatchingOverrulesCollectionOrdering(): void
    {
        $this->createFixture();

        $query = $this->_em->createQuery('select p from Doctrine\Tests\ORM\Functional\Ticket\GH7767ParentEntity p');
        $result = $query->getResult();
        $parent = $result[0];

        assert($parent instanceof GH7767ParentEntity);

        $children = $parent
            ->getChildren()
            ->matching(
                Criteria::create()
                    ->orderBy(['position' => 'DESC'])
            );

        self::assertEquals(300, $children[0]->position);
        self::assertEquals(200, $children[1]->position);
        self::assertEquals(100, $children[2]->position);
    }

    protected function setUp(): void
    {
        parent::setUp();

        $this->setUpEntitySchema(
            [
                GH7767ParentEntity::class,
                GH7767ChildEntity::class
            ]
        );
    }

    private function createFixture()
    {
        $parent = new GH7767ParentEntity();

        $firstChild = new GH7767ChildEntity();
        $firstChild->position = 200;

        $secondChild = new GH7767ChildEntity();
        $secondChild->position = 100;

        $thirdChild = new GH7767ChildEntity();
        $thirdChild->position = 300;

        $parent->addChild($firstChild);
        $parent->addChild($secondChild);
        $parent->addChild($thirdChild);

        $this->_em->persist($parent);

        $this->_em->flush();
        $this->_em->clear();
    }
}

/**
 * @Entity
 */
class GH7767ParentEntity
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue
     */
    private $id;

The private property $id is not used, and could be removed.

    /**
     * @OneToMany(
     *     targetEntity=GH7767ChildEntity::class,
     *     mappedBy="parent",
     *     fetch="EXTRA_LAZY",
     *     cascade={"persist"}
     * )
     * @OrderBy({"position" = "ASC"})
     */
    private $children;

    public function addChild(GH7767ChildEntity $child)
    {
        $this->children[] = $child;
        $child->setParent($this);
    }

    public function getChildren(): PersistentCollection
    {
        return $this->children;
    }
}

/**
 * @Entity
 */
class GH7767ChildEntity
{
    /**
     * @Column(type="integer")
     */
    public $position;
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue
     */
    private $id;
    /**
     * @ManyToOne(targetEntity=GH7767ParentEntity::class, inversedBy="children")
     * @JoinColumn(name="parent_id", referencedColumnName="id")
     */
    private $parent;

    public function setParent(GH7767ParentEntity $parent)
    {
        $this->parent = $parent;
    }
}