Run functional tests without the doctrine-orm-infrastructure dependency (#85)

I am unsure about the future of the [Doctrine-ORM-Test-infrastructure
package](https://github.com/webfactory/doctrine-orm-test-infrastructure/):
Recent deprecations in ORM 3 and especially DBAL 3 make it seem harder
and harder to come up with something that closely resembles a working
ORM setup "out of nothing".

So, this PR gets rid of that dependency. It builds upon Symfonys
functional testing infrastructure, and configures a copy of the default
entity manager in the DIC. This is good enough to have separate channels
for importing/loading data and still having a pristine entity manager
afterwards (altough, admittedly, a `clear()` call would probably have
the same effect?).

Also, setting up the schema in memory is not all too complicated,
leveraging the ORM's schema tool.

Author: mpdude

composer.json

@@ -26,7 +26,7 @@
         "doctrine/event-manager": "^1.1|^2.0",
         "doctrine/orm": "^2.13|^3.0",
         "doctrine/persistence": "^2.4|^3.1",
-        "psr/log": "^1.0|^2.0|^3.0",
+        "psr/log": "^2.0|^3.0",
         "symfony/config": "^6.4|^7.0",
         "symfony/dependency-injection": "^6.4|^7.0",
         "symfony/deprecation-contracts": "^2.0|^3.0",
@@ -39,8 +39,7 @@
         "doctrine/doctrine-bundle": "^2.12",
         "phpunit/phpunit": "^10.5.58",
         "symfony/framework-bundle": "^6.4|^7.0",
-        "symfony/yaml": "^6.4|^7.0",
-        "webfactory/doctrine-orm-test-infrastructure": "^1.14"
+        "symfony/yaml": "^6.4|^7.0"
     },
 
     "config": {

tests/Doctrine/TranslatableClassMetadataTest.php

@@ -2,15 +2,12 @@
 
 namespace Webfactory\Bundle\PolyglotBundle\Tests\Doctrine;
 
-use Doctrine\ORM\Mapping\Driver\AttributeDriver;
 use Doctrine\Persistence\Mapping\RuntimeReflectionService;
-use PHPUnit\Framework\TestCase;
 use Webfactory\Bundle\PolyglotBundle\Doctrine\TranslatableClassMetadata;
 use Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\TestEntity;
-use Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\TestEntityTranslation;
-use Webfactory\Doctrine\ORMTestInfrastructure\ORMInfrastructure;
+use Webfactory\Bundle\PolyglotBundle\Tests\Functional\DatabaseFunctionalTestCase;
 
-class TranslatableClassMetadataTest extends TestCase
+class TranslatableClassMetadataTest extends DatabaseFunctionalTestCase
 {
     /**
      * @test
@@ -27,11 +24,7 @@ public function can_be_serialized_and_retrieved(): void
 
     private function createMetadata(): TranslatableClassMetadata
     {
-        $infrastructure = new ORMInfrastructure([
-            TestEntity::class,
-            TestEntityTranslation::class,
-        ], mappingDriver: new AttributeDriver([], true));
-        $entityManager = $infrastructure->getEntityManager();
+        $entityManager = $this->entityManager;
 
         return TranslatableClassMetadata::parseFromClass(TestEntity::class, $entityManager->getMetadataFactory());
     }

tests/Fixtures/Entity/CascadePersist/CascadePersistTranslationsTest_Entity.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\CascadePersist;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+use Webfactory\Bundle\PolyglotBundle\Translatable;
+use Webfactory\Bundle\PolyglotBundle\TranslatableInterface;
+
+#[Polyglot\Locale(primary: 'en_GB')]
+#[ORM\Entity]
+class CascadePersistTranslationsTest_Entity
+{
+    #[ORM\Column]
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    private ?int $id = null;
+
+    /**
+     * (!) There is *not* cascade="persist" configuration here.
+     */
+    #[Polyglot\TranslationCollection]
+    #[ORM\OneToMany(targetEntity: CascadePersistTranslationsTest_Translation::class, mappedBy: 'entity')]
+    protected Collection $translations;
+
+    #[Polyglot\Translatable]
+    #[ORM\Column(type: 'string')]
+    protected string|TranslatableInterface $text;
+
+    public function __construct()
+    {
+        $this->text = new Translatable('test en_GB');
+        $this->translations = new ArrayCollection();
+    }
+
+    public function addTranslation(string $locale, mixed $text): void
+    {
+        $this->text->setTranslation($text, $locale);
+    }
+}

tests/Fixtures/Entity/CascadePersist/CascadePersistTranslationsTest_Translation.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\CascadePersist;
+
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+
+#[ORM\Entity]
+class CascadePersistTranslationsTest_Translation
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    private ?int $id = null;
+
+    #[Polyglot\Locale]
+    #[ORM\Column]
+    private string $locale;
+
+    #[ORM\ManyToOne(inversedBy: 'translations')]
+    private CascadePersistTranslationsTest_Entity $entity;
+
+    #[ORM\Column]
+    private string $text;
+}

tests/Fixtures/Entity/EntityInheritance/EntityInheritance_BaseEntityClass.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\EntityInheritance;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+use Webfactory\Bundle\PolyglotBundle\TranslatableInterface;
+
+#[Polyglot\Locale(primary: 'en_GB')]
+#[ORM\Entity]
+#[ORM\InheritanceType(value: 'SINGLE_TABLE')]
+#[ORM\DiscriminatorMap(['base' => 'EntityInheritance_BaseEntityClass', 'child' => 'EntityInheritance_ChildEntityClass'])]
+#[ORM\DiscriminatorColumn(name: 'discriminator', type: 'string')]
+class EntityInheritance_BaseEntityClass
+{
+    #[ORM\Column(type: 'integer')]
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    private ?int $id = null;
+
+    private string $discriminator;
+
+    #[Polyglot\TranslationCollection]
+    #[ORM\OneToMany(targetEntity: EntityInheritance_BaseEntityClassTranslation::class, mappedBy: 'entity')]
+    private Collection $translations;
+
+    #[Polyglot\Translatable]
+    #[ORM\Column(type: 'string')]
+    private TranslatableInterface|string|null $text = null;
+
+    public function __construct()
+    {
+        $this->translations = new ArrayCollection();
+    }
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    public function setText(TranslatableInterface $text): void
+    {
+        $this->text = $text;
+    }
+
+    public function getText(): TranslatableInterface
+    {
+        return $this->text;
+    }
+}

tests/Fixtures/Entity/EntityInheritance/EntityInheritance_BaseEntityClassTranslation.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\EntityInheritance;
+
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+
+#[ORM\Entity]
+class EntityInheritance_BaseEntityClassTranslation
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    private ?int $id = null;
+
+    #[Polyglot\Locale]
+    #[ORM\Column]
+    private string $locale;
+
+    #[ORM\ManyToOne(inversedBy: 'translations')]
+    private EntityInheritance_BaseEntityClass $entity;
+
+    #[ORM\Column]
+    private string $text;
+}

