Doctrine\Tests\ORM\Functional\Ticket\GH7062Team

Complexity

Total Complexity

1

Size/Duplication

Total Lines	13
Duplicated Lines	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1

<?php
declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional\Ticket;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Tests\OrmFunctionalTestCase;

class GH7062Test extends OrmFunctionalTestCase
{
    private const SEASON_ID = 'season_18';
    private const TEAM_ID   = 'team_A';

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

        $this->setUpEntitySchema([GH7062Team::class, GH7062Season::class, GH7062Ranking::class, GH7062RankingPosition::class]);
    }

    /**
     * @group 7062
     */
    public function testEntityWithAssociationKeyIdentityCanBeUpdated() : void
    {
        $this->createInitialRankingWithRelatedEntities();
        $this->modifyRanking();
        $this->verifyRanking();
    }

    private function createInitialRankingWithRelatedEntities() : void
    {
        $team    = new GH7062Team(self::TEAM_ID);
        $season  = new GH7062Season(self::SEASON_ID);
        $ranking = $season->start([$team]);

        $this->_em->persist($team);
        $this->_em->persist($season);
        $this->_em->persist($ranking);
        $this->_em->flush();
        $this->_em->clear();

        foreach ($ranking->getPositions() as $position) {
            self::assertFalse($position->hasPoints());
        }
    }

    private function modifyRanking() : void
    {
        /** @var GH7062Ranking $ranking */
        $ranking = $this->_em->find(GH7062Ranking::class, self::SEASON_ID);

        $ranking->everybodyWins();

        foreach ($ranking->getPositions() as $position) {
            self::assertTrue($position->hasPoints());
        }

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

    private function verifyRanking() : void
    {
        /** @var GH7062Season $season */
        $season = $this->_em->find(GH7062Season::class, self::SEASON_ID);
        self::assertInstanceOf(GH7062Season::class, $season);

        $ranking = $season->getRanking();
        self::assertInstanceOf(GH7062Ranking::class, $ranking);

        foreach ($ranking->getPositions() as $position) {
            self::assertTrue($position->hasPoints());
        }
    }
}

/**
 * Simple Entity whose identity is defined through another Entity (Season)
 *
 * @Entity
 * @Table(name="soccer_rankings")
 */
class GH7062Ranking
{
    /**
     * @Id
     * @OneToOne(targetEntity=GH7062Season::class, inversedBy="ranking")
     * @JoinColumn(name="season_id", referencedColumnName="id")
     *
     * @var GH7062Season
     */
    private $season;

    /**
     * @OneToMany(targetEntity=GH7062RankingPosition::class, mappedBy="ranking", cascade={"all"})
     *
     * @var Collection
     */
    private $positions;

    /**
     * @param GH7062Team[] $teams
     */
    public function __construct(GH7062Season $season, array $teams)
    {
        $this->season    = $season;
        $this->positions = new ArrayCollection();

        foreach ($teams as $team) {
            $this->positions[] = new GH7062RankingPosition($this, $team);
        }
    }

    /**
     * Adds a victory for every team :)
     */
    public function everybodyWins() : void
    {
        foreach ($this->positions as $position) {
            $position->addVictory();
        }
    }

    /**
     * @return GH7062RankingPosition[]
     */
    public function getPositions() : array
    {
        return $this->positions->toArray();
    }
}

/**
 * Entity which serves as a identity provider for other entities
 *
 * @Entity
 * @Table(name="soccer_seasons")
 */
class GH7062Season
{
    /**
     * @Id
     * @Column(type="string")
     *
     * @var string
     */
    private $id;

    /**
     * @OneToOne(targetEntity=GH7062Ranking::class, mappedBy="season", cascade={"all"})
     *
     * @var GH7062Ranking|null
     */
    private $ranking;

    public function __construct(string $id)
    {
        $this->id = $id;
    }

    public function start(array $teams) : GH7062Ranking
    {
        return $this->ranking = new GH7062Ranking($this, $teams);
    }

    /**
     * @return GH7062Ranking|null
     */
    public function getRanking(): ?GH7062Ranking
    {
        return $this->ranking;
    }
}

/**
 * Entity which serves as a identity provider for other entities
 *
 * @Entity
 * @Table(name="soccer_teams")
 */
class GH7062Team
{
    /**
     * @Id
     * @Column(type="string")
     *
     * @var string
     */
    private $id;

    public function __construct($id)
    {
        $this->id = $id;
    }
}

/**
 * Entity whose identity is defined through two other entities
 *
 * @Entity
 * @Table(name="soccer_ranking_positions")
 */
class GH7062RankingPosition
{
    /**
     * @Id
     * @ManyToOne(targetEntity=GH7062Ranking::class, inversedBy="positions")
     * @JoinColumn(name="season_id", referencedColumnName="season_id")
     *
     * @var GH7062Ranking
     */
    private $ranking;

    /**
     * @Id
     * @ManyToOne(targetEntity=GH7062Team::class)
     * @JoinColumn(name="team_id", referencedColumnName="id")
     *
     * @var GH7062Team
     */
    private $team;

    /**
     * @Column(type="integer")
     *
     * @var int
     */
    private $points;

    public function __construct(GH7062Ranking $ranking, GH7062Team $team)
    {
        $this->ranking = $ranking;
        $this->team    = $team;
        $this->points  = 0;
    }

    public function addVictory() : void
    {
        $this->points += 3;
    }

    public function hasPoints() : bool
    {
        return $this->points > 0;
    }
}