Merge branch '4.3' into 4.4

nicolas-grekas · nicolas-grekas · commit af97cf9cecb7 · 2020-01-21T12:12:16.000+01:00
* 4.3:
  [Yaml] Throw on unquoted exclamation mark
  Use supportsClass where possible
diff --git a/Core/Tests/User/ChainUserProviderTest.php b/Core/Tests/User/ChainUserProviderTest.php
@@ -70,31 +70,62 @@ public function testRefreshUser()
         $provider1 = $this->getProvider();
         $provider1
             ->expects($this->once())
-            ->method('refreshUser')
-            ->willThrowException(new UnsupportedUserException('unsupported'))
+            ->method('supportsClass')
+            ->willReturn(false)
         ;
 
         $provider2 = $this->getProvider();
+        $provider2
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider2
+            ->expects($this->once())
+            ->method('refreshUser')
+            ->willThrowException(new UnsupportedUserException('unsupported'))
+        ;
+
+        $provider3 = $this->getProvider();
+        $provider3
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
+        $provider3
             ->expects($this->once())
             ->method('refreshUser')
             ->willReturn($account = $this->getAccount())
         ;
 
-        $provider = new ChainUserProvider([$provider1, $provider2]);
+        $provider = new ChainUserProvider([$provider1, $provider2, $provider3]);
         $this->assertSame($account, $provider->refreshUser($this->getAccount()));
     }
 
     public function testRefreshUserAgain()
     {
         $provider1 = $this->getProvider();
+        $provider1
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider1
             ->expects($this->once())
             ->method('refreshUser')
             ->willThrowException(new UsernameNotFoundException('not found'))
         ;
 
         $provider2 = $this->getProvider();
+        $provider2
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider2
             ->expects($this->once())
             ->method('refreshUser')
@@ -109,13 +140,25 @@ public function testRefreshUserThrowsUnsupportedUserException()
     {
         $this->expectException('Symfony\Component\Security\Core\Exception\UnsupportedUserException');
         $provider1 = $this->getProvider();
+        $provider1
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider1
             ->expects($this->once())
             ->method('refreshUser')
             ->willThrowException(new UnsupportedUserException('unsupported'))
         ;
 
         $provider2 = $this->getProvider();
+        $provider2
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider2
             ->expects($this->once())
             ->method('refreshUser')
@@ -173,13 +216,25 @@ public function testSupportsClassWhenNotSupported()
     public function testAcceptsTraversable()
     {
         $provider1 = $this->getProvider();
+        $provider1
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider1
             ->expects($this->once())
             ->method('refreshUser')
             ->willThrowException(new UnsupportedUserException('unsupported'))
         ;
 
         $provider2 = $this->getProvider();
+        $provider2
+            ->expects($this->once())
+            ->method('supportsClass')
+            ->willReturn(true)
+        ;
+
         $provider2
             ->expects($this->once())
             ->method('refreshUser')
diff --git a/Core/User/ChainUserProvider.php b/Core/User/ChainUserProvider.php
@@ -73,6 +73,10 @@ public function refreshUser(UserInterface $user)
 
         foreach ($this->providers as $provider) {
             try {
+                if (!$provider->supportsClass(\get_class($user))) {
+                    continue;
+                }
+
                 return $provider->refreshUser($user);
             } catch (UnsupportedUserException $e) {
                 // try next one
diff --git a/Http/Firewall/ContextListener.php b/Http/Firewall/ContextListener.php
@@ -218,12 +218,17 @@ protected function refreshUser(TokenInterface $token)
 
         $userNotFoundByProvider = false;
         $userDeauthenticated = false;
+        $userClass = \get_class($user);
 
         foreach ($this->userProviders as $provider) {
             if (!$provider instanceof UserProviderInterface) {
                 throw new \InvalidArgumentException(sprintf('User provider "%s" must implement "%s".', \get_class($provider), UserProviderInterface::class));
             }
 
+            if (!$provider->supportsClass($userClass)) {
+                continue;
+            }
+
             try {
                 $refreshedUser = $provider->refreshUser($user);
                 $newToken = clone $token;
@@ -287,7 +292,7 @@ protected function refreshUser(TokenInterface $token)
             return null;
         }
 
-        throw new \RuntimeException(sprintf('There is no user provider for user "%s".', \get_class($user)));
+        throw new \RuntimeException(sprintf('There is no user provider for user "%s".', $userClass));
     }
 
     private function safelyUnserialize(string $serializedToken)
diff --git a/Http/Tests/Firewall/ContextListenerTest.php b/Http/Tests/Firewall/ContextListenerTest.php
@@ -253,7 +253,7 @@ public function testHandleRemovesTokenIfNoPreviousSessionWasFound()
     public function testIfTokenIsDeauthenticated()
     {
         $refreshedUser = new User('foobar', 'baz');
-        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)]);
+        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)]);
 
         $this->assertNull($tokenStorage->getToken());
     }
