Write unhappy tests

src/Types/EnumType.php

@@ -9,17 +9,19 @@
 use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
 use Doctrine\DBAL\Platforms\SQLitePlatform;
 use Doctrine\DBAL\Platforms\SQLServerPlatform;
+use Doctrine\DBAL\Types\Exception\InvalidFormat;
 use Doctrine\DBAL\Types\Exception\InvalidType;
 use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
 use ReflectionClass;
+use StringBackedEnum;
 use Throwable;
 use UnitEnum;
-use ValueError;
 
 use function array_map;
 use function class_exists;
 use function enum_exists;
 use function implode;
+use function is_object;
 use function is_string;
 use function sprintf;
 
@@ -69,14 +71,34 @@ public function convertToDatabaseValue($value, AbstractPlatform $platform): ?str
             return null;
         }
 
-        if ($value instanceof UnitEnum) {
-            if ($value instanceof BackedEnum) {
+        if ($this->enumClassname === null) {
+            if (! is_string($value)) {
+                throw InvalidType::new($value, $this->name, ['null', 'string']);
+            }
+
+            if (! in_array($value, $this->members)) {
+                throw InvalidType::new($value, $this->name, ['null', 'string']);
+            }
+
+            return $value;
+        }
+
+        if (enum_exists($this->enumClassname)) {
+            if (! $value instanceof UnitEnum) {
+                throw InvalidType::new($value, $this->name, ['null', $this->enumClassname]);
+            }
+
+            if ($value instanceof \BackedEnum) {
                 return $value->value;
             }
 
             return $value->name;
         }
 
+        if (! (is_object($value) && $value::class === $this->enumClassname)) {
+            throw InvalidType::new($value, $this->name, ['null', $this->enumClassname]);
+        }
+
         return (string) $value;
     }
 
@@ -87,35 +109,46 @@ public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mix
         }
 
         if (! is_string($value)) {
-            throw InvalidType::new($value, $this->name, ['null', 'string']);
+            throw InvalidFormat::new($value, $this->name, ['null', 'string']);
         }
 
