#6759 cleaning up test case, using new models from the isolated namespace

tests/Doctrine/Tests/ORM/Functional/OneToOneInverseSideLoadAfterDqlQueryTest.php

@@ -1,112 +1,70 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Doctrine\Tests\ORM\Functional;
 
-use Doctrine\ORM\Tools\SchemaTool;
 use Doctrine\ORM\Tools\ToolsException;
+use Doctrine\Tests\Models\OneToOneInverseSideLoad\InverseSide;
+use Doctrine\Tests\Models\OneToOneInverseSideLoad\OwningSide;
 use Doctrine\Tests\OrmFunctionalTestCase;
 
 class OneToOneInverseSideLoadAfterDqlQueryTest extends OrmFunctionalTestCase
 {
-
     protected function setUp()
     {
         parent::setUp();
 
         try {
             $this->_schemaTool->createSchema([
-                $this->_em->getClassMetadata(Bus::class),
-                $this->_em->getClassMetadata(BusOwner::class),
+                $this->_em->getClassMetadata(OwningSide::class),
+                $this->_em->getClassMetadata(InverseSide::class),
             ]);
         } catch(ToolsException $e) {
             // ignored
         }
     }
 
+    /**
+     * @group #6759
+     */
     public function testInverseSideOneToOneLoadedAfterDqlQuery(): void
     {
-        $owner = new BusOwner('Alexander');
-        $bus = new Bus($owner);
+        $owner   = new OwningSide();
+        $inverse = new InverseSide();
 
-        $this->_em->persist($bus);
+        $owner->id       = 'owner';
+        $inverse->id     = 'inverse';
+        $owner->inverse  = $inverse;
+        $inverse->owning = $owner;
+
+        $this->_em->persist($owner);
+        $this->_em->persist($inverse);
         $this->_em->flush();
         $this->_em->clear();
 
-        $bus = $this
+        /* @var $fetchedInverse InverseSide */
+        $fetchedInverse = $this
             ->_em
             ->createQueryBuilder()
-            ->select('to')
-            ->from(BusOwner::class, 'to')
-            ->andWhere('to.id = :id')
-            ->setParameter('id', $owner->id)
+            ->select('inverse')
+            ->from(InverseSide::class, 'inverse')
+            ->andWhere('inverse.id = :id')
+            ->setParameter('id', 'inverse')
             ->getQuery()
-            ->getResult();
+            ->getSingleResult();
+
+        self::assertInstanceOf(InverseSide::class, $fetchedInverse);
+        self::assertInstanceOf(OwningSide::class, $fetchedInverse->owning);
 
         $this->assertSQLEquals(
-            'SELECT b0_.id AS id_0, b0_.name AS name_1 FROM BusOwner b0_ WHERE b0_.id = ?',
+            'select o0_.id as id_0 from one_to_one_inverse_side_load_inverse o0_ where o0_.id = ?',
             $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery - 1]['sql']
         );
 
         $this->assertSQLEquals(
-            'SELECT t0.id AS id_1, t0.owner AS owner_2 FROM Bus t0 WHERE t0.owner = ?',
+            'select t0.id as id_1, t0.inverse as inverse_2 from one_to_one_inverse_side_load_owning t0 WHERE t0.inverse = ?',
             $this->_sqlLoggerStack->queries[$this->_sqlLoggerStack->currentQuery]['sql']
         );
     }
-
-}
-
-
-/**
- * @Entity
- */
-class Bus
-{
-    /**
-     * @id @column(type="integer") @generatedValue
-     * @var int
-     */
-    public $id;
-    /**
-     * Owning side
-     * @OneToOne(targetEntity="BusOwner", inversedBy="bus", cascade={"persist"})
-     * @JoinColumn(nullable=false, name="owner")
-     */
-    public $owner;
-
-    public function __construct(BusOwner $owner)
-    {
-        $this->owner = $owner;
-    }
-
-}
-
-/**
- * @Entity
- */
-class BusOwner
-{
-    /**
-     * @Id
-     * @Column(type="integer")
-     * @GeneratedValue
-     */
-    public $id;
-
-    /** @column(type="string") */
-    public $name;
-    /**
-     * Inverse side
-     * @OneToOne(targetEntity="Bus", mappedBy="owner")
-     */
-    public $bus;
-
-    public function __construct($name)
-    {
-        $this->name = $name;
-    }
-
-    public function setBus(Bus $t)
-    {
-        $this->bus = $t;
-    }
 }