GH5762Test::setUp() - Code Metrics - Inspection of "Merge branch 'fix/#5975-fix_hydrating_fetch_join_w..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a90f23...2814d6 )

by Marco

created 2016-09-07 21:23 UTC

GH5762Test::setUp() A

↳ Parent: GH5762Test

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Doctrine\Tests\ORM\Functional\Ticket;

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

/**
 * @group GH-5762
 */
class GH5762Test extends OrmFunctionalTestCase
{
    protected function setUp()
    {
        parent::setUp();

        $this->_schemaTool->createSchema(array(
            $this->_em->getClassMetadata(GH5762Driver::class),
            $this->_em->getClassMetadata(GH5762DriverRide::class),
            $this->_em->getClassMetadata(GH5762Car::class),
        ));
    }

    public function testIssue()
    {
        $result = $this->fetchData();

        self::assertInstanceOf(GH5762Driver::class, $result);
        self::assertInstanceOf(PersistentCollection::class, $result->driverRides);
        self::assertInstanceOf(GH5762DriverRide::class, $result->driverRides->get(0));
        self::assertInstanceOf(GH5762Car::class, $result->driverRides->get(0)->car);

        $cars = array();
        foreach ($result->driverRides as $ride) {
            $cars[] = $ride->car->brand;
        }

        self::assertEquals(count($cars), count(array_unique($cars)));

        self::assertContains('BMW', $cars);
        self::assertContains('Crysler', $cars);
        self::assertContains('Dodge', $cars);
        self::assertContains('Mercedes', $cars);
        self::assertContains('Volvo', $cars);
    }

    private function fetchData()
    {
        $this->createData();

        $qb = $this->_em->createQueryBuilder();
        $qb->select('d, dr, c')
            ->from(GH5762Driver::class, 'd')
            ->leftJoin('d.driverRides', 'dr')
            ->leftJoin('dr.car', 'c')
            ->where('d.id = 1');

        return $qb->getQuery()->getSingleResult();
    }

    private function createData()
    {
        $car1 = new GH5762Car('BMW', '7 Series');
        $car2 = new GH5762Car('Crysler', '300');
        $car3 = new GH5762Car('Dodge', 'Dart');
        $car4 = new GH5762Car('Mercedes', 'C-Class');
        $car5 = new GH5762Car('Volvo', 'XC90');

        $driver = new GH5762Driver(1, 'John Doe');

        $ride1 = new GH5762DriverRide($driver, $car1);
        $ride2 = new GH5762DriverRide($driver, $car2);
        $ride3 = new GH5762DriverRide($driver, $car3);
        $ride4 = new GH5762DriverRide($driver, $car4);
        $ride5 = new GH5762DriverRide($driver, $car5);

        $this->_em->persist($car1);
        $this->_em->persist($car2);
        $this->_em->persist($car3);
        $this->_em->persist($car4);
        $this->_em->persist($car5);

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

        $this->_em->persist($ride1);
        $this->_em->persist($ride2);
        $this->_em->persist($ride3);
        $this->_em->persist($ride4);
        $this->_em->persist($ride5);

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

/**
 * @Entity
 * @Table(name="driver")
 */
class GH5762Driver
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue(strategy="NONE")
     */
    public $id;

    /**
     * @Column(type="string", length=255);
     */
    public $name;

    /**
     * @OneToMany(targetEntity="GH5762DriverRide", mappedBy="driver")
     */
    public $driverRides;

    public function __construct($id, $name)
    {
        $this->driverRides = new ArrayCollection();
        $this->id = $id;
        $this->name = $name;
    }
}

/**
 * @Entity
 * @Table(name="driver_ride")
 */
class GH5762DriverRide
{
    /**
     * @Id
     * @ManyToOne(targetEntity="GH5762Driver", inversedBy="driverRides")
     * @JoinColumn(name="driver_id", referencedColumnName="id")
     */
    public $driver;

    /**
     * @Id
     * @ManyToOne(targetEntity="GH5762Car", inversedBy="carRides")
     * @JoinColumn(name="car", referencedColumnName="brand")
     */
    public $car;

    function __construct(GH5762Driver $driver, GH5762Car $car)
    {
        $this->driver = $driver;
        $this->car = $car;

        $this->driver->driverRides->add($this);
        $this->car->carRides->add($this);
    }
}

/**
 * @Entity
 * @Table(name="car")
 */
class GH5762Car
{

    /**
     * @Id
     * @Column(type="string", length=25)
     * @GeneratedValue(strategy="NONE")
     */
    public $brand;

    /**
     * @Column(type="string", length=255);
     */
    public $model;

    /**
     * @OneToMany(targetEntity="GH5762DriverRide", mappedBy="car")
     */
    public $carRides;

