fix: Fix LazyServiceFactory to handle exception in constructor

src/Proxy/LazyServiceFactory.php

@@ -10,6 +10,7 @@
 use ProxyManager\Proxy\LazyLoadingInterface;
 use ProxyManager\Proxy\VirtualProxyInterface;
 use Psr\Container\ContainerInterface;
+use Throwable;
 
 use function sprintf;
 
@@ -42,8 +43,14 @@ public function __invoke(
     ): VirtualProxyInterface {
         if (isset($this->servicesMap[$name])) {
             $initializer = static function (&$wrappedInstance, LazyLoadingInterface $proxy) use ($callback): bool {
+                $initializer = $proxy->getProxyInitializer();
                 $proxy->setProxyInitializer(null);
-                $wrappedInstance = $callback();
+                try {
+                    $wrappedInstance = $callback();
+                } catch (Throwable $e) {
+                    $proxy->setProxyInitializer($initializer);
+                    throw $e;
+                }
 
                 return true;
             };

test/Proxy/LazyServiceFactoryTest.php

@@ -15,6 +15,7 @@
 use ProxyManager\Proxy\LazyLoadingInterface;
 use ProxyManager\Proxy\VirtualProxyInterface;
 use Psr\Container\ContainerInterface;
+use RuntimeException;
 
 #[CoversClass(LazyServiceFactory::class)]
 final class LazyServiceFactoryTest extends TestCase
@@ -94,4 +95,52 @@ static function ($className, $initializer) use ($expectedService, $proxy): MockO
 
         self::assertSame($expectedService, $result, 'service created not match the expected');
     }
+
+    public function testHandlesExceptionInInitializer(): void
+    {
+        $callback = function (): void {
+            throw new RuntimeException('Test exception');
+        };
+
+        $proxy       = $this->createMock(LazyLoadingInterface::class);
+        $initializer = static fn(): bool => true;
+
+        $proxy->expects(self::once())
+            ->method('getProxyInitializer')
+            ->willReturn($initializer);
+
+        $proxy
+            ->expects(self::exactly(2))
+            ->method('setProxyInitializer')
+            ->willReturnMap(
+                [
+                    [null],
+                    [$initializer],
+                ]
+            );
+
+        $expectedService = $this->createMock(VirtualProxyInterface::class);
+
+        $this->proxyFactory
+            ->expects(self::once())
+            ->method('createProxy')
+            ->willReturnCallback(
+                /** @psalm-suppress UnusedVariable */
+                static function (string $className, callable $initializer) use ($expectedService, $proxy): MockObject {
+                    self::assertEquals('FooClass', $className);
+
+                    try {
+                        $wrappedInstance = null;
+                        $initializer($wrappedInstance, $proxy);
+                        self::fail('Expected exception was not thrown');
+                    } catch (RuntimeException) {
+                    }
+
+                    return $expectedService;
+                }
+            );
+
+        $result = $this->factory->__invoke($this->container, 'fooService', $callback);
+        self::assertSame($expectedService, $result);
+    }
 }