From 760de2742d0fe78afb24ebd1b0355646c82b1c2e Mon Sep 17 00:00:00 2001 From: David Badura Date: Fri, 6 Nov 2026 18:40:09 +0100 Subject: [PATCH] Use an enum type when looking up the class normalizer of an enum getNormalizerOnClass always built the class type with Type::object(), so the guesser never saw a BackedEnumType for an enum class and never offered the EnumNormalizer. Extracting a backed enum directly gave its name and value, and hydrating it failed. An EnumNormalizer attribute without an explicit enum, on the enum or on an interface it implements, failed with a missing type for the same reason. The type is now built the way the type resolver builds it for a property of that class. An enum property with an explicit ObjectNormalizer also needs #239 to be hydrated again. --- src/Metadata/AttributeMetadataFactory.php | 5 ++- tests/Unit/Fixture/HasEnumNormalizer.php | 12 ++++++ tests/Unit/Fixture/PureEnum.php | 11 +++++ .../Fixture/StatusWithInterfaceNormalizer.php | 11 +++++ .../Metadata/AttributeMetadataFactoryTest.php | 42 +++++++++++++++++++ tests/Unit/StackHydratorTest.php | 26 ++++++++++++ 6 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 tests/Unit/Fixture/HasEnumNormalizer.php create mode 100644 tests/Unit/Fixture/PureEnum.php create mode 100644 tests/Unit/Fixture/StatusWithInterfaceNormalizer.php diff --git a/src/Metadata/AttributeMetadataFactory.php b/src/Metadata/AttributeMetadataFactory.php index b3d530d1..67c7d41a 100644 --- a/src/Metadata/AttributeMetadataFactory.php +++ b/src/Metadata/AttributeMetadataFactory.php @@ -219,7 +219,10 @@ private function getNormalizer(ReflectionProperty $reflectionProperty, Type $typ /** @param ReflectionClass $reflectionClass */ private function getNormalizerOnClass(ReflectionClass $reflectionClass): Normalizer|null { - $type = Type::object($reflectionClass->getName()); + // Build the type like the type resolver does for a property of this class, + // so enums get an enum type and the guesser can offer the EnumNormalizer. + $className = $reflectionClass->getName(); + $type = $reflectionClass->isEnum() ? Type::enum($className) : Type::object($className); $normalizer = $this->inferNormalizerByType($type); if ($normalizer instanceof ObjectNormalizer) { diff --git a/tests/Unit/Fixture/HasEnumNormalizer.php b/tests/Unit/Fixture/HasEnumNormalizer.php new file mode 100644 index 00000000..9a211849 --- /dev/null +++ b/tests/Unit/Fixture/HasEnumNormalizer.php @@ -0,0 +1,12 @@ +normalizer); } + + public function testClassMetadataOfBackedEnumGetsEnumNormalizer(): void + { + $metadataFactory = new AttributeMetadataFactory(); + $metadata = $metadataFactory->metadata(Status::class); + + self::assertEquals(new EnumNormalizer(Status::class), $metadata->normalizer); + } + + public function testClassMetadataOfBackedEnumWithEnumNormalizerAttribute(): void + { + $metadataFactory = new AttributeMetadataFactory(); + $metadata = $metadataFactory->metadata(StatusWithNormalizer::class); + + self::assertEquals(new EnumNormalizer(StatusWithNormalizer::class), $metadata->normalizer); + } + + public function testClassMetadataOfPureEnumHasNoNormalizer(): void + { + $metadataFactory = new AttributeMetadataFactory(); + $metadata = $metadataFactory->metadata(PureEnum::class); + + self::assertNull($metadata->normalizer); + } + + public function testGuesserGetsEnumTypeForEnumClass(): void + { + $guesser = $this->createMock(Guesser::class); + $guesser + ->expects(self::once()) + ->method('guess') + ->with(Type::enum(PureEnum::class)) + ->willReturn(null); + + $metadataFactory = new AttributeMetadataFactory(guesser: $guesser); + $metadata = $metadataFactory->metadata(PureEnum::class); + + self::assertNull($metadata->normalizer); + } } diff --git a/tests/Unit/StackHydratorTest.php b/tests/Unit/StackHydratorTest.php index 8b8e3195..162e9c1c 100644 --- a/tests/Unit/StackHydratorTest.php +++ b/tests/Unit/StackHydratorTest.php @@ -45,6 +45,7 @@ use Patchlevel\Hydrator\Tests\Unit\Fixture\ProfileId; use Patchlevel\Hydrator\Tests\Unit\Fixture\Skill; use Patchlevel\Hydrator\Tests\Unit\Fixture\Status; +use Patchlevel\Hydrator\Tests\Unit\Fixture\StatusWithInterfaceNormalizer; use Patchlevel\Hydrator\Tests\Unit\Fixture\StatusWithNormalizer; use Patchlevel\Hydrator\Tests\Unit\Fixture\ValueObject; use Patchlevel\Hydrator\Tests\Unit\Fixture\WrongNormalizer; @@ -238,6 +239,11 @@ public function testExtractWithClassNormalizer(): void self::assertEquals('id', $data); } + public function testExtractBackedEnum(): void + { + self::assertSame('draft', $this->hydrator->extract(Status::Draft)); + } + public function testHydrate(): void { $expected = new ProfileCreated( @@ -567,6 +573,26 @@ public function testHydrateWithClassNormalizer(): void self::assertEquals(ProfileId::fromString('id'), $object); } + public function testHydrateBackedEnum(): void + { + self::assertSame(Status::Draft, $this->hydrator->hydrate(Status::class, 'draft')); + } + + public function testBackedEnumWithEnumNormalizerOnTheEnum(): void + { + self::assertSame('draft', $this->hydrator->extract(StatusWithNormalizer::Draft)); + self::assertSame(StatusWithNormalizer::Draft, $this->hydrator->hydrate(StatusWithNormalizer::class, 'draft')); + } + + public function testBackedEnumWithEnumNormalizerFromAnInterface(): void + { + self::assertSame('draft', $this->hydrator->extract(StatusWithInterfaceNormalizer::Draft)); + self::assertSame( + StatusWithInterfaceNormalizer::Draft, + $this->hydrator->hydrate(StatusWithInterfaceNormalizer::class, 'draft'), + ); + } + #[RequiresPhp('>=8.4')] public function testLazyHydrate(): void {