    public function __construct($brand, $model)
    {
        $this->carRides = new ArrayCollection();
        $this->brand = $brand;
        $this->model = $model;
    }
}


1			<?php
2
3			namespace Doctrine\Tests\ORM\Functional\Ticket;
4
5			use Doctrine\Common\Collections\ArrayCollection;
6			use Doctrine\ORM\PersistentCollection;
7			use Doctrine\Tests\OrmFunctionalTestCase;
8
9			/**
10			* @group GH-5762
11			*/
12			class GH5762Test extends OrmFunctionalTestCase
13			{
14			protected function setUp()
15			{
16			parent::setUp();
17
18			$this->_schemaTool->createSchema(array(
19			$this->_em->getClassMetadata(GH5762Driver::class),
20			$this->_em->getClassMetadata(GH5762DriverRide::class),
21			$this->_em->getClassMetadata(GH5762Car::class),
22			));
23			}
24
25			public function testIssue()
26			{
27			$result = $this->fetchData();
28
29			self::assertInstanceOf(GH5762Driver::class, $result);
30			self::assertInstanceOf(PersistentCollection::class, $result->driverRides);
31			self::assertInstanceOf(GH5762DriverRide::class, $result->driverRides->get(0));
32			self::assertInstanceOf(GH5762Car::class, $result->driverRides->get(0)->car);
33
34			$cars = array();
35			foreach ($result->driverRides as $ride) {
36			$cars[] = $ride->car->brand;
37			}
38
39			self::assertEquals(count($cars), count(array_unique($cars)));
40
41			self::assertContains('BMW', $cars);
42			self::assertContains('Crysler', $cars);
43			self::assertContains('Dodge', $cars);
44			self::assertContains('Mercedes', $cars);
45			self::assertContains('Volvo', $cars);
46			}
47
48			private function fetchData()
49			{
50			$this->createData();
51
52			$qb = $this->_em->createQueryBuilder();
53			$qb->select('d, dr, c')
54			->from(GH5762Driver::class, 'd')
55			->leftJoin('d.driverRides', 'dr')
56			->leftJoin('dr.car', 'c')
57			->where('d.id = 1');
58
59			return $qb->getQuery()->getSingleResult();
60			}
61
62			private function createData()
63			{
64			$car1 = new GH5762Car('BMW', '7 Series');
65			$car2 = new GH5762Car('Crysler', '300');
66			$car3 = new GH5762Car('Dodge', 'Dart');
67			$car4 = new GH5762Car('Mercedes', 'C-Class');
68			$car5 = new GH5762Car('Volvo', 'XC90');
69
70			$driver = new GH5762Driver(1, 'John Doe');
71
72			$ride1 = new GH5762DriverRide($driver, $car1);
73			$ride2 = new GH5762DriverRide($driver, $car2);
74			$ride3 = new GH5762DriverRide($driver, $car3);
75			$ride4 = new GH5762DriverRide($driver, $car4);
76			$ride5 = new GH5762DriverRide($driver, $car5);
77
78			$this->_em->persist($car1);
79			$this->_em->persist($car2);
80			$this->_em->persist($car3);
81			$this->_em->persist($car4);
82			$this->_em->persist($car5);
83
84			$this->_em->persist($driver);
85
86			$this->_em->persist($ride1);
87			$this->_em->persist($ride2);
88			$this->_em->persist($ride3);
89			$this->_em->persist($ride4);
90			$this->_em->persist($ride5);
91
92			$this->_em->flush();
93			$this->_em->clear();
94			}
95			}
96
97			/**
98			* @Entity
99			* @Table(name="driver")
100			*/
101			class GH5762Driver
102			{
103			/**
104			* @Id
105			* @Column(type="integer")
106			* @GeneratedValue(strategy="NONE")
107			*/
108			public $id;
109
110			/**
111			* @Column(type="string", length=255);
112			*/
113			public $name;
114
115			/**
116			* @OneToMany(targetEntity="GH5762DriverRide", mappedBy="driver")
117			*/
118			public $driverRides;
119
120			public function __construct($id, $name)
121			{
122			$this->driverRides = new ArrayCollection();
123			$this->id = $id;
124			$this->name = $name;
125			}
126			}
127
128			/**
129			* @Entity
130			* @Table(name="driver_ride")
131			*/
132			class GH5762DriverRide
133			{
134			/**
135			* @Id
136			* @ManyToOne(targetEntity="GH5762Driver", inversedBy="driverRides")
137			* @JoinColumn(name="driver_id", referencedColumnName="id")
138			*/
139			public $driver;
140
141			/**
142			* @Id
143			* @ManyToOne(targetEntity="GH5762Car", inversedBy="carRides")
144			* @JoinColumn(name="car", referencedColumnName="brand")
145			*/
146			public $car;
147
148			function __construct(GH5762Driver $driver, GH5762Car $car)
149			{
150			$this->driver = $driver;
151			$this->car = $car;
152
153			$this->driver->driverRides->add($this);
154			$this->car->carRides->add($this);
155			}
156			}
157
158			/**
159			* @Entity
160			* @Table(name="car")
161			*/
162			class GH5762Car
163			{
164
165			/**
166			* @Id
167			* @Column(type="string", length=25)
168			* @GeneratedValue(strategy="NONE")
169			*/
170			public $brand;
171
172			/**
173			* @Column(type="string", length=255);
174			*/
175			public $model;
176
177			/**
178			* @OneToMany(targetEntity="GH5762DriverRide", mappedBy="car")
179			*/
180			public $carRides;
181
182			public function __construct($brand, $model)
183			{
184			$this->carRides = new ArrayCollection();
185			$this->brand = $brand;
186			$this->model = $model;
187			}
188			}
189

doctrine / orm

Push — master ( a90f23...2814d6 )

GH5762Test::setUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like