Convert proxy factory auto generate mode to integer

lib/Doctrine/Common/Proxy/AbstractProxyFactory.php

@@ -69,6 +69,13 @@ abstract class AbstractProxyFactory
      */
     const AUTOGENERATE_EVAL = 3;
 
+    private const AUTOGENERATE_MODES = [
+        self::AUTOGENERATE_NEVER,
+        self::AUTOGENERATE_ALWAYS,
+        self::AUTOGENERATE_FILE_NOT_EXISTS,
+        self::AUTOGENERATE_EVAL
+    ];
+
     /**
      * @var \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory
      */
@@ -80,7 +87,7 @@ abstract class AbstractProxyFactory
     private $proxyGenerator;
 
     /**
-     * @var bool Whether to automatically (re)generate proxy classes.
+     * @var int Whether to automatically (re)generate proxy classes.
      */
     private $autoGenerate;
 
@@ -93,12 +100,19 @@ abstract class AbstractProxyFactory
      * @param \Doctrine\Common\Proxy\ProxyGenerator                     $proxyGenerator
      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory $metadataFactory
      * @param bool|int                                                  $autoGenerate
+     *
+     * @throws \Doctrine\Common\Proxy\Exception\InvalidArgumentException When auto generate mode is not valid.
      */
     public function __construct(ProxyGenerator $proxyGenerator, ClassMetadataFactory $metadataFactory, $autoGenerate)
     {
         $this->proxyGenerator  = $proxyGenerator;
         $this->metadataFactory = $metadataFactory;
-        $this->autoGenerate    = (bool)$autoGenerate;
+
+        if ( ! in_array($autoGenerate, self::AUTOGENERATE_MODES, false)) {
+            throw InvalidArgumentException::invalidAutoGenerateMode($autoGenerate);
+        }
+
+        $this->autoGenerate = (int)$autoGenerate;
     }
 
     /**

lib/Doctrine/Common/Proxy/Exception/InvalidArgumentException.php

@@ -109,4 +109,14 @@ public static function classMustNotBeFinal($className)
     {
         return new self(sprintf('Unable to create a proxy for a final class "%s".', $className));
     }
+
+    /**
+     * @param mixed $value
+     *
+     * @return self
+     */
+    public static function invalidAutoGenerateMode($value): self
+    {
+        return new self(sprintf('Invalid auto generate mode "%s" given.', $value));
+    }
 }

tests/Doctrine/Tests/Common/Proxy/AbstractProxyFactoryTest.php

@@ -14,6 +14,52 @@
 
 class AbstractProxyFactoryTest extends DoctrineTestCase
 {
+    public function dataAutoGenerateValues(): array
+    {
+        return [
+            [0, 0],
+            [1, 1],
+            [2, 2],
+            [3, 3],
+            ['2', 2],
+            [true, 1],
+            [false, 0],
+            ['', 0]
+        ];
+    }
+
+    /**
+     * @dataProvider dataAutoGenerateValues
+     *
+     * @param mixed $autoGenerate
+     * @param int $expected
+     */
+    public function testNoExceptionIsThrownForValidIntegerAutoGenerateValues($autoGenerate, int $expected): void
+    {
+        $proxyGenerator = $this->createMock(ProxyGenerator::class);
+        $metadataFactory = $this->createMock(ClassMetadataFactory::class);
+
+        $proxyFactory = $this->getMockForAbstractClass(
+            AbstractProxyFactory::class,
+            [$proxyGenerator, $metadataFactory, $autoGenerate]
+        );
+
+        self::assertAttributeSame($expected, 'autoGenerate', $proxyFactory);
+    }
+
+    public function testInvalidAutoGenerateValueThrowsException(): void
+    {
+        $proxyGenerator = $this->createMock(ProxyGenerator::class);
+        $metadataFactory = $this->createMock(ClassMetadataFactory::class);
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $this->getMockForAbstractClass(
+            AbstractProxyFactory::class,
+            [$proxyGenerator, $metadataFactory, 5]
+        );
+    }
+
     public function testGenerateProxyClasses()
     {
         $metadata       = $this->createMock(ClassMetadata::class);