@@ -275,44 +275,44 @@ public function testRememberMeGetsCanceledIfTokenIsDeauthenticated()
         $rememberMeServices = $this->createMock(RememberMeServicesInterface::class);
         $rememberMeServices->expects($this->once())->method('loginFail');
 
-        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], null, $rememberMeServices);
+        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], null, $rememberMeServices);
 
         $this->assertNull($tokenStorage->getToken());
     }
 
     public function testTryAllUserProvidersUntilASupportingUserProviderIsFound()
     {
         $refreshedUser = new User('foobar', 'baz');
-        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], $refreshedUser);
+        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], $refreshedUser);
 
         $this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());
     }
 
     public function testNextSupportingUserProviderIsTriedIfPreviousSupportingUserProviderDidNotLoadTheUser()
     {
         $refreshedUser = new User('foobar', 'baz');
-        $tokenStorage = $this->handleEventWithPreviousSession([new SupportingUserProvider(), new SupportingUserProvider($refreshedUser)], $refreshedUser);
+        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], $refreshedUser);
 
         $this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());
     }
 
     public function testTokenIsSetToNullIfNoUserWasLoadedByTheRegisteredUserProviders()
     {
-        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider()]);
+        $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider()]);
 
         $this->assertNull($tokenStorage->getToken());
     }
 
     public function testRuntimeExceptionIsThrownIfNoSupportingUserProviderWasRegistered()
     {
         $this->expectException('RuntimeException');
-        $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new NotSupportingUserProvider()]);
+        $this->handleEventWithPreviousSession([new NotSupportingUserProvider(false), new NotSupportingUserProvider(true)]);
     }
 
     public function testAcceptsProvidersAsTraversable()
     {
         $refreshedUser = new User('foobar', 'baz');
-        $tokenStorage = $this->handleEventWithPreviousSession(new \ArrayObject([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)]), $refreshedUser);
+        $tokenStorage = $this->handleEventWithPreviousSession(new \ArrayObject([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)]), $refreshedUser);
 
         $this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());
     }
@@ -338,7 +338,7 @@ public function testDeauthenticatedEvent()
             $this->assertNotEquals($event->getRefreshedToken()->getUser(), $user);
         });
 
-        $listener = new ContextListener($tokenStorage, [new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], 'context_key', null, $eventDispatcher);
+        $listener = new ContextListener($tokenStorage, [new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], 'context_key', null, $eventDispatcher);
         $listener(new RequestEvent($this->getMockBuilder(HttpKernelInterface::class)->getMock(), $request, HttpKernelInterface::MASTER_REQUEST));
 
         $this->assertNull($tokenStorage->getToken());
@@ -431,14 +431,26 @@ private function handleEventWithPreviousSession($userProviders, UserInterface $u
 
 class NotSupportingUserProvider implements UserProviderInterface
 {
+    /** @var bool */
+    private $throwsUnsupportedException;
+
+    public function __construct($throwsUnsupportedException)
+    {
+        $this->throwsUnsupportedException = $throwsUnsupportedException;
+    }
+
     public function loadUserByUsername($username): UserInterface
     {
         throw new UsernameNotFoundException();
     }
 
     public function refreshUser(UserInterface $user): UserInterface
     {
-        throw new UnsupportedUserException();
+        if ($this->throwsUnsupportedException) {
+            throw new UnsupportedUserException();
+        }
+
+        return $user;
     }
 
     public function supportsClass($class): bool

Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ public function testHandleRemovesTokenIfNoPreviousSessionWasFound()`
`253`	`253`	`public function testIfTokenIsDeauthenticated()`
`254`	`254`	`{`
`255`	`255`	`$refreshedUser = new User('foobar', 'baz');`
`256`		`- $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)]);`
	`256`	`+ $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)]);`
`257`	`257`
`258`	`258`	`$this->assertNull($tokenStorage->getToken());`
`259`	`259`	`}`
`@@ -275,44 +275,44 @@ public function testRememberMeGetsCanceledIfTokenIsDeauthenticated()`
`275`	`275`	`$rememberMeServices = $this->createMock(RememberMeServicesInterface::class);`
`276`	`276`	`$rememberMeServices->expects($this->once())->method('loginFail');`
`277`	`277`
`278`		`- $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], null, $rememberMeServices);`
	`278`	`+ $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], null, $rememberMeServices);`
`279`	`279`
`280`	`280`	`$this->assertNull($tokenStorage->getToken());`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`public function testTryAllUserProvidersUntilASupportingUserProviderIsFound()`
`284`	`284`	`{`
`285`	`285`	`$refreshedUser = new User('foobar', 'baz');`
`286`		`- $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], $refreshedUser);`
	`286`	`+ $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], $refreshedUser);`
`287`	`287`
`288`	`288`	`$this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`public function testNextSupportingUserProviderIsTriedIfPreviousSupportingUserProviderDidNotLoadTheUser()`
`292`	`292`	`{`
`293`	`293`	`$refreshedUser = new User('foobar', 'baz');`
`294`		`- $tokenStorage = $this->handleEventWithPreviousSession([new SupportingUserProvider(), new SupportingUserProvider($refreshedUser)], $refreshedUser);`
	`294`	`+ $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], $refreshedUser);`
