Merge pull request #78 from boesing/bugfix/resolved-aliases-non-share…

…d-service Regression in 3.6.x regarding aliased services in combination with non-shared services
laminas · Jan 25, 2021 · bf5fe52 · bf5fe52
2 parents 11ea2dd + 0cd0a07
commit bf5fe52
Show file tree

Hide file tree

Showing 2 changed files with 93 additions and 0 deletions.
diff --git a/src/ServiceManager.php b/src/ServiceManager.php
@@ -211,6 +211,11 @@ public function get($name)
         // We now deal with requests which may be aliases.
         $resolvedName = isset($this->aliases[$name]) ? $this->aliases[$name] : $name;
 
+        // Update shared service information as we checked if the alias was shared before.
+        if ($resolvedName !== $name) {
+            $sharedService = $this->shared[$resolvedName] ?? $sharedService;
+        }
+
         // The following is only true if the requested service is a shared alias.
         $sharedAlias = $sharedService && isset($this->services[$resolvedName]);
 

diff --git a/test/ServiceManagerTest.php b/test/ServiceManagerTest.php
@@ -476,4 +476,92 @@ static function (object $service) use (&$initializerTwoCalled): object {
         self::assertTrue($initializerOneCalled, 'First initializer was not called');
         self::assertTrue($initializerTwoCalled, 'Second initializer was not called');
     }
+
+    /**
+     * @param array<string,mixed>  $config
+     * @param non-empty-string $serviceName
+     * @param non-empty-string $alias
+     * @dataProvider aliasedServices
+     */
+    public function testWontShareServiceWhenRequestedByAlias(array $config, string $serviceName, string $alias): void
+    {
+        $serviceManager = new ServiceManager($config);
+        $service = $serviceManager->get($serviceName);
+        $serviceFromAlias = $serviceManager->get($alias);
+        $serviceFromServiceNameAfterUsingAlias = $serviceManager->get($serviceName);
+
+        self::assertNotSame($service, $serviceFromAlias);
+        self::assertNotSame($service, $serviceFromServiceNameAfterUsingAlias);
+        self::assertNotSame($serviceFromAlias, $serviceFromServiceNameAfterUsingAlias);
+    }
+
+    /**
+     * @return array<non-empty-string,array{0:array<string,mixed>,1:non-empty-string,2:non-empty-string}>
+     */
+    public function aliasedServices(): array
+    {
+        return [
+            'invokables' => [
+                [
+                    'invokables' => [
+                        stdClass::class => stdClass::class,
+                    ],
+                    'aliases' => [
+                        'object' => stdClass::class,
+                    ],
+                    'shared' => [
+                        stdClass::class => false,
+                    ],
+                ],
+                stdClass::class,
+                'object',
+            ],
+            'factories' => [
+                [
+                    'factories' => [
+                        stdClass::class => static function (): stdClass {
+                            return new stdClass();
+                        },
+                    ],
+                    'aliases' => [
+                        'object' => stdClass::class,
+                    ],
+                    'shared' => [
+                        stdClass::class => false,
+                    ],
+                ],
+                stdClass::class,
+                'object',
+            ],
+            'abstract factories' => [
+                [
+                    'abstract_factories' => [
+                        new class implements AbstractFactoryInterface {
+
+                            public function canCreate(\Interop\Container\ContainerInterface $container, $requestedName)
+                            {
+                                return $requestedName === stdClass::class;
+                            }
+
+                            public function __invoke(
+                                \Interop\Container\ContainerInterface $container,
+                                $requestedName,
+                                array $options = null
+                            ) {
+                                return new stdClass();
+                            }
+                        }
+                    ],
+                    'aliases' => [
+                        'object' => stdClass::class,
+                    ],
+                    'shared' => [
+                        stdClass::class => false,
+                    ],
+                ],
+                stdClass::class,
+                'object',
+            ],
+        ];
+    }
 }