Fix security context missing in Doctrine entity listeners after kernel reboot

Persisting an EntityManager across kernel reboots binds its internal
ListenersInvoker to the old container. Lazy entity listeners then resolve
dependencies like security.token_storage from that stale container, making
the logged-in user invisible inside the listener while it is visible in the
controller. In pure Symfony (WebTestCase) there is no reboot, one container,
so the listener and the controller share the same security context.

Fix, in two parts that share one idea -- only the DBAL connection survives a
reboot; rebuild everything else on top of it from the current container:

- injectPersistentServices() no longer re-injects EntityManagerInterface or
  ManagerRegistry instances. The freshly booted container rebuilds the
  EntityManager on the persisted connection, preserving the open test
  transaction while wiring every dependency (security included) to the
  current request.

- _getEntityManager() resolves the EntityManager fresh from the current
  container on every call instead of caching it as a permanent service. This
  keeps the module's Doctrine helpers and the application on a single identity
  map, matching pure Symfony, and avoids a stale cached manager after a reboot.
  Only doctrine.dbal.default_connection stays persistent, which is what keeps
  the transaction open.

Also rename persistDoctrineConnections() -> keepDoctrineConnectionsOpen() to
describe what it does: it removes the doctrine.connections parameter before
shutdown so DoctrineBundle::shutdown() cannot close the persisted connection
and drop the test transaction.

Fixes #34

Author: TavoNiievez

src/Codeception/Lib/Connector/Symfony.php

@@ -4,6 +4,8 @@
 
 namespace Codeception\Lib\Connector;
 
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\Persistence\ManagerRegistry;
 use InvalidArgumentException;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\HttpFoundation\Response;
@@ -55,7 +57,7 @@ public function rebootKernel(): void
     {
         $this->updatePersistentServices();
 
-        $this->persistDoctrineConnections();
+        $this->keepDoctrineConnectionsOpen();
 
         if ($this->kernel instanceof Kernel) {
             $this->ensureKernelShutdown();
@@ -96,7 +98,7 @@ private function getProfiler(): ?Profiler
         return $profiler instanceof Profiler ? $profiler : null;
     }
 
-    private function persistDoctrineConnections(): void
+    private function keepDoctrineConnectionsOpen(): void
     {
         (function (): void {
             if (property_exists($this, 'parameters') && is_array($this->parameters)) {
@@ -117,6 +119,9 @@ private function updatePersistentServices(): void
     private function injectPersistentServices(): void
     {
         foreach ($this->persistentServices as $name => $service) {
+            if ($service instanceof EntityManagerInterface || $service instanceof ManagerRegistry) {
+                continue;
+            }
             try {
                 $this->container->set($name, $service);
             } catch (InvalidArgumentException $e) {

src/Codeception/Module/Symfony.php

@@ -272,24 +272,31 @@ protected function onReconfigure(array $settings = []): void
 
     /**
      * Retrieve the Doctrine EntityManager.
-     * EntityManager service is retrieved once and then reused.
+     *
+     * The EntityManager is resolved fresh from the current container on every
+     * call instead of being cached, so it always matches the one the kernel
+     * uses for the request in flight. After a reboot a persisted EntityManager
+     * would keep an immutable ListenersInvoker bound to the old container,
+     * splitting the identity map (and the security context lazy entity
+     * listeners see) from the application's. Only the DBAL connection is kept
+     * persistent: that preserves the open test transaction across reboots while
+     * the freshly rebuilt EntityManager runs on top of it.
+     *
+     * @see https://github.com/Codeception/module-symfony/issues/34
      */
     public function _getEntityManager(): EntityManagerInterface
     {
         /** @var non-empty-string $emService */
         $emService = $this->config['em_service'];
 
-        if (!isset($this->permanentServices[$emService])) {
-            $this->persistPermanentService($emService);
+        if (!isset($this->permanentServices['doctrine.dbal.default_connection'])) {
             $container = $this->_getContainer();
-            foreach (['doctrine', 'doctrine.orm.default_entity_manager', 'doctrine.dbal.default_connection'] as $service) {
-                if ($container->has($service)) {
-                    $this->persistPermanentService($service);
-                }
+            if ($container->has('doctrine.dbal.default_connection')) {
+                $this->persistPermanentService('doctrine.dbal.default_connection');
             }
         }
 
-        $em = $this->permanentServices[$emService];
+        $em = $this->getService($emService);
         if (!$em instanceof EntityManagerInterface) {
             Assert::fail(sprintf('Service "%s" is not an instance of EntityManagerInterface.', $emService));
         }