`295`	`295`
`296`	`296`	`$this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`public function testTokenIsSetToNullIfNoUserWasLoadedByTheRegisteredUserProviders()`
`300`	`300`	`{`
`301`		`- $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new SupportingUserProvider()]);`
	`301`	`+ $tokenStorage = $this->handleEventWithPreviousSession([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider()]);`
`302`	`302`
`303`	`303`	`$this->assertNull($tokenStorage->getToken());`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`public function testRuntimeExceptionIsThrownIfNoSupportingUserProviderWasRegistered()`
`307`	`307`	`{`
`308`	`308`	`$this->expectException('RuntimeException');`
`309`		`- $this->handleEventWithPreviousSession([new NotSupportingUserProvider(), new NotSupportingUserProvider()]);`
	`309`	`+ $this->handleEventWithPreviousSession([new NotSupportingUserProvider(false), new NotSupportingUserProvider(true)]);`
`310`	`310`	`}`
`311`	`311`
`312`	`312`	`public function testAcceptsProvidersAsTraversable()`
`313`	`313`	`{`
`314`	`314`	`$refreshedUser = new User('foobar', 'baz');`
`315`		`- $tokenStorage = $this->handleEventWithPreviousSession(new \ArrayObject([new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)]), $refreshedUser);`
	`315`	`+ $tokenStorage = $this->handleEventWithPreviousSession(new \ArrayObject([new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)]), $refreshedUser);`
`316`	`316`
`317`	`317`	`$this->assertSame($refreshedUser, $tokenStorage->getToken()->getUser());`
`318`	`318`	`}`
`@@ -338,7 +338,7 @@ public function testDeauthenticatedEvent()`
`338`	`338`	`$this->assertNotEquals($event->getRefreshedToken()->getUser(), $user);`
`339`	`339`	`});`
`340`	`340`
`341`		`- $listener = new ContextListener($tokenStorage, [new NotSupportingUserProvider(), new SupportingUserProvider($refreshedUser)], 'context_key', null, $eventDispatcher);`
	`341`	`+ $listener = new ContextListener($tokenStorage, [new NotSupportingUserProvider(true), new NotSupportingUserProvider(false), new SupportingUserProvider($refreshedUser)], 'context_key', null, $eventDispatcher);`
`342`	`342`	`$listener(new RequestEvent($this->getMockBuilder(HttpKernelInterface::class)->getMock(), $request, HttpKernelInterface::MASTER_REQUEST));`
`343`	`343`
`344`	`344`	`$this->assertNull($tokenStorage->getToken());`
`@@ -431,14 +431,26 @@ private function handleEventWithPreviousSession($userProviders, UserInterface $u`
`431`	`431`
`432`	`432`	`class NotSupportingUserProvider implements UserProviderInterface`
`433`	`433`	`{`
	`434`	`+ /** @var bool */`
	`435`	`+ private $throwsUnsupportedException;`
	`436`	`+`
	`437`	`+ public function __construct($throwsUnsupportedException)`
	`438`	`+ {`
	`439`	`+ $this->throwsUnsupportedException = $throwsUnsupportedException;`
	`440`	`+ }`
	`441`	`+`
`434`	`442`	`public function loadUserByUsername($username): UserInterface`
`435`	`443`	`{`
`436`	`444`	`throw new UsernameNotFoundException();`
`437`	`445`	`}`
`438`	`446`
`439`	`447`	`public function refreshUser(UserInterface $user): UserInterface`
`440`	`448`	`{`
`441`		`- throw new UnsupportedUserException();`
	`449`	`+ if ($this->throwsUnsupportedException) {`
	`450`	`+ throw new UnsupportedUserException();`
	`451`	`+ }`
	`452`	`+`
	`453`	`+ return $user;`
`442`	`454`	`}`
`443`	`455`
`444`	`456`	`public function supportsClass($class): bool`