tests/Fixtures/Entity/EntityInheritance/EntityInheritance_ChildEntityClass.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\EntityInheritance;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+use Webfactory\Bundle\PolyglotBundle\TranslatableInterface;
+
+#[ORM\Entity]
+class EntityInheritance_ChildEntityClass extends EntityInheritance_BaseEntityClass
+{
+    #[Polyglot\Translatable]
+    #[ORM\Column(type: 'string')]
+    private TranslatableInterface|string|null $extraText = null;
+
+    #[Polyglot\TranslationCollection]
+    #[ORM\OneToMany(targetEntity: EntityInheritance_ChildEntityClassTranslation::class, mappedBy: 'entity')]
+    private Collection $extraTranslations;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->extraTranslations = new ArrayCollection();
+    }
+
+    public function setExtra(TranslatableInterface $extraText): void
+    {
+        $this->extraText = $extraText;
+    }
+
+    public function getExtraText(): TranslatableInterface
+    {
+        return $this->extraText;
+    }
+}

tests/Fixtures/Entity/EntityInheritance/EntityInheritance_ChildEntityClassTranslation.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\EntityInheritance;
+
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+
+#[ORM\Entity]
+class EntityInheritance_ChildEntityClassTranslation
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    private ?int $id = null;
+
+    #[Polyglot\Locale]
+    #[ORM\Column]
+    private string $locale;
+
+    #[ORM\ManyToOne(inversedBy: 'extraTranslations')]
+    private EntityInheritance_ChildEntityClass $entity;
+
+    #[ORM\Column]
+    private string $extraText;
+}

tests/Fixtures/Entity/StronglyTyped/StronglyTypedTranslationsTest_Entity.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\StronglyTyped;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+use Webfactory\Bundle\PolyglotBundle\Translatable;
+use Webfactory\Bundle\PolyglotBundle\TranslatableInterface;
+
+#[Polyglot\Locale(primary: 'en_GB')]
+#[ORM\Entity]
+class StronglyTypedTranslationsTest_Entity
+{
+    #[ORM\Column(type: 'integer')]
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    public ?int $id = null;
+
+    #[Polyglot\TranslationCollection]
+    #[ORM\OneToMany(targetEntity: StronglyTypedTranslationsTest_Translation::class, mappedBy: 'entity')]
+    public Collection $translations;
+
+    /**
+     * @var TranslatableInterface<string>
+     */
+    #[Polyglot\Translatable]
+    #[ORM\Column(type: 'translatable_string', options: ['use_text_column' => true])]
+    public TranslatableInterface $text;
+
+    public function __construct()
+    {
+        $this->text = new Translatable();
+        $this->translations = new ArrayCollection();
+    }
+}

tests/Fixtures/Entity/StronglyTyped/StronglyTypedTranslationsTest_Translation.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Webfactory\Bundle\PolyglotBundle\Tests\Fixtures\Entity\StronglyTyped;
+
+use Doctrine\ORM\Mapping as ORM;
+use Webfactory\Bundle\PolyglotBundle\Attribute as Polyglot;
+
+#[ORM\Entity]
+class StronglyTypedTranslationsTest_Translation
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    public ?int $id = null;
+
+    #[Polyglot\Locale]
+    #[ORM\Column]
+    public string $locale;
+
+    #[ORM\ManyToOne(targetEntity: StronglyTypedTranslationsTest_Entity::class, inversedBy: 'translations')]
+    public StronglyTypedTranslationsTest_Entity $entity;
+
+    #[ORM\Column]
+    public string $text;
+}