Initial testing

src/Schema/Column.php

@@ -19,6 +19,7 @@ class Column extends AbstractAsset
 
     protected ?int $_length = null;
 
+    /** @var string[] */
     protected array $_members = [];
 
     protected ?int $_precision = null;
@@ -221,11 +222,13 @@ public function setAutoincrement(bool $flag): self
         return $this;
     }
 
+    /** @return string[] */
     public function getMembers(): array
     {
         return $this->_members;
     }
 
+    /** @param string[] $members */
     public function setMembers(array $members): void
     {
         $this->_members = $members;

src/Schema/MySQLSchemaManager.php

@@ -22,6 +22,7 @@
 use function implode;
 use function is_string;
 use function preg_match;
+use function preg_match_all;
 use function str_contains;
 use function strtok;
 use function strtolower;

src/Types/EnumType.php

@@ -10,100 +10,124 @@
 use Doctrine\DBAL\Platforms\SQLServerPlatform;
 use Doctrine\DBAL\Types\Exception\InvalidType;
 use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
+use ReflectionClass;
+use Throwable;
+
+use function array_map;
+use function class_exists;
+use function enum_exists;
+use function implode;
+use function is_string;
+use function sprintf;
 
 final class EnumType extends Type
 {
     public string $name = 'enum';
 
     public ?string $enumClassname = null;
 
+    /** @var array<int, string> */
     public array $members = [];
 
     /**
-     * Gets an array of database types that map to this Doctrine type.
-     *
-     * @return string[]
+     * {@inheritDoc}
      */
     public function getMappedDatabaseTypes(AbstractPlatform $platform): array
     {
         return [$this->name];
     }
 
     /**
-     * Gets the SQL declaration snippet for a field of this type.
-     *
-     * @param mixed[]          $column   The field declaration
-     * @param AbstractPlatform $platform The currently used database platform
+     * {@inheritDoc}
      */
     public function getSqlDeclaration(array $column, AbstractPlatform $platform): string
     {
-        assert($column['type'] instanceof self::class);
-
         $values = implode(
             ', ',
             array_map(
-                static fn (string $value) => "'{$value}'",
-                $column['members'] ?: $column['type']->members
-            )
+                static fn (string $value) => sprintf('\'%s\'', $value),
+                $column['members'] ?: $column['type']->members,
+            ),
         );
 
-        $sqlDeclaration = match (true) {
+        return match (true) {
             $platform instanceof SqlitePlatform => sprintf('TEXT CHECK(%s IN (%s))', $column['name'], $values),
             $platform instanceof PostgreSqlPlatform, $platform instanceof SQLServerPlatform => sprintf('VARCHAR(255) CHECK(%s IN (%s))', $column['name'], $values),
             default => sprintf('ENUM(%s)', $values),
         };
-
-        return $sqlDeclaration;
     }
 
     /**
-     * {@inheritdoc}
-     *
-     * @return mixed the database representation of the value
-     *
-     * @throws \InvalidArgumentException
+     * {@inheritDoc}
      */
     public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
     {
-        if (null === $value) {
+        if ($value === null) {
             return null;
         }
 
+        if ($value instanceof \UnitEnum) {
+            return $value->value;
+        }
+
         return (string) $value;
     }
 
     /**
-     * {@inheritdoc}
-     *
-     * @return mixed the PHP representation of the value
+     * {@inheritDoc}
      */
     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
     {
-        if (null === $value) {
+        if ($value === null) {
             return null;
         }
 
-        if (!\is_string($value)) {
+        if (! is_string($value)) {
             throw InvalidType::new($value, $this->name, ['null', 'string']);
         }
 
-        $refl = new \ReflectionClass($this->enumClassname);
-
-        try {
-            return $refl->newInstance($value);
-        } catch (\Throwable $e) {
-            throw ValueNotConvertible::new($value, $this->name, $e->getMessage(), $e);
+        if ($this->enumClassname) {
+            if (enum_exists($this->enumClassname)) {
+                try {
+                    //var_dump($this->enumClassname::cases());die();
+                    /*$refl = new \ReflectionEnum($this->enumClassname);
+                    foreach ($refl->getCases() as $case) {
+                        if ($value === $case->getValue()->value) {
+                            return $case->getValue();
+                        }
+                    }*/
+
+                    foreach ($this->enumClassname::cases() as $case) {
+                        if ($value === $case->value) {
+                            return $case;
+                        }
+                    }
+
+                    throw new \ValueError(sprintf("'%s' is not a valid backing value for enum %s", $value, $this->enumClassname));
+                } catch (Throwable $e) {
+                    throw ValueNotConvertible::new($value, $this->name, $e->getMessage(), $e);
+                }
+            }
+
+            if (class_exists($this->enumClassname)) {
+                $refl = new ReflectionClass($this->enumClassname);
+
+                try {
+                    return $refl->newInstance($value);
+                } catch (Throwable $e) {
+                    throw ValueNotConvertible::new($value, $this->name, $e->getMessage(), $e);
+                }
+            }
         }
+
+        return $value;
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public static function addType(string $name, string $enumClassname): void
     {
         self::getTypeRegistry()->register($name, $me = new self());
-        $me->name = $name;
+        $me->name          = $name;
         $me->enumClassname = $enumClassname;
-        $me->members = $enumClassname::getAllowedValues();
+        $me->members       = $enumClassname::getAllowedValues();
     }
 }

tests/Functional/Types/EnumTest.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tests\Functional\Types;
+
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Tests\FunctionalTestCase;
+use Doctrine\DBAL\Types\Types;
+
+class EnumTest extends FunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        $table = new Table('enum_table');
+        $table->addColumn('val', Types::ENUM, ['members' => ['a', 'b']]);
+
+        $this->dropAndCreateTable($table);
+    }
+
+    public function testInsertAndSelect(): void
+    {
+        $val = 'b';
+
+        $result = $this->connection->insert('enum_table', ['val' => $val]);
+        self::assertSame(1, $result);
+
+        $value = $this->connection->fetchOne('SELECT val FROM enum_table');
+
+        self::assertEquals($val, $value);
+    }
+}

tests/Schema/ColumnTest.php

@@ -45,6 +45,7 @@ public function testToArray(): void
             'default' => 'baz',
             'notnull' => false,
             'length' => 200,
+            'members' => [],
             'precision' => 5,
             'scale' => 2,
             'fixed' => true,
@@ -148,4 +149,17 @@ public function testColumnComment(): void
         self::assertArrayHasKey('comment', $columnArray);
         self::assertEquals('foo', $columnArray['comment']);
     }
+
+    public function testEnumMembers(): void
+    {
+        $column = new Column('bar', Type::getType(Types::ENUM));
+        self::assertSame([], $column->getMembers());
+
+        $column->setMembers(['a', 'b']);
+        self::assertEquals(['a', 'b'], $column->getMembers());
+
+        $columnArray = $column->toArray();
+        self::assertArrayHasKey('members', $columnArray);
+        self::assertEquals(['a', 'b'], $columnArray['members']);
+    }
 }

tests/Types/EnumTest.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tests\Types;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\EnumType;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+use function anonymous_class;
+
+class EnumTest extends TestCase
+{
+    private AbstractPlatform&MockObject $platform;
+    private EnumType $type;
+
+    protected function setUp(): void
+    {
+        $this->platform = $this->createMock(AbstractPlatform::class);
+        $this->type = new EnumType();
+    }
+
+    public function testReturnsSQLDeclaration(): void
+    {
+        self::assertSame('ENUM(\'a\', \'b\')', $this->type->getSQLDeclaration(['members' => ['a', 'b']], $this->platform));
+    }
+
+    public function testConvertToPHPValue(): void
+    {
+        self::assertIsString($this->type->convertToPHPValue('foo', $this->platform));
+        self::assertIsString($this->type->convertToPHPValue('', $this->platform));
+        self::assertNull($this->type->convertToPHPValue(null, $this->platform));
+    }
+
+    public function testConvertToPHPEnum(): void
+    {
+        $this->type->enumClassname = EnumPhp::class;
+
+        self::assertInstanceOf($this->type->enumClassname, $this->type->convertToPHPValue('a', $this->platform));
+        self::assertSame(EnumPhp::VALUE_A, $this->type->convertToPHPValue('a', $this->platform));
+        self::assertNull($this->type->convertToPHPValue(null, $this->platform));
+    }
+
+    public function testConvertToPHPObject(): void
+    {
+        $this->type->enumClassname = EnumClass::class;
+
+        self::assertInstanceOf($this->type->enumClassname, $this->type->convertToPHPValue('a', $this->platform));
+        self::assertEquals(new EnumClass('a'), $this->type->convertToPHPValue('a', $this->platform));
+        self::assertNull($this->type->convertToPHPValue(null, $this->platform));
+    }
+
+    public function testConvertStringToDatabaseValue(): void
+    {
+        self::assertSame('a', $this->type->convertToDatabaseValue('a', $this->platform));
+        self::assertNull($this->type->convertToDatabaseValue(null, $this->platform));
+    }
+
+    public function testConvertEnumToDatabaseValue(): void
+    {
+        $this->type->enumClassname = EnumPhp::class;
+
+        self::assertSame('a', $this->type->convertToDatabaseValue(EnumPhp::VALUE_A, $this->platform));
+        self::assertNull($this->type->convertToDatabaseValue(null, $this->platform));
+    }
+
+    public function testConvertObjectToDatabaseValue(): void
+    {
+        $enum = new EnumClass('a');
+        $this->type->enumClassname = EnumClass::class;
+
+        self::assertSame('a', $this->type->convertToDatabaseValue($enum, $this->platform));
+        self::assertNull($this->type->convertToDatabaseValue(null, $this->platform));
+    }
+}
+
+enum EnumPhp: string
+{
+    case VALUE_A = 'a';
+    case VALUE_B = 'b';
+}
+
+final class EnumClass implements \Stringable {
+    function __construct(
+        private ?string $value
+    ) {
+    }
+
+    function __tostring(): string
+    {
+        return $this->value;
+    }
+};