-        if ($this->enumClassname) {
-            if (enum_exists($this->enumClassname)) {
-                try {
-                    foreach ($this->enumClassname::cases() as $case) {
-                        if (($case instanceof BackedEnum && $value === $case->value) || $value === $case->name) {
-                            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 ($this->enumClassname === null) {
+            if (! in_array($value, $this->members)) {
+                throw ValueNotConvertible::new($value, $this->name);
             }
 
-            if (class_exists($this->enumClassname)) {
-                $refl = new ReflectionClass($this->enumClassname);
+            return $value;
+        }
 
-                try {
-                    return $refl->newInstance($value);
-                } catch (Throwable $e) {
-                    throw ValueNotConvertible::new($value, $this->name, $e->getMessage(), $e);
+        if (enum_exists($this->enumClassname)) {
+            foreach ($this->enumClassname::cases() as $case) {
+                if (($case instanceof BackedEnum && $value === $case->value) || $value === $case->name) {
+                    return $case;
                 }
             }
+
+            throw ValueNotConvertible::new($value, $this->getInternalDocrineType());
+        }
+
+        if (class_exists($this->enumClassname)) {
+            $refl = new ReflectionClass($this->enumClassname);
+
+            try {
+                return $refl->newInstance($value);
+            } catch (Throwable $e) {
+                throw ValueNotConvertible::new($value, $this->getInternalDocrineType(), $e->getMessage(), $e);
+            }
+        }
+
+        throw new ConversionException(sprintf('Class %s does not exists', $this->enumClassname));
+    }
+
+    private function getInternalDocrineType(): string
+    {
+        if ($this->enumClassname) {
+            return sprintf('%s(%s)', $this->name, $this->enumClassname);
         }
 
-        return $value;
+        return sprintf('%s(%s)', $this->name, 'string');
     }
 }

tests/Types/EnumTest.php

@@ -5,7 +5,9 @@
 namespace Doctrine\DBAL\Tests\Types;
 
 use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\ConversionException;
 use Doctrine\DBAL\Types\EnumType;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use Stringable;
@@ -62,6 +64,8 @@ public function testConvertToPHPObject(): void
 
     public function testConvertStringToDatabaseValue(): void
     {
+        $this->type->members = ['a', 'b'];
+
         self::assertSame('a', $this->type->convertToDatabaseValue('a', $this->platform));
         self::assertNull($this->type->convertToDatabaseValue(null, $this->platform));
     }
@@ -89,6 +93,107 @@ public function testConvertObjectToDatabaseValue(): void
         self::assertSame('a', $this->type->convertToDatabaseValue(new EnumClass('a'), $this->platform));
         self::assertNull($this->type->convertToDatabaseValue(null, $this->platform));
     }
+
+    #[DataProvider('provideInvalidDataForEnumStringToDatabaseValueConversion')]
+    public function testEnumStringDoesNotSupportInvalidValuesToDatabaseValueConversion($value): void
+    {
+        $this->expectException(ConversionException::class);
+
+        $this->type->convertToDatabaseValue($value, $this->platform);
+    }
+
+    public static function provideInvalidDataForEnumStringToDatabaseValueConversion()
+    {
+        return [
+            'boolean true' => [true],
+            'boolean false' => [false],
+            'integer' => [17],
+            'string' => ['not_in_members'],
+            'array' => [['']],
+            'enum' => [EnumPhp::A],
+            'enum backed' => [EnumPhpBacked::A],
+            'object' => [new \stdClass()],
+            'stringable' => [new class() { function __toString() { return 'a'; }}],
+        ];
+    }
+
+    #[DataProvider('provideInvalidDataForEnumPhpToDatabaseValueConversion')]
+    public function testEnumPhpDoesNotSupportInvalidValuesToDatabaseValueConversion($value): void
+    {
+        $this->expectException(ConversionException::class);
+
+        $this->type->convertToDatabaseValue($value, $this->platform);
+    }
+
+    public static function provideInvalidDataForEnumPhpToDatabaseValueConversion()
+    {
+        return [
+            'boolean true' => [true],
+            'boolean false' => [false],
+            'integer' => [17],
+            'string' => ['a'],
+            'array' => [['']],
+            'enum' => [WrongEnumPhp::WRONG],
+            'enum backed' => [EnumPhpBacked::A],
+            'object' => [new \stdClass()],
+            'stringable' => [new class() { function __toString() { return 'a'; }}],
+        ];
+    }
+
+    #[DataProvider('provideInvalidDataForEnumPhpBackedToDatabaseValueConversion')]
+    public function testEnumPhpBackedDoesNotSupportInvalidValuesToDatabaseValueConversion($value): void
+    {
+        $this->expectException(ConversionException::class);
+
+        $this->type->convertToDatabaseValue($value, $this->platform);
+    }
+
+    public static function provideInvalidDataForEnumPhpBackedToDatabaseValueConversion()
+    {
+        return [
+            'boolean true' => [true],
+            'boolean false' => [false],
+            'integer' => [17],
+            'string' => ['a'],
+            'array' => [['']],
+            'enum' => [EnumPhp::A],
+            'enum backed' => [WrongEnumPhpBacked::WRONG],
+            'object' => [new \stdClass()],
+            'stringable' => [new class() { function __toString() { return 'a'; }}],
+        ];
+    }
+
+    #[DataProvider('provideInvalidDataForEnumObjectToDatabaseValueConversion')]
+    public function testEnumObjectDoesNotSupportInvalidValuesToDatabaseValueConversion($value): void
+    {
+        $this->expectException(ConversionException::class);
+
+        $this->type->convertToDatabaseValue($value, $this->platform);
+    }
+
+    public static function provideInvalidDataForEnumObjectToDatabaseValueConversion()
+    {
+        return [
+            'boolean true' => [true],
+            'boolean false' => [false],
+            'integer' => [17],
+            'string' => ['a'],
+            'array' => [['']],
+            'enum' => [EnumPhp::A],
+            'enum backed' => [EnumPhpBacked::A],
+            'object' => [new \stdClass()],
+            'stringable' => [new class() { function __toString() { return 'a'; }}],
+        ];
+    }
+
+    public function testInvalidValueForDatabaseValueToEnumStringConversion(): void
+    {
+        $this->type->members = ['a', 'b'];
+
+        $this->expectException(ConversionException::class);
+
+        $this->type->convertToPHPValue('not_in_members', $this->platform);
+    }
 }
 
 enum EnumPhp
@@ -97,13 +202,22 @@ enum EnumPhp
     case B;
 }
 
+enum WrongEnumPhp
+{
+    case WRONG;
+}
 
 enum EnumPhpBacked: string
 {
     case A = 'a';
     case B = 'b';
 }
 
+enum WrongEnumPhpBacked: string
+{
+    case WRONG = 'wrong';
+}
+
 final class EnumClass implements Stringable
 {
     public function __construct(