3 namespace MediaWiki\Auth
;
6 use MediaWiki\Block\DatabaseBlock
;
7 use MediaWiki\Session\SessionInfo
;
8 use MediaWiki\Session\UserInfo
;
9 use Psr\Log\LoggerInterface
;
13 use Wikimedia\ScopedCallback
;
14 use Wikimedia\TestingAccessWrapper
;
19 * @covers \MediaWiki\Auth\AuthManager
21 class AuthManagerTest
extends \MediaWikiTestCase
{
22 /** @var WebRequest */
26 /** @var LoggerInterface */
29 protected $preauthMocks = [];
30 protected $primaryauthMocks = [];
31 protected $secondaryauthMocks = [];
33 /** @var AuthManager */
35 /** @var TestingAccessWrapper */
36 protected $managerPriv;
39 * Sets a mock on a hook
41 * @param object $expect From $this->once(), $this->never(), etc.
42 * @return object $mock->expects( $expect )->method( ... ).
44 protected function hook( $hook, $expect ) {
45 $mock = $this->getMockBuilder( __CLASS__
)
46 ->setMethods( [ "on$hook" ] )
48 $this->setTemporaryHook( $hook, $mock );
49 return $mock->expects( $expect )->method( "on$hook" );
56 protected function unhook( $hook ) {
62 * Ensure a value is a clean Message object
63 * @param string|Message $key
64 * @param array $params
67 protected function message( $key, $params = [] ) {
68 if ( $key === null ) {
71 if ( $key instanceof \MessageSpecifier
) {
72 $params = $key->getParams();
73 $key = $key->getKey();
75 return new \
Message( $key, $params, \Language
::factory( 'en' ) );
79 * Test two AuthenticationResponses for equality. We don't want to use regular assertEquals
80 * because that recursively compares members, which leads to false negatives if e.g. Language
83 * @param AuthenticationResponse $response1
84 * @param AuthenticationResponse $response2
88 private function assertResponseEquals(
89 AuthenticationResponse
$expected, AuthenticationResponse
$actual, $msg = ''
91 foreach ( ( new \
ReflectionClass( $expected ) )->getProperties() as $prop ) {
92 $name = $prop->getName();
93 $usedMsg = ltrim( "$msg ($name)" );
94 if ( $name === 'message' && $expected->message
) {
95 $this->assertSame( $expected->message
->serialize(), $actual->message
->serialize(),
98 $this->assertEquals( $expected->$name, $actual->$name, $usedMsg );
104 * Initialize the AuthManagerConfig variable in $this->config
106 * Uses data from the various 'mocks' fields.
108 protected function initializeConfig() {
118 foreach ( [ 'preauth', 'primaryauth', 'secondaryauth' ] as $type ) {
119 $key = $type . 'Mocks';
120 foreach ( $this->$key as $mock ) {
121 $config[$type][$mock->getUniqueId()] = [ 'factory' => function () use ( $mock ) {
127 $this->config
->set( 'AuthManagerConfig', $config );
128 $this->config
->set( 'LanguageCode', 'en' );
129 $this->config
->set( 'NewUserLog', false );
133 * Initialize $this->manager
134 * @param bool $regen Force a call to $this->initializeConfig()
136 protected function initializeManager( $regen = false ) {
137 if ( $regen ||
!$this->config
) {
138 $this->config
= new \
HashConfig();
140 if ( $regen ||
!$this->request
) {
141 $this->request
= new \
FauxRequest();
143 if ( !$this->logger
) {
144 $this->logger
= new \
TestLogger();
147 if ( $regen ||
!$this->config
->has( 'AuthManagerConfig' ) ) {
148 $this->initializeConfig();
150 $this->manager
= new AuthManager( $this->request
, $this->config
);
151 $this->manager
->setLogger( $this->logger
);
152 $this->managerPriv
= TestingAccessWrapper
::newFromObject( $this->manager
);
156 * Setup SessionManager with a mock session provider
157 * @param bool|null $canChangeUser If non-null, canChangeUser will be mocked to return this
158 * @param array $methods Additional methods to mock
159 * @return array (MediaWiki\Session\SessionProvider, ScopedCallback)
161 protected function getMockSessionProvider( $canChangeUser = null, array $methods = [] ) {
162 if ( !$this->config
) {
163 $this->config
= new \
HashConfig();
164 $this->initializeConfig();
166 $this->config
->set( 'ObjectCacheSessionExpiry', 100 );
168 $methods[] = '__toString';
169 $methods[] = 'describe';
170 if ( $canChangeUser !== null ) {
171 $methods[] = 'canChangeUser';
173 $provider = $this->getMockBuilder( \DummySessionProvider
::class )
174 ->setMethods( $methods )
176 $provider->expects( $this->any() )->method( '__toString' )
177 ->will( $this->returnValue( 'MockSessionProvider' ) );
178 $provider->expects( $this->any() )->method( 'describe' )
179 ->will( $this->returnValue( 'MockSessionProvider sessions' ) );
180 if ( $canChangeUser !== null ) {
181 $provider->expects( $this->any() )->method( 'canChangeUser' )
182 ->will( $this->returnValue( $canChangeUser ) );
184 $this->config
->set( 'SessionProviders', [
185 [ 'factory' => function () use ( $provider ) {
190 $manager = new \MediaWiki\Session\
SessionManager( [
191 'config' => $this->config
,
192 'logger' => new \Psr\Log\
NullLogger(),
193 'store' => new \
HashBagOStuff(),
195 TestingAccessWrapper
::newFromObject( $manager )->getProvider( (string)$provider );
197 $reset = \MediaWiki\Session\TestUtils
::setSessionManagerSingleton( $manager );
199 if ( $this->request
) {
200 $manager->getSessionForRequest( $this->request
);
203 return [ $provider, $reset ];
206 public function testSingleton() {
207 // Temporarily clear out the global singleton, if any, to test creating
209 $rProp = new \
ReflectionProperty( AuthManager
::class, 'instance' );
210 $rProp->setAccessible( true );
211 $old = $rProp->getValue();
212 $cb = new ScopedCallback( [ $rProp, 'setValue' ], [ $old ] );
213 $rProp->setValue( null );
215 $singleton = AuthManager
::singleton();
216 $this->assertInstanceOf( AuthManager
::class, AuthManager
::singleton() );
217 $this->assertSame( $singleton, AuthManager
::singleton() );
218 $this->assertSame( \RequestContext
::getMain()->getRequest(), $singleton->getRequest() );
220 \RequestContext
::getMain()->getConfig(),
221 TestingAccessWrapper
::newFromObject( $singleton )->config
225 public function testCanAuthenticateNow() {
226 $this->initializeManager();
228 list( $provider, $reset ) = $this->getMockSessionProvider( false );
229 $this->assertFalse( $this->manager
->canAuthenticateNow() );
230 ScopedCallback
::consume( $reset );
232 list( $provider, $reset ) = $this->getMockSessionProvider( true );
233 $this->assertTrue( $this->manager
->canAuthenticateNow() );
234 ScopedCallback
::consume( $reset );
237 public function testNormalizeUsername() {
239 $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class ),
240 $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class ),
241 $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class ),
242 $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class ),
244 foreach ( $mocks as $key => $mock ) {
245 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $key ) );
247 $mocks[0]->expects( $this->once() )->method( 'providerNormalizeUsername' )
248 ->with( $this->identicalTo( 'XYZ' ) )
249 ->willReturn( 'Foo' );
250 $mocks[1]->expects( $this->once() )->method( 'providerNormalizeUsername' )
251 ->with( $this->identicalTo( 'XYZ' ) )
252 ->willReturn( 'Foo' );
253 $mocks[2]->expects( $this->once() )->method( 'providerNormalizeUsername' )
254 ->with( $this->identicalTo( 'XYZ' ) )
255 ->willReturn( null );
256 $mocks[3]->expects( $this->once() )->method( 'providerNormalizeUsername' )
257 ->with( $this->identicalTo( 'XYZ' ) )
258 ->willReturn( 'Bar!' );
260 $this->primaryauthMocks
= $mocks;
262 $this->initializeManager();
264 $this->assertSame( [ 'Foo', 'Bar!' ], $this->manager
->normalizeUsername( 'XYZ' ) );
268 * @dataProvider provideSecuritySensitiveOperationStatus
269 * @param bool $mutableSession
271 public function testSecuritySensitiveOperationStatus( $mutableSession ) {
272 $this->logger
= new \Psr\Log\
NullLogger();
273 $user = \User
::newFromName( 'UTSysop' );
275 $reauth = $mutableSession ? AuthManager
::SEC_REAUTH
: AuthManager
::SEC_FAIL
;
277 list( $provider, $reset ) = $this->getMockSessionProvider(
278 $mutableSession, [ 'provideSessionInfo' ]
280 $provider->expects( $this->any() )->method( 'provideSessionInfo' )
281 ->will( $this->returnCallback( function () use ( $provider, &$provideUser ) {
282 return new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
283 'provider' => $provider,
284 'id' => \DummySessionProvider
::ID
,
286 'userInfo' => UserInfo
::newFromUser( $provideUser, true )
289 $this->initializeManager();
291 $this->config
->set( 'ReauthenticateTime', [] );
292 $this->config
->set( 'AllowSecuritySensitiveOperationIfCannotReauthenticate', [] );
293 $provideUser = new \User
;
294 $session = $provider->getManager()->getSessionForRequest( $this->request
);
295 $this->assertSame( 0, $session->getUser()->getId(), 'sanity check' );
297 // Anonymous user => reauth
298 $session->set( 'AuthManager:lastAuthId', 0 );
299 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
300 $this->assertSame( $reauth, $this->manager
->securitySensitiveOperationStatus( 'foo' ) );
302 $provideUser = $user;
303 $session = $provider->getManager()->getSessionForRequest( $this->request
);
304 $this->assertSame( $user->getId(), $session->getUser()->getId(), 'sanity check' );
306 // Error for no default (only gets thrown for non-anonymous user)
307 $session->set( 'AuthManager:lastAuthId', $user->getId() +
1 );
308 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
310 $this->manager
->securitySensitiveOperationStatus( 'foo' );
311 $this->fail( 'Expected exception not thrown' );
312 } catch ( \UnexpectedValueException
$ex ) {
315 ?
'$wgReauthenticateTime lacks a default'
316 : '$wgAllowSecuritySensitiveOperationIfCannotReauthenticate lacks a default',
321 if ( $mutableSession ) {
322 $this->config
->set( 'ReauthenticateTime', [
328 // Mismatched user ID
329 $session->set( 'AuthManager:lastAuthId', $user->getId() +
1 );
330 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
332 AuthManager
::SEC_REAUTH
, $this->manager
->securitySensitiveOperationStatus( 'foo' )
335 AuthManager
::SEC_REAUTH
, $this->manager
->securitySensitiveOperationStatus( 'test' )
338 AuthManager
::SEC_OK
, $this->manager
->securitySensitiveOperationStatus( 'test2' )
342 $session->set( 'AuthManager:lastAuthId', $user->getId() );
343 $session->set( 'AuthManager:lastAuthTimestamp', null );
345 AuthManager
::SEC_REAUTH
, $this->manager
->securitySensitiveOperationStatus( 'foo' )
348 AuthManager
::SEC_REAUTH
, $this->manager
->securitySensitiveOperationStatus( 'test' )
351 AuthManager
::SEC_OK
, $this->manager
->securitySensitiveOperationStatus( 'test2' )
354 // Recent enough to pass
355 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
357 AuthManager
::SEC_OK
, $this->manager
->securitySensitiveOperationStatus( 'foo' )
360 // Not recent enough to pass
361 $session->set( 'AuthManager:lastAuthTimestamp', time() - 20 );
363 AuthManager
::SEC_REAUTH
, $this->manager
->securitySensitiveOperationStatus( 'foo' )
365 // But recent enough for the 'test' operation
367 AuthManager
::SEC_OK
, $this->manager
->securitySensitiveOperationStatus( 'test' )
370 $this->config
->set( 'AllowSecuritySensitiveOperationIfCannotReauthenticate', [
376 AuthManager
::SEC_OK
, $this->manager
->securitySensitiveOperationStatus( 'foo' )
380 AuthManager
::SEC_FAIL
, $this->manager
->securitySensitiveOperationStatus( 'test' )
384 // Test hook, all three possible values
386 AuthManager
::SEC_OK
=> AuthManager
::SEC_OK
,
387 AuthManager
::SEC_REAUTH
=> $reauth,
388 AuthManager
::SEC_FAIL
=> AuthManager
::SEC_FAIL
,
389 ] as $hook => $expect ) {
390 $this->hook( 'SecuritySensitiveOperationStatus', $this->exactly( 2 ) )
394 $this->callback( function ( $s ) use ( $session ) {
395 return $s->getId() === $session->getId();
397 $mutableSession ?
$this->equalTo( 500, 1 ) : $this->equalTo( -1 )
399 ->will( $this->returnCallback( function ( &$v ) use ( $hook ) {
403 $session->set( 'AuthManager:lastAuthTimestamp', time() - 500 );
405 $expect, $this->manager
->securitySensitiveOperationStatus( 'test' ), "hook $hook"
408 $expect, $this->manager
->securitySensitiveOperationStatus( 'test2' ), "hook $hook"
410 $this->unhook( 'SecuritySensitiveOperationStatus' );
413 ScopedCallback
::consume( $reset );
416 public function onSecuritySensitiveOperationStatus( &$status, $operation, $session, $time ) {
419 public static function provideSecuritySensitiveOperationStatus() {
427 * @dataProvider provideUserCanAuthenticate
428 * @param bool $primary1Can
429 * @param bool $primary2Can
430 * @param bool $expect
432 public function testUserCanAuthenticate( $primary1Can, $primary2Can, $expect ) {
433 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
434 $mock1->expects( $this->any() )->method( 'getUniqueId' )
435 ->will( $this->returnValue( 'primary1' ) );
436 $mock1->expects( $this->any() )->method( 'testUserCanAuthenticate' )
437 ->with( $this->equalTo( 'UTSysop' ) )
438 ->will( $this->returnValue( $primary1Can ) );
439 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
440 $mock2->expects( $this->any() )->method( 'getUniqueId' )
441 ->will( $this->returnValue( 'primary2' ) );
442 $mock2->expects( $this->any() )->method( 'testUserCanAuthenticate' )
443 ->with( $this->equalTo( 'UTSysop' ) )
444 ->will( $this->returnValue( $primary2Can ) );
445 $this->primaryauthMocks
= [ $mock1, $mock2 ];
447 $this->initializeManager( true );
448 $this->assertSame( $expect, $this->manager
->userCanAuthenticate( 'UTSysop' ) );
451 public static function provideUserCanAuthenticate() {
453 [ false, false, false ],
454 [ true, false, true ],
455 [ false, true, true ],
456 [ true, true, true ],
460 public function testRevokeAccessForUser() {
461 $this->initializeManager();
463 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
464 $mock->expects( $this->any() )->method( 'getUniqueId' )
465 ->will( $this->returnValue( 'primary' ) );
466 $mock->expects( $this->once() )->method( 'providerRevokeAccessForUser' )
467 ->with( $this->equalTo( 'UTSysop' ) );
468 $this->primaryauthMocks
= [ $mock ];
470 $this->initializeManager( true );
471 $this->logger
->setCollect( true );
473 $this->manager
->revokeAccessForUser( 'UTSysop' );
476 [ LogLevel
::INFO
, 'Revoking access for {user}' ],
477 ], $this->logger
->getBuffer() );
480 public function testProviderCreation() {
482 'pre' => $this->getMockForAbstractClass( PreAuthenticationProvider
::class ),
483 'primary' => $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class ),
484 'secondary' => $this->getMockForAbstractClass( SecondaryAuthenticationProvider
::class ),
486 foreach ( $mocks as $key => $mock ) {
487 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $key ) );
488 $mock->expects( $this->once() )->method( 'setLogger' );
489 $mock->expects( $this->once() )->method( 'setManager' );
490 $mock->expects( $this->once() )->method( 'setConfig' );
492 $this->preauthMocks
= [ $mocks['pre'] ];
493 $this->primaryauthMocks
= [ $mocks['primary'] ];
494 $this->secondaryauthMocks
= [ $mocks['secondary'] ];
497 $this->initializeManager();
500 $this->managerPriv
->getAuthenticationProvider( 'primary' )
504 $this->managerPriv
->getAuthenticationProvider( 'secondary' )
508 $this->managerPriv
->getAuthenticationProvider( 'pre' )
511 [ 'pre' => $mocks['pre'] ],
512 $this->managerPriv
->getPreAuthenticationProviders()
515 [ 'primary' => $mocks['primary'] ],
516 $this->managerPriv
->getPrimaryAuthenticationProviders()
519 [ 'secondary' => $mocks['secondary'] ],
520 $this->managerPriv
->getSecondaryAuthenticationProviders()
524 $mock1 = $this->getMockForAbstractClass( PreAuthenticationProvider
::class );
525 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
526 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
527 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
528 $this->preauthMocks
= [ $mock1 ];
529 $this->primaryauthMocks
= [ $mock2 ];
530 $this->secondaryauthMocks
= [];
531 $this->initializeManager( true );
533 $this->managerPriv
->getAuthenticationProvider( 'Y' );
534 $this->fail( 'Expected exception not thrown' );
535 } catch ( \RuntimeException
$ex ) {
536 $class1 = get_class( $mock1 );
537 $class2 = get_class( $mock2 );
539 "Duplicate specifications for id X (classes $class1 and $class2)", $ex->getMessage()
544 $mock = $this->getMockForAbstractClass( AuthenticationProvider
::class );
545 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
546 $class = get_class( $mock );
547 $this->preauthMocks
= [ $mock ];
548 $this->primaryauthMocks
= [ $mock ];
549 $this->secondaryauthMocks
= [ $mock ];
550 $this->initializeManager( true );
552 $this->managerPriv
->getPreAuthenticationProviders();
553 $this->fail( 'Expected exception not thrown' );
554 } catch ( \RuntimeException
$ex ) {
556 "Expected instance of MediaWiki\\Auth\\PreAuthenticationProvider, got $class",
561 $this->managerPriv
->getPrimaryAuthenticationProviders();
562 $this->fail( 'Expected exception not thrown' );
563 } catch ( \RuntimeException
$ex ) {
565 "Expected instance of MediaWiki\\Auth\\PrimaryAuthenticationProvider, got $class",
570 $this->managerPriv
->getSecondaryAuthenticationProviders();
571 $this->fail( 'Expected exception not thrown' );
572 } catch ( \RuntimeException
$ex ) {
574 "Expected instance of MediaWiki\\Auth\\SecondaryAuthenticationProvider, got $class",
580 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
581 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
582 $mock3 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
583 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'A' ) );
584 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
585 $mock3->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'C' ) );
586 $this->preauthMocks
= [];
587 $this->primaryauthMocks
= [ $mock1, $mock2, $mock3 ];
588 $this->secondaryauthMocks
= [];
589 $this->initializeConfig();
590 $config = $this->config
->get( 'AuthManagerConfig' );
592 $this->initializeManager( false );
594 [ 'A' => $mock1, 'B' => $mock2, 'C' => $mock3 ],
595 $this->managerPriv
->getPrimaryAuthenticationProviders(),
599 $config['primaryauth']['A']['sort'] = 100;
600 $config['primaryauth']['C']['sort'] = -1;
601 $this->config
->set( 'AuthManagerConfig', $config );
602 $this->initializeManager( false );
604 [ 'C' => $mock3, 'B' => $mock2, 'A' => $mock1 ],
605 $this->managerPriv
->getPrimaryAuthenticationProviders()
610 * @dataProvider provideSetDefaultUserOptions
612 public function testSetDefaultUserOptions(
613 $contLang, $useContextLang, $expectedLang, $expectedVariant
615 $this->initializeManager();
617 $this->setContentLang( $contLang );
618 $context = \RequestContext
::getMain();
619 $reset = new ScopedCallback( [ $context, 'setLanguage' ], [ $context->getLanguage() ] );
620 $context->setLanguage( 'de' );
622 $user = \User
::newFromName( self
::usernameForCreation() );
623 $user->addToDatabase();
624 $oldToken = $user->getToken();
625 $this->managerPriv
->setDefaultUserOptions( $user, $useContextLang );
626 $user->saveSettings();
627 $this->assertNotEquals( $oldToken, $user->getToken() );
628 $this->assertSame( $expectedLang, $user->getOption( 'language' ) );
629 $this->assertSame( $expectedVariant, $user->getOption( 'variant' ) );
632 public function provideSetDefaultUserOptions() {
634 [ 'zh', false, 'zh', 'zh' ],
635 [ 'zh', true, 'de', 'zh' ],
636 [ 'fr', true, 'de', null ],
640 public function testForcePrimaryAuthenticationProviders() {
641 $mockA = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
642 $mockB = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
643 $mockB2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
644 $mockA->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'A' ) );
645 $mockB->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
646 $mockB2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
647 $this->primaryauthMocks
= [ $mockA ];
649 $this->logger
= new \
TestLogger( true );
651 // Test without first initializing the configured providers
652 $this->initializeManager();
653 $this->manager
->forcePrimaryAuthenticationProviders( [ $mockB ], 'testing' );
655 [ 'B' => $mockB ], $this->managerPriv
->getPrimaryAuthenticationProviders()
657 $this->assertSame( null, $this->managerPriv
->getAuthenticationProvider( 'A' ) );
658 $this->assertSame( $mockB, $this->managerPriv
->getAuthenticationProvider( 'B' ) );
660 [ LogLevel
::WARNING
, 'Overriding AuthManager primary authn because testing' ],
661 ], $this->logger
->getBuffer() );
662 $this->logger
->clearBuffer();
664 // Test with first initializing the configured providers
665 $this->initializeManager();
666 $this->assertSame( $mockA, $this->managerPriv
->getAuthenticationProvider( 'A' ) );
667 $this->assertSame( null, $this->managerPriv
->getAuthenticationProvider( 'B' ) );
668 $this->request
->getSession()->setSecret( 'AuthManager::authnState', 'test' );
669 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState', 'test' );
670 $this->manager
->forcePrimaryAuthenticationProviders( [ $mockB ], 'testing' );
672 [ 'B' => $mockB ], $this->managerPriv
->getPrimaryAuthenticationProviders()
674 $this->assertSame( null, $this->managerPriv
->getAuthenticationProvider( 'A' ) );
675 $this->assertSame( $mockB, $this->managerPriv
->getAuthenticationProvider( 'B' ) );
676 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::authnState' ) );
678 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
681 [ LogLevel
::WARNING
, 'Overriding AuthManager primary authn because testing' ],
684 'PrimaryAuthenticationProviders have already been accessed! I hope nothing breaks.'
686 ], $this->logger
->getBuffer() );
687 $this->logger
->clearBuffer();
689 // Test duplicate IDs
690 $this->initializeManager();
692 $this->manager
->forcePrimaryAuthenticationProviders( [ $mockB, $mockB2 ], 'testing' );
693 $this->fail( 'Expected exception not thrown' );
694 } catch ( \RuntimeException
$ex ) {
695 $class1 = get_class( $mockB );
696 $class2 = get_class( $mockB2 );
698 "Duplicate specifications for id B (classes $class2 and $class1)", $ex->getMessage()
703 $mock = $this->getMockForAbstractClass( AuthenticationProvider
::class );
704 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
705 $class = get_class( $mock );
707 $this->manager
->forcePrimaryAuthenticationProviders( [ $mock ], 'testing' );
708 $this->fail( 'Expected exception not thrown' );
709 } catch ( \RuntimeException
$ex ) {
711 "Expected instance of MediaWiki\\Auth\\PrimaryAuthenticationProvider, got $class",
717 public function testBeginAuthentication() {
718 $this->initializeManager();
721 list( $provider, $reset ) = $this->getMockSessionProvider( false );
722 $this->hook( 'UserLoggedIn', $this->never() );
723 $this->request
->getSession()->setSecret( 'AuthManager::authnState', 'test' );
725 $this->manager
->beginAuthentication( [], 'http://localhost/' );
726 $this->fail( 'Expected exception not thrown' );
727 } catch ( \LogicException
$ex ) {
728 $this->assertSame( 'Authentication is not possible now', $ex->getMessage() );
730 $this->unhook( 'UserLoggedIn' );
731 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::authnState' ) );
732 ScopedCallback
::consume( $reset );
733 $this->initializeManager( true );
735 // CreatedAccountAuthenticationRequest
736 $user = \User
::newFromName( 'UTSysop' );
738 new CreatedAccountAuthenticationRequest( $user->getId(), $user->getName() )
740 $this->hook( 'UserLoggedIn', $this->never() );
742 $this->manager
->beginAuthentication( $reqs, 'http://localhost/' );
743 $this->fail( 'Expected exception not thrown' );
744 } catch ( \LogicException
$ex ) {
746 'CreatedAccountAuthenticationRequests are only valid on the same AuthManager ' .
747 'that created the account',
751 $this->unhook( 'UserLoggedIn' );
753 $this->request
->getSession()->clear();
754 $this->request
->getSession()->setSecret( 'AuthManager::authnState', 'test' );
755 $this->managerPriv
->createdAccountAuthenticationRequests
= [ $reqs[0] ];
756 $this->hook( 'UserLoggedIn', $this->once() )
757 ->with( $this->callback( function ( $u ) use ( $user ) {
758 return $user->getId() === $u->getId() && $user->getName() === $u->getName();
760 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->once() );
761 $this->logger
->setCollect( true );
762 $ret = $this->manager
->beginAuthentication( $reqs, 'http://localhost/' );
763 $this->logger
->setCollect( false );
764 $this->unhook( 'UserLoggedIn' );
765 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
766 $this->assertSame( AuthenticationResponse
::PASS
, $ret->status
);
767 $this->assertSame( $user->getName(), $ret->username
);
768 $this->assertSame( $user->getId(), $this->request
->getSessionData( 'AuthManager:lastAuthId' ) );
770 time(), $this->request
->getSessionData( 'AuthManager:lastAuthTimestamp' ),
773 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::authnState' ) );
774 $this->assertSame( $user->getId(), $this->request
->getSession()->getUser()->getId() );
776 [ LogLevel
::INFO
, 'Logging in {user} after account creation' ],
777 ], $this->logger
->getBuffer() );
780 public function testCreateFromLogin() {
781 $user = \User
::newFromName( 'UTSysop' );
782 $req1 = $this->createMock( AuthenticationRequest
::class );
783 $req2 = $this->createMock( AuthenticationRequest
::class );
784 $req3 = $this->createMock( AuthenticationRequest
::class );
785 $userReq = new UsernameAuthenticationRequest
;
786 $userReq->username
= 'UTDummy';
788 $req1->returnToUrl
= 'http://localhost/';
789 $req2->returnToUrl
= 'http://localhost/';
790 $req3->returnToUrl
= 'http://localhost/';
791 $req3->username
= 'UTDummy';
792 $userReq->returnToUrl
= 'http://localhost/';
794 // Passing one into beginAuthentication(), and an immediate FAIL
795 $primary = $this->getMockForAbstractClass( AbstractPrimaryAuthenticationProvider
::class );
796 $this->primaryauthMocks
= [ $primary ];
797 $this->initializeManager( true );
798 $res = AuthenticationResponse
::newFail( wfMessage( 'foo' ) );
799 $res->createRequest
= $req1;
800 $primary->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
801 ->will( $this->returnValue( $res ) );
802 $createReq = new CreateFromLoginAuthenticationRequest(
803 null, [ $req2->getUniqueId() => $req2 ]
805 $this->logger
->setCollect( true );
806 $ret = $this->manager
->beginAuthentication( [ $createReq ], 'http://localhost/' );
807 $this->logger
->setCollect( false );
808 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
809 $this->assertInstanceOf( CreateFromLoginAuthenticationRequest
::class, $ret->createRequest
);
810 $this->assertSame( $req1, $ret->createRequest
->createRequest
);
811 $this->assertEquals( [ $req2->getUniqueId() => $req2 ], $ret->createRequest
->maybeLink
);
813 // UI, then FAIL in beginAuthentication()
814 $primary = $this->getMockBuilder( AbstractPrimaryAuthenticationProvider
::class )
815 ->setMethods( [ 'continuePrimaryAuthentication' ] )
816 ->getMockForAbstractClass();
817 $this->primaryauthMocks
= [ $primary ];
818 $this->initializeManager( true );
819 $primary->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
820 ->will( $this->returnValue(
821 AuthenticationResponse
::newUI( [ $req1 ], wfMessage( 'foo' ) )
823 $res = AuthenticationResponse
::newFail( wfMessage( 'foo' ) );
824 $res->createRequest
= $req2;
825 $primary->expects( $this->any() )->method( 'continuePrimaryAuthentication' )
826 ->will( $this->returnValue( $res ) );
827 $this->logger
->setCollect( true );
828 $ret = $this->manager
->beginAuthentication( [], 'http://localhost/' );
829 $this->assertSame( AuthenticationResponse
::UI
, $ret->status
, 'sanity check' );
830 $ret = $this->manager
->continueAuthentication( [] );
831 $this->logger
->setCollect( false );
832 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
833 $this->assertInstanceOf( CreateFromLoginAuthenticationRequest
::class, $ret->createRequest
);
834 $this->assertSame( $req2, $ret->createRequest
->createRequest
);
835 $this->assertEquals( [], $ret->createRequest
->maybeLink
);
837 // Pass into beginAccountCreation(), see that maybeLink and createRequest get copied
838 $primary = $this->getMockForAbstractClass( AbstractPrimaryAuthenticationProvider
::class );
839 $this->primaryauthMocks
= [ $primary ];
840 $this->initializeManager( true );
841 $createReq = new CreateFromLoginAuthenticationRequest( $req3, [ $req2 ] );
842 $createReq->returnToUrl
= 'http://localhost/';
843 $createReq->username
= 'UTDummy';
844 $res = AuthenticationResponse
::newUI( [ $req1 ], wfMessage( 'foo' ) );
845 $primary->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )
846 ->with( $this->anything(), $this->anything(), [ $userReq, $createReq, $req3 ] )
847 ->will( $this->returnValue( $res ) );
848 $primary->expects( $this->any() )->method( 'accountCreationType' )
849 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
850 $this->logger
->setCollect( true );
851 $ret = $this->manager
->beginAccountCreation(
852 $user, [ $userReq, $createReq ], 'http://localhost/'
854 $this->logger
->setCollect( false );
855 $this->assertSame( AuthenticationResponse
::UI
, $ret->status
);
856 $state = $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' );
857 $this->assertNotNull( $state );
858 $this->assertEquals( [ $userReq, $createReq, $req3 ], $state['reqs'] );
859 $this->assertEquals( [ $req2 ], $state['maybeLink'] );
863 * @dataProvider provideAuthentication
864 * @param StatusValue $preResponse
865 * @param array $primaryResponses
866 * @param array $secondaryResponses
867 * @param array $managerResponses
868 * @param bool $link Whether the primary authentication provider is a "link" provider
870 public function testAuthentication(
871 StatusValue
$preResponse, array $primaryResponses, array $secondaryResponses,
872 array $managerResponses, $link = false
874 $this->initializeManager();
875 $user = \User
::newFromName( 'UTSysop' );
876 $id = $user->getId();
877 $name = $user->getName();
879 // Set up lots of mocks...
880 $req = new RememberMeAuthenticationRequest
;
881 $req->rememberMe
= (bool)rand( 0, 1 );
882 $req->pre
= $preResponse;
883 $req->primary
= $primaryResponses;
884 $req->secondary
= $secondaryResponses;
886 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
887 $class = ucfirst( $key ) . 'AuthenticationProvider';
888 $mocks[$key] = $this->getMockForAbstractClass(
889 "MediaWiki\\Auth\\$class", [], "Mock$class"
891 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
892 ->will( $this->returnValue( $key ) );
893 $mocks[$key . '2'] = $this->getMockForAbstractClass( "MediaWiki\\Auth\\$class" );
894 $mocks[$key . '2']->expects( $this->any() )->method( 'getUniqueId' )
895 ->will( $this->returnValue( $key . '2' ) );
896 $mocks[$key . '3'] = $this->getMockForAbstractClass( "MediaWiki\\Auth\\$class" );
897 $mocks[$key . '3']->expects( $this->any() )->method( 'getUniqueId' )
898 ->will( $this->returnValue( $key . '3' ) );
900 foreach ( $mocks as $mock ) {
901 $mock->expects( $this->any() )->method( 'getAuthenticationRequests' )
902 ->will( $this->returnValue( [] ) );
905 $mocks['pre']->expects( $this->once() )->method( 'testForAuthentication' )
906 ->will( $this->returnCallback( function ( $reqs ) use ( $req ) {
907 $this->assertContains( $req, $reqs );
911 $ct = count( $req->primary
);
912 $callback = $this->returnCallback( function ( $reqs ) use ( $req ) {
913 $this->assertContains( $req, $reqs );
914 return array_shift( $req->primary
);
916 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
917 ->method( 'beginPrimaryAuthentication' )
919 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
920 ->method( 'continuePrimaryAuthentication' )
923 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
924 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
927 $ct = count( $req->secondary
);
928 $callback = $this->returnCallback( function ( $user, $reqs ) use ( $id, $name, $req ) {
929 $this->assertSame( $id, $user->getId() );
930 $this->assertSame( $name, $user->getName() );
931 $this->assertContains( $req, $reqs );
932 return array_shift( $req->secondary
);
934 $mocks['secondary']->expects( $this->exactly( min( 1, $ct ) ) )
935 ->method( 'beginSecondaryAuthentication' )
937 $mocks['secondary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
938 ->method( 'continueSecondaryAuthentication' )
941 $abstain = AuthenticationResponse
::newAbstain();
942 $mocks['pre2']->expects( $this->atMost( 1 ) )->method( 'testForAuthentication' )
943 ->will( $this->returnValue( StatusValue
::newGood() ) );
944 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAuthentication' )
945 ->will( $this->returnValue( $abstain ) );
946 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAuthentication' );
947 $mocks['secondary2']->expects( $this->atMost( 1 ) )->method( 'beginSecondaryAuthentication' )
948 ->will( $this->returnValue( $abstain ) );
949 $mocks['secondary2']->expects( $this->never() )->method( 'continueSecondaryAuthentication' );
950 $mocks['secondary3']->expects( $this->atMost( 1 ) )->method( 'beginSecondaryAuthentication' )
951 ->will( $this->returnValue( $abstain ) );
952 $mocks['secondary3']->expects( $this->never() )->method( 'continueSecondaryAuthentication' );
954 $this->preauthMocks
= [ $mocks['pre'], $mocks['pre2'] ];
955 $this->primaryauthMocks
= [ $mocks['primary'], $mocks['primary2'] ];
956 $this->secondaryauthMocks
= [
957 $mocks['secondary3'], $mocks['secondary'], $mocks['secondary2'],
958 // So linking happens
959 new ConfirmLinkSecondaryAuthenticationProvider
,
961 $this->initializeManager( true );
962 $this->logger
->setCollect( true );
964 $constraint = \PHPUnit_Framework_Assert
::logicalOr(
965 $this->equalTo( AuthenticationResponse
::PASS
),
966 $this->equalTo( AuthenticationResponse
::FAIL
)
968 $providers = array_filter(
970 $this->preauthMocks
, $this->primaryauthMocks
, $this->secondaryauthMocks
973 return is_callable( [ $p, 'expects' ] );
976 foreach ( $providers as $p ) {
977 $p->postCalled
= false;
978 $p->expects( $this->atMost( 1 ) )->method( 'postAuthentication' )
979 ->willReturnCallback( function ( $user, $response ) use ( $constraint, $p ) {
980 if ( $user !== null ) {
981 $this->assertInstanceOf( \User
::class, $user );
982 $this->assertSame( 'UTSysop', $user->getName() );
984 $this->assertInstanceOf( AuthenticationResponse
::class, $response );
985 $this->assertThat( $response->status
, $constraint );
986 $p->postCalled
= $response->status
;
990 $session = $this->request
->getSession();
991 $session->setRememberUser( !$req->rememberMe
);
993 foreach ( $managerResponses as $i => $response ) {
994 $success = $response instanceof AuthenticationResponse
&&
995 $response->status
=== AuthenticationResponse
::PASS
;
997 $this->hook( 'UserLoggedIn', $this->once() )
998 ->with( $this->callback( function ( $user ) use ( $id, $name ) {
999 return $user->getId() === $id && $user->getName() === $name;
1002 $this->hook( 'UserLoggedIn', $this->never() );
1005 $response instanceof AuthenticationResponse
&&
1006 $response->status
=== AuthenticationResponse
::FAIL
&&
1007 $response->message
->getKey() !== 'authmanager-authn-not-in-progress' &&
1008 $response->message
->getKey() !== 'authmanager-authn-no-primary'
1011 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->once() );
1013 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->never() );
1019 $ret = $this->manager
->beginAuthentication( [ $req ], 'http://localhost/' );
1021 $ret = $this->manager
->continueAuthentication( [ $req ] );
1023 if ( $response instanceof \Exception
) {
1024 $this->fail( 'Expected exception not thrown', "Response $i" );
1026 } catch ( \Exception
$ex ) {
1027 if ( !$response instanceof \Exception
) {
1030 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
1031 $this->assertNull( $session->getSecret( 'AuthManager::authnState' ),
1032 "Response $i, exception, session state" );
1033 $this->unhook( 'UserLoggedIn' );
1034 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
1038 $this->unhook( 'UserLoggedIn' );
1039 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
1041 $this->assertSame( 'http://localhost/', $req->returnToUrl
);
1043 $ret->message
= $this->message( $ret->message
);
1044 $this->assertResponseEquals( $response, $ret, "Response $i, response" );
1046 $this->assertSame( $id, $session->getUser()->getId(),
1047 "Response $i, authn" );
1049 $this->assertSame( 0, $session->getUser()->getId(),
1050 "Response $i, authn" );
1052 if ( $success ||
$response->status
=== AuthenticationResponse
::FAIL
) {
1053 $this->assertNull( $session->getSecret( 'AuthManager::authnState' ),
1054 "Response $i, session state" );
1055 foreach ( $providers as $p ) {
1056 $this->assertSame( $response->status
, $p->postCalled
,
1057 "Response $i, post-auth callback called" );
1060 $this->assertNotNull( $session->getSecret( 'AuthManager::authnState' ),
1061 "Response $i, session state" );
1062 foreach ( $ret->neededRequests
as $neededReq ) {
1063 $this->assertEquals( AuthManager
::ACTION_LOGIN
, $neededReq->action
,
1064 "Response $i, neededRequest action" );
1066 $this->assertEquals(
1067 $ret->neededRequests
,
1068 $this->manager
->getAuthenticationRequests( AuthManager
::ACTION_LOGIN_CONTINUE
),
1069 "Response $i, continuation check"
1071 foreach ( $providers as $p ) {
1072 $this->assertFalse( $p->postCalled
, "Response $i, post-auth callback not called" );
1076 $state = $session->getSecret( 'AuthManager::authnState' );
1077 $maybeLink = $state['maybeLink'] ??
[];
1078 if ( $link && $response->status
=== AuthenticationResponse
::RESTART
) {
1079 $this->assertEquals(
1080 $response->createRequest
->maybeLink
,
1082 "Response $i, maybeLink"
1085 $this->assertEquals( [], $maybeLink, "Response $i, maybeLink" );
1090 $this->assertSame( $req->rememberMe
, $session->shouldRememberUser(),
1091 'rememberMe checkbox had effect' );
1093 $this->assertNotSame( $req->rememberMe
, $session->shouldRememberUser(),
1094 'rememberMe checkbox wasn\'t applied' );
1098 public function provideAuthentication() {
1099 $rememberReq = new RememberMeAuthenticationRequest
;
1100 $rememberReq->action
= AuthManager
::ACTION_LOGIN
;
1102 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
1103 $req->foobar
= 'baz';
1104 $restartResponse = AuthenticationResponse
::newRestart(
1105 $this->message( 'authmanager-authn-no-local-user' )
1107 $restartResponse->neededRequests
= [ $rememberReq ];
1109 $restartResponse2Pass = AuthenticationResponse
::newPass( null );
1110 $restartResponse2Pass->linkRequest
= $req;
1111 $restartResponse2 = AuthenticationResponse
::newRestart(
1112 $this->message( 'authmanager-authn-no-local-user-link' )
1114 $restartResponse2->createRequest
= new CreateFromLoginAuthenticationRequest(
1115 null, [ $req->getUniqueId() => $req ]
1117 $restartResponse2->createRequest
->action
= AuthManager
::ACTION_LOGIN
;
1118 $restartResponse2->neededRequests
= [ $rememberReq, $restartResponse2->createRequest
];
1120 $userName = 'UTSysop';
1123 'Failure in pre-auth' => [
1124 StatusValue
::newFatal( 'fail-from-pre' ),
1128 AuthenticationResponse
::newFail( $this->message( 'fail-from-pre' ) ),
1129 AuthenticationResponse
::newFail(
1130 $this->message( 'authmanager-authn-not-in-progress' )
1134 'Failure in primary' => [
1135 StatusValue
::newGood(),
1137 AuthenticationResponse
::newFail( $this->message( 'fail-from-primary' ) ),
1142 'All primary abstain' => [
1143 StatusValue
::newGood(),
1145 AuthenticationResponse
::newAbstain(),
1149 AuthenticationResponse
::newFail( $this->message( 'authmanager-authn-no-primary' ) )
1152 'Primary UI, then redirect, then fail' => [
1153 StatusValue
::newGood(),
1155 AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
1156 AuthenticationResponse
::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
1157 AuthenticationResponse
::newFail( $this->message( 'fail-in-primary-continue' ) ),
1162 'Primary redirect, then abstain' => [
1163 StatusValue
::newGood(),
1165 $tmp = AuthenticationResponse
::newRedirect(
1166 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
1168 AuthenticationResponse
::newAbstain(),
1173 new \
DomainException(
1174 'MockPrimaryAuthenticationProvider::continuePrimaryAuthentication() returned ABSTAIN'
1178 'Primary UI, then pass with no local user' => [
1179 StatusValue
::newGood(),
1181 $tmp = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
1182 AuthenticationResponse
::newPass( null ),
1190 'Primary UI, then pass with no local user (link type)' => [
1191 StatusValue
::newGood(),
1193 $tmp = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
1194 $restartResponse2Pass,
1203 'Primary pass with invalid username' => [
1204 StatusValue
::newGood(),
1206 AuthenticationResponse
::newPass( '<>' ),
1210 new \
DomainException( 'MockPrimaryAuthenticationProvider returned an invalid username: <>' ),
1213 'Secondary fail' => [
1214 StatusValue
::newGood(),
1216 AuthenticationResponse
::newPass( $userName ),
1219 AuthenticationResponse
::newFail( $this->message( 'fail-in-secondary' ) ),
1223 'Secondary UI, then abstain' => [
1224 StatusValue
::newGood(),
1226 AuthenticationResponse
::newPass( $userName ),
1229 $tmp = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
1230 AuthenticationResponse
::newAbstain()
1234 AuthenticationResponse
::newPass( $userName ),
1237 'Secondary pass' => [
1238 StatusValue
::newGood(),
1240 AuthenticationResponse
::newPass( $userName ),
1243 AuthenticationResponse
::newPass()
1246 AuthenticationResponse
::newPass( $userName ),
1253 * @dataProvider provideUserExists
1254 * @param bool $primary1Exists
1255 * @param bool $primary2Exists
1256 * @param bool $expect
1258 public function testUserExists( $primary1Exists, $primary2Exists, $expect ) {
1259 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1260 $mock1->expects( $this->any() )->method( 'getUniqueId' )
1261 ->will( $this->returnValue( 'primary1' ) );
1262 $mock1->expects( $this->any() )->method( 'testUserExists' )
1263 ->with( $this->equalTo( 'UTSysop' ) )
1264 ->will( $this->returnValue( $primary1Exists ) );
1265 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1266 $mock2->expects( $this->any() )->method( 'getUniqueId' )
1267 ->will( $this->returnValue( 'primary2' ) );
1268 $mock2->expects( $this->any() )->method( 'testUserExists' )
1269 ->with( $this->equalTo( 'UTSysop' ) )
1270 ->will( $this->returnValue( $primary2Exists ) );
1271 $this->primaryauthMocks
= [ $mock1, $mock2 ];
1273 $this->initializeManager( true );
1274 $this->assertSame( $expect, $this->manager
->userExists( 'UTSysop' ) );
1277 public static function provideUserExists() {
1279 [ false, false, false ],
1280 [ true, false, true ],
1281 [ false, true, true ],
1282 [ true, true, true ],
1287 * @dataProvider provideAllowsAuthenticationDataChange
1288 * @param StatusValue $primaryReturn
1289 * @param StatusValue $secondaryReturn
1290 * @param Status $expect
1292 public function testAllowsAuthenticationDataChange( $primaryReturn, $secondaryReturn, $expect ) {
1293 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
1295 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1296 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '1' ) );
1297 $mock1->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
1298 ->with( $this->equalTo( $req ) )
1299 ->will( $this->returnValue( $primaryReturn ) );
1300 $mock2 = $this->getMockForAbstractClass( SecondaryAuthenticationProvider
::class );
1301 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '2' ) );
1302 $mock2->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
1303 ->with( $this->equalTo( $req ) )
1304 ->will( $this->returnValue( $secondaryReturn ) );
1306 $this->primaryauthMocks
= [ $mock1 ];
1307 $this->secondaryauthMocks
= [ $mock2 ];
1308 $this->initializeManager( true );
1309 $this->assertEquals( $expect, $this->manager
->allowsAuthenticationDataChange( $req ) );
1312 public static function provideAllowsAuthenticationDataChange() {
1313 $ignored = \Status
::newGood( 'ignored' );
1314 $ignored->warning( 'authmanager-change-not-supported' );
1316 $okFromPrimary = StatusValue
::newGood();
1317 $okFromPrimary->warning( 'warning-from-primary' );
1318 $okFromSecondary = StatusValue
::newGood();
1319 $okFromSecondary->warning( 'warning-from-secondary' );
1323 StatusValue
::newGood(),
1324 StatusValue
::newGood(),
1328 StatusValue
::newGood(),
1329 StatusValue
::newGood( 'ignore' ),
1333 StatusValue
::newGood( 'ignored' ),
1334 StatusValue
::newGood(),
1338 StatusValue
::newGood( 'ignored' ),
1339 StatusValue
::newGood( 'ignored' ),
1343 StatusValue
::newFatal( 'fail from primary' ),
1344 StatusValue
::newGood(),
1345 \Status
::newFatal( 'fail from primary' ),
1349 StatusValue
::newGood(),
1350 \Status
::wrap( $okFromPrimary ),
1353 StatusValue
::newGood(),
1354 StatusValue
::newFatal( 'fail from secondary' ),
1355 \Status
::newFatal( 'fail from secondary' ),
1358 StatusValue
::newGood(),
1360 \Status
::wrap( $okFromSecondary ),
1365 public function testChangeAuthenticationData() {
1366 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
1367 $req->username
= 'UTSysop';
1369 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1370 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '1' ) );
1371 $mock1->expects( $this->once() )->method( 'providerChangeAuthenticationData' )
1372 ->with( $this->equalTo( $req ) );
1373 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1374 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '2' ) );
1375 $mock2->expects( $this->once() )->method( 'providerChangeAuthenticationData' )
1376 ->with( $this->equalTo( $req ) );
1378 $this->primaryauthMocks
= [ $mock1, $mock2 ];
1379 $this->initializeManager( true );
1380 $this->logger
->setCollect( true );
1381 $this->manager
->changeAuthenticationData( $req );
1382 $this->assertSame( [
1383 [ LogLevel
::INFO
, 'Changing authentication data for {user} class {what}' ],
1384 ], $this->logger
->getBuffer() );
1387 public function testCanCreateAccounts() {
1389 PrimaryAuthenticationProvider
::TYPE_CREATE
=> true,
1390 PrimaryAuthenticationProvider
::TYPE_LINK
=> true,
1391 PrimaryAuthenticationProvider
::TYPE_NONE
=> false,
1394 foreach ( $types as $type => $can ) {
1395 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1396 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $type ) );
1397 $mock->expects( $this->any() )->method( 'accountCreationType' )
1398 ->will( $this->returnValue( $type ) );
1399 $this->primaryauthMocks
= [ $mock ];
1400 $this->initializeManager( true );
1401 $this->assertSame( $can, $this->manager
->canCreateAccounts(), $type );
1405 public function testCheckAccountCreatePermissions() {
1406 $this->initializeManager( true );
1408 $this->setGroupPermissions( '*', 'createaccount', true );
1409 $this->assertEquals(
1411 $this->manager
->checkAccountCreatePermissions( new \User
)
1414 $readOnlyMode = \MediaWiki\MediaWikiServices
::getInstance()->getReadOnlyMode();
1415 $readOnlyMode->setReason( 'Because' );
1416 $this->assertEquals(
1417 \Status
::newFatal( wfMessage( 'readonlytext', 'Because' ) ),
1418 $this->manager
->checkAccountCreatePermissions( new \User
)
1420 $readOnlyMode->setReason( false );
1422 $this->setGroupPermissions( '*', 'createaccount', false );
1423 $status = $this->manager
->checkAccountCreatePermissions( new \User
);
1424 $this->assertFalse( $status->isOK() );
1425 $this->assertTrue( $status->hasMessage( 'badaccess-groups' ) );
1426 $this->setGroupPermissions( '*', 'createaccount', true );
1428 $user = \User
::newFromName( 'UTBlockee' );
1429 if ( $user->getID() == 0 ) {
1430 $user->addToDatabase();
1431 \TestUser
::setPasswordForUser( $user, 'UTBlockeePassword' );
1432 $user->saveSettings();
1434 $oldBlock = DatabaseBlock
::newFromTarget( 'UTBlockee' );
1436 // An old block will prevent our new one from saving.
1437 $oldBlock->delete();
1440 'address' => 'UTBlockee',
1441 'user' => $user->getID(),
1442 'by' => $this->getTestSysop()->getUser()->getId(),
1443 'reason' => __METHOD__
,
1444 'expiry' => time() +
100500,
1445 'createAccount' => true,
1447 $block = new DatabaseBlock( $blockOptions );
1449 $status = $this->manager
->checkAccountCreatePermissions( $user );
1450 $this->assertFalse( $status->isOK() );
1451 $this->assertTrue( $status->hasMessage( 'cantcreateaccount-text' ) );
1454 'address' => '127.0.0.0/24',
1455 'by' => $this->getTestSysop()->getUser()->getId(),
1456 'reason' => __METHOD__
,
1457 'expiry' => time() +
100500,
1458 'createAccount' => true,
1460 $block = new DatabaseBlock( $blockOptions );
1462 $scopeVariable = new ScopedCallback( [ $block, 'delete' ] );
1463 $status = $this->manager
->checkAccountCreatePermissions( new \User
);
1464 $this->assertFalse( $status->isOK() );
1465 $this->assertTrue( $status->hasMessage( 'cantcreateaccount-range-text' ) );
1466 ScopedCallback
::consume( $scopeVariable );
1468 $this->setMwGlobals( [
1469 'wgEnableDnsBlacklist' => true,
1470 'wgDnsBlacklistUrls' => [
1471 'local.wmftest.net', // This will resolve for every subdomain, which works to test "listed?"
1473 'wgProxyWhitelist' => [],
1475 $this->overrideMwServices();
1476 $status = $this->manager
->checkAccountCreatePermissions( new \User
);
1477 $this->assertFalse( $status->isOK() );
1478 $this->assertTrue( $status->hasMessage( 'sorbs_create_account_reason' ) );
1479 $this->setMwGlobals( 'wgProxyWhitelist', [ '127.0.0.1' ] );
1480 $this->overrideMwServices();
1481 $status = $this->manager
->checkAccountCreatePermissions( new \User
);
1482 $this->assertTrue( $status->isGood() );
1486 * @param string $uniq
1489 private static function usernameForCreation( $uniq = '' ) {
1492 $username = "UTAuthManagerTestAccountCreation" . $uniq . ++
$i;
1493 } while ( \User
::newFromName( $username )->getId() !== 0 );
1497 public function testCanCreateAccount() {
1498 $username = self
::usernameForCreation();
1499 $this->initializeManager();
1501 $this->assertEquals(
1502 \Status
::newFatal( 'authmanager-create-disabled' ),
1503 $this->manager
->canCreateAccount( $username )
1506 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1507 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1508 $mock->expects( $this->any() )->method( 'accountCreationType' )
1509 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1510 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
1511 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1512 ->will( $this->returnValue( StatusValue
::newGood() ) );
1513 $this->primaryauthMocks
= [ $mock ];
1514 $this->initializeManager( true );
1516 $this->assertEquals(
1517 \Status
::newFatal( 'userexists' ),
1518 $this->manager
->canCreateAccount( $username )
1521 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1522 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1523 $mock->expects( $this->any() )->method( 'accountCreationType' )
1524 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1525 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1526 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1527 ->will( $this->returnValue( StatusValue
::newGood() ) );
1528 $this->primaryauthMocks
= [ $mock ];
1529 $this->initializeManager( true );
1531 $this->assertEquals(
1532 \Status
::newFatal( 'noname' ),
1533 $this->manager
->canCreateAccount( $username . '<>' )
1536 $this->assertEquals(
1537 \Status
::newFatal( 'userexists' ),
1538 $this->manager
->canCreateAccount( 'UTSysop' )
1541 $this->assertEquals(
1543 $this->manager
->canCreateAccount( $username )
1546 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1547 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1548 $mock->expects( $this->any() )->method( 'accountCreationType' )
1549 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1550 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1551 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1552 ->will( $this->returnValue( StatusValue
::newFatal( 'fail' ) ) );
1553 $this->primaryauthMocks
= [ $mock ];
1554 $this->initializeManager( true );
1556 $this->assertEquals(
1557 \Status
::newFatal( 'fail' ),
1558 $this->manager
->canCreateAccount( $username )
1562 public function testBeginAccountCreation() {
1563 $creator = \User
::newFromName( 'UTSysop' );
1564 $userReq = new UsernameAuthenticationRequest
;
1565 $this->logger
= new \
TestLogger( false, function ( $message, $level ) {
1566 return $level === LogLevel
::DEBUG ?
null : $message;
1568 $this->initializeManager();
1570 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState', 'test' );
1571 $this->hook( 'LocalUserCreated', $this->never() );
1573 $this->manager
->beginAccountCreation(
1574 $creator, [], 'http://localhost/'
1576 $this->fail( 'Expected exception not thrown' );
1577 } catch ( \LogicException
$ex ) {
1578 $this->assertEquals( 'Account creation is not possible', $ex->getMessage() );
1580 $this->unhook( 'LocalUserCreated' );
1582 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1585 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1586 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1587 $mock->expects( $this->any() )->method( 'accountCreationType' )
1588 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1589 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
1590 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1591 ->will( $this->returnValue( StatusValue
::newGood() ) );
1592 $this->primaryauthMocks
= [ $mock ];
1593 $this->initializeManager( true );
1595 $this->hook( 'LocalUserCreated', $this->never() );
1596 $ret = $this->manager
->beginAccountCreation( $creator, [], 'http://localhost/' );
1597 $this->unhook( 'LocalUserCreated' );
1598 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1599 $this->assertSame( 'noname', $ret->message
->getKey() );
1601 $this->hook( 'LocalUserCreated', $this->never() );
1602 $userReq->username
= self
::usernameForCreation();
1603 $userReq2 = new UsernameAuthenticationRequest
;
1604 $userReq2->username
= $userReq->username
. 'X';
1605 $ret = $this->manager
->beginAccountCreation(
1606 $creator, [ $userReq, $userReq2 ], 'http://localhost/'
1608 $this->unhook( 'LocalUserCreated' );
1609 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1610 $this->assertSame( 'noname', $ret->message
->getKey() );
1612 $readOnlyMode = \MediaWiki\MediaWikiServices
::getInstance()->getReadOnlyMode();
1613 $readOnlyMode->setReason( 'Because' );
1614 $this->hook( 'LocalUserCreated', $this->never() );
1615 $userReq->username
= self
::usernameForCreation();
1616 $ret = $this->manager
->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1617 $this->unhook( 'LocalUserCreated' );
1618 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1619 $this->assertSame( 'readonlytext', $ret->message
->getKey() );
1620 $this->assertSame( [ 'Because' ], $ret->message
->getParams() );
1621 $readOnlyMode->setReason( false );
1623 $this->hook( 'LocalUserCreated', $this->never() );
1624 $userReq->username
= self
::usernameForCreation();
1625 $ret = $this->manager
->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1626 $this->unhook( 'LocalUserCreated' );
1627 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1628 $this->assertSame( 'userexists', $ret->message
->getKey() );
1630 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1631 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1632 $mock->expects( $this->any() )->method( 'accountCreationType' )
1633 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1634 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1635 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1636 ->will( $this->returnValue( StatusValue
::newFatal( 'fail' ) ) );
1637 $this->primaryauthMocks
= [ $mock ];
1638 $this->initializeManager( true );
1640 $this->hook( 'LocalUserCreated', $this->never() );
1641 $userReq->username
= self
::usernameForCreation();
1642 $ret = $this->manager
->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1643 $this->unhook( 'LocalUserCreated' );
1644 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1645 $this->assertSame( 'fail', $ret->message
->getKey() );
1647 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1648 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1649 $mock->expects( $this->any() )->method( 'accountCreationType' )
1650 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1651 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1652 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1653 ->will( $this->returnValue( StatusValue
::newGood() ) );
1654 $this->primaryauthMocks
= [ $mock ];
1655 $this->initializeManager( true );
1657 $this->hook( 'LocalUserCreated', $this->never() );
1658 $userReq->username
= self
::usernameForCreation() . '<>';
1659 $ret = $this->manager
->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1660 $this->unhook( 'LocalUserCreated' );
1661 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1662 $this->assertSame( 'noname', $ret->message
->getKey() );
1664 $this->hook( 'LocalUserCreated', $this->never() );
1665 $userReq->username
= $creator->getName();
1666 $ret = $this->manager
->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1667 $this->unhook( 'LocalUserCreated' );
1668 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1669 $this->assertSame( 'userexists', $ret->message
->getKey() );
1671 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1672 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1673 $mock->expects( $this->any() )->method( 'accountCreationType' )
1674 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1675 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1676 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1677 ->will( $this->returnValue( StatusValue
::newGood() ) );
1678 $mock->expects( $this->any() )->method( 'testForAccountCreation' )
1679 ->will( $this->returnValue( StatusValue
::newFatal( 'fail' ) ) );
1680 $this->primaryauthMocks
= [ $mock ];
1681 $this->initializeManager( true );
1683 $req = $this->getMockBuilder( UserDataAuthenticationRequest
::class )
1684 ->setMethods( [ 'populateUser' ] )
1686 $req->expects( $this->any() )->method( 'populateUser' )
1687 ->willReturn( \StatusValue
::newFatal( 'populatefail' ) );
1688 $userReq->username
= self
::usernameForCreation();
1689 $ret = $this->manager
->beginAccountCreation(
1690 $creator, [ $userReq, $req ], 'http://localhost/'
1692 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1693 $this->assertSame( 'populatefail', $ret->message
->getKey() );
1695 $req = new UserDataAuthenticationRequest
;
1696 $userReq->username
= self
::usernameForCreation();
1698 $ret = $this->manager
->beginAccountCreation(
1699 $creator, [ $userReq, $req ], 'http://localhost/'
1701 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1702 $this->assertSame( 'fail', $ret->message
->getKey() );
1704 $this->manager
->beginAccountCreation(
1705 \User
::newFromName( $userReq->username
), [ $userReq, $req ], 'http://localhost/'
1707 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1708 $this->assertSame( 'fail', $ret->message
->getKey() );
1711 public function testContinueAccountCreation() {
1712 $creator = \User
::newFromName( 'UTSysop' );
1713 $username = self
::usernameForCreation();
1714 $this->logger
= new \
TestLogger( false, function ( $message, $level ) {
1715 return $level === LogLevel
::DEBUG ?
null : $message;
1717 $this->initializeManager();
1721 'username' => $username,
1723 'creatorname' => $username,
1726 'primaryResponse' => null,
1728 'ranPreTests' => true,
1731 $this->hook( 'LocalUserCreated', $this->never() );
1733 $this->manager
->continueAccountCreation( [] );
1734 $this->fail( 'Expected exception not thrown' );
1735 } catch ( \LogicException
$ex ) {
1736 $this->assertEquals( 'Account creation is not possible', $ex->getMessage() );
1738 $this->unhook( 'LocalUserCreated' );
1740 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
1741 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1742 $mock->expects( $this->any() )->method( 'accountCreationType' )
1743 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1744 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1745 $mock->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )->will(
1746 $this->returnValue( AuthenticationResponse
::newFail( $this->message( 'fail' ) ) )
1748 $this->primaryauthMocks
= [ $mock ];
1749 $this->initializeManager( true );
1751 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState', null );
1752 $this->hook( 'LocalUserCreated', $this->never() );
1753 $ret = $this->manager
->continueAccountCreation( [] );
1754 $this->unhook( 'LocalUserCreated' );
1755 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1756 $this->assertSame( 'authmanager-create-not-in-progress', $ret->message
->getKey() );
1758 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1759 [ 'username' => "$username<>" ] +
$session );
1760 $this->hook( 'LocalUserCreated', $this->never() );
1761 $ret = $this->manager
->continueAccountCreation( [] );
1762 $this->unhook( 'LocalUserCreated' );
1763 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1764 $this->assertSame( 'noname', $ret->message
->getKey() );
1766 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1769 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState', $session );
1770 $this->hook( 'LocalUserCreated', $this->never() );
1771 $cache = \ObjectCache
::getLocalClusterInstance();
1772 $lock = $cache->getScopedLock( $cache->makeGlobalKey( 'account', md5( $username ) ) );
1773 $ret = $this->manager
->continueAccountCreation( [] );
1775 $this->unhook( 'LocalUserCreated' );
1776 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1777 $this->assertSame( 'usernameinprogress', $ret->message
->getKey() );
1778 // This error shouldn't remove the existing session, because the
1779 // raced-with process "owns" it.
1781 $session, $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1784 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1785 [ 'username' => $creator->getName() ] +
$session );
1786 $readOnlyMode = \MediaWiki\MediaWikiServices
::getInstance()->getReadOnlyMode();
1787 $readOnlyMode->setReason( 'Because' );
1788 $this->hook( 'LocalUserCreated', $this->never() );
1789 $ret = $this->manager
->continueAccountCreation( [] );
1790 $this->unhook( 'LocalUserCreated' );
1791 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1792 $this->assertSame( 'readonlytext', $ret->message
->getKey() );
1793 $this->assertSame( [ 'Because' ], $ret->message
->getParams() );
1794 $readOnlyMode->setReason( false );
1796 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1797 [ 'username' => $creator->getName() ] +
$session );
1798 $this->hook( 'LocalUserCreated', $this->never() );
1799 $ret = $this->manager
->continueAccountCreation( [] );
1800 $this->unhook( 'LocalUserCreated' );
1801 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1802 $this->assertSame( 'userexists', $ret->message
->getKey() );
1804 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1807 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1808 [ 'userid' => $creator->getId() ] +
$session );
1809 $this->hook( 'LocalUserCreated', $this->never() );
1811 $ret = $this->manager
->continueAccountCreation( [] );
1812 $this->fail( 'Expected exception not thrown' );
1813 } catch ( \UnexpectedValueException
$ex ) {
1814 $this->assertEquals( "User \"{$username}\" should exist now, but doesn't!", $ex->getMessage() );
1816 $this->unhook( 'LocalUserCreated' );
1818 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1821 $id = $creator->getId();
1822 $name = $creator->getName();
1823 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1824 [ 'username' => $name, 'userid' => $id +
1 ] +
$session );
1825 $this->hook( 'LocalUserCreated', $this->never() );
1827 $ret = $this->manager
->continueAccountCreation( [] );
1828 $this->fail( 'Expected exception not thrown' );
1829 } catch ( \UnexpectedValueException
$ex ) {
1830 $this->assertEquals(
1831 "User \"{$name}\" exists, but ID $id !== " . ( $id +
1 ) . '!', $ex->getMessage()
1834 $this->unhook( 'LocalUserCreated' );
1836 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1839 $req = $this->getMockBuilder( UserDataAuthenticationRequest
::class )
1840 ->setMethods( [ 'populateUser' ] )
1842 $req->expects( $this->any() )->method( 'populateUser' )
1843 ->willReturn( \StatusValue
::newFatal( 'populatefail' ) );
1844 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState',
1845 [ 'reqs' => [ $req ] ] +
$session );
1846 $ret = $this->manager
->continueAccountCreation( [] );
1847 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
1848 $this->assertSame( 'populatefail', $ret->message
->getKey() );
1850 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' )
1855 * @dataProvider provideAccountCreation
1856 * @param StatusValue $preTest
1857 * @param StatusValue $primaryTest
1858 * @param StatusValue $secondaryTest
1859 * @param array $primaryResponses
1860 * @param array $secondaryResponses
1861 * @param array $managerResponses
1863 public function testAccountCreation(
1864 StatusValue
$preTest, $primaryTest, $secondaryTest,
1865 array $primaryResponses, array $secondaryResponses, array $managerResponses
1867 $creator = \User
::newFromName( 'UTSysop' );
1868 $username = self
::usernameForCreation();
1870 $this->initializeManager();
1872 // Set up lots of mocks...
1873 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
1874 $req->preTest
= $preTest;
1875 $req->primaryTest
= $primaryTest;
1876 $req->secondaryTest
= $secondaryTest;
1877 $req->primary
= $primaryResponses;
1878 $req->secondary
= $secondaryResponses;
1880 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
1881 $class = ucfirst( $key ) . 'AuthenticationProvider';
1882 $mocks[$key] = $this->getMockForAbstractClass(
1883 "MediaWiki\\Auth\\$class", [], "Mock$class"
1885 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
1886 ->will( $this->returnValue( $key ) );
1887 $mocks[$key]->expects( $this->any() )->method( 'testUserForCreation' )
1888 ->will( $this->returnValue( StatusValue
::newGood() ) );
1889 $mocks[$key]->expects( $this->any() )->method( 'testForAccountCreation' )
1890 ->will( $this->returnCallback(
1891 function ( $user, $creatorIn, $reqs )
1892 use ( $username, $creator, $req, $key )
1894 $this->assertSame( $username, $user->getName() );
1895 $this->assertSame( $creator->getId(), $creatorIn->getId() );
1896 $this->assertSame( $creator->getName(), $creatorIn->getName() );
1898 foreach ( $reqs as $r ) {
1899 $this->assertSame( $username, $r->username
);
1900 $foundReq = $foundReq ||
get_class( $r ) === get_class( $req );
1902 $this->assertTrue( $foundReq, '$reqs contains $req' );
1908 for ( $i = 2; $i <= 3; $i++
) {
1909 $mocks[$key . $i] = $this->getMockForAbstractClass( "MediaWiki\\Auth\\$class" );
1910 $mocks[$key . $i]->expects( $this->any() )->method( 'getUniqueId' )
1911 ->will( $this->returnValue( $key . $i ) );
1912 $mocks[$key . $i]->expects( $this->any() )->method( 'testUserForCreation' )
1913 ->will( $this->returnValue( StatusValue
::newGood() ) );
1914 $mocks[$key . $i]->expects( $this->atMost( 1 ) )->method( 'testForAccountCreation' )
1915 ->will( $this->returnValue( StatusValue
::newGood() ) );
1919 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
1920 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
1921 $mocks['primary']->expects( $this->any() )->method( 'testUserExists' )
1922 ->will( $this->returnValue( false ) );
1923 $ct = count( $req->primary
);
1924 $callback = $this->returnCallback( function ( $user, $creator, $reqs ) use ( $username, $req ) {
1925 $this->assertSame( $username, $user->getName() );
1926 $this->assertSame( 'UTSysop', $creator->getName() );
1928 foreach ( $reqs as $r ) {
1929 $this->assertSame( $username, $r->username
);
1930 $foundReq = $foundReq ||
get_class( $r ) === get_class( $req );
1932 $this->assertTrue( $foundReq, '$reqs contains $req' );
1933 return array_shift( $req->primary
);
1935 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
1936 ->method( 'beginPrimaryAccountCreation' )
1937 ->will( $callback );
1938 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
1939 ->method( 'continuePrimaryAccountCreation' )
1940 ->will( $callback );
1942 $ct = count( $req->secondary
);
1943 $callback = $this->returnCallback( function ( $user, $creator, $reqs ) use ( $username, $req ) {
1944 $this->assertSame( $username, $user->getName() );
1945 $this->assertSame( 'UTSysop', $creator->getName() );
1947 foreach ( $reqs as $r ) {
1948 $this->assertSame( $username, $r->username
);
1949 $foundReq = $foundReq ||
get_class( $r ) === get_class( $req );
1951 $this->assertTrue( $foundReq, '$reqs contains $req' );
1952 return array_shift( $req->secondary
);
1954 $mocks['secondary']->expects( $this->exactly( min( 1, $ct ) ) )
1955 ->method( 'beginSecondaryAccountCreation' )
1956 ->will( $callback );
1957 $mocks['secondary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
1958 ->method( 'continueSecondaryAccountCreation' )
1959 ->will( $callback );
1961 $abstain = AuthenticationResponse
::newAbstain();
1962 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
1963 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
1964 $mocks['primary2']->expects( $this->any() )->method( 'testUserExists' )
1965 ->will( $this->returnValue( false ) );
1966 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAccountCreation' )
1967 ->will( $this->returnValue( $abstain ) );
1968 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAccountCreation' );
1969 $mocks['primary3']->expects( $this->any() )->method( 'accountCreationType' )
1970 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_NONE
) );
1971 $mocks['primary3']->expects( $this->any() )->method( 'testUserExists' )
1972 ->will( $this->returnValue( false ) );
1973 $mocks['primary3']->expects( $this->never() )->method( 'beginPrimaryAccountCreation' );
1974 $mocks['primary3']->expects( $this->never() )->method( 'continuePrimaryAccountCreation' );
1975 $mocks['secondary2']->expects( $this->atMost( 1 ) )
1976 ->method( 'beginSecondaryAccountCreation' )
1977 ->will( $this->returnValue( $abstain ) );
1978 $mocks['secondary2']->expects( $this->never() )->method( 'continueSecondaryAccountCreation' );
1979 $mocks['secondary3']->expects( $this->atMost( 1 ) )
1980 ->method( 'beginSecondaryAccountCreation' )
1981 ->will( $this->returnValue( $abstain ) );
1982 $mocks['secondary3']->expects( $this->never() )->method( 'continueSecondaryAccountCreation' );
1984 $this->preauthMocks
= [ $mocks['pre'], $mocks['pre2'] ];
1985 $this->primaryauthMocks
= [ $mocks['primary3'], $mocks['primary'], $mocks['primary2'] ];
1986 $this->secondaryauthMocks
= [
1987 $mocks['secondary3'], $mocks['secondary'], $mocks['secondary2']
1990 $this->logger
= new \
TestLogger( true, function ( $message, $level ) {
1991 return $level === LogLevel
::DEBUG ?
null : $message;
1994 $this->initializeManager( true );
1996 $constraint = \PHPUnit_Framework_Assert
::logicalOr(
1997 $this->equalTo( AuthenticationResponse
::PASS
),
1998 $this->equalTo( AuthenticationResponse
::FAIL
)
2000 $providers = array_merge(
2001 $this->preauthMocks
, $this->primaryauthMocks
, $this->secondaryauthMocks
2003 foreach ( $providers as $p ) {
2004 $p->postCalled
= false;
2005 $p->expects( $this->atMost( 1 ) )->method( 'postAccountCreation' )
2006 ->willReturnCallback( function ( $user, $creator, $response )
2007 use ( $constraint, $p, $username )
2009 $this->assertInstanceOf( \User
::class, $user );
2010 $this->assertSame( $username, $user->getName() );
2011 $this->assertSame( 'UTSysop', $creator->getName() );
2012 $this->assertInstanceOf( AuthenticationResponse
::class, $response );
2013 $this->assertThat( $response->status
, $constraint );
2014 $p->postCalled
= $response->status
;
2018 // We're testing with $wgNewUserLog = false, so assert that it worked
2019 $dbw = wfGetDB( DB_MASTER
);
2020 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2024 foreach ( $managerResponses as $i => $response ) {
2025 $success = $response instanceof AuthenticationResponse
&&
2026 $response->status
=== AuthenticationResponse
::PASS
;
2027 if ( $i === 'created' ) {
2029 $this->hook( 'LocalUserCreated', $this->once() )
2031 $this->callback( function ( $user ) use ( $username ) {
2032 return $user->getName() === $username;
2034 $this->equalTo( false )
2036 $expectLog[] = [ LogLevel
::INFO
, "Creating user {user} during account creation" ];
2038 $this->hook( 'LocalUserCreated', $this->never() );
2044 $userReq = new UsernameAuthenticationRequest
;
2045 $userReq->username
= $username;
2046 $ret = $this->manager
->beginAccountCreation(
2047 $creator, [ $userReq, $req ], 'http://localhost/'
2050 $ret = $this->manager
->continueAccountCreation( [ $req ] );
2052 if ( $response instanceof \Exception
) {
2053 $this->fail( 'Expected exception not thrown', "Response $i" );
2055 } catch ( \Exception
$ex ) {
2056 if ( !$response instanceof \Exception
) {
2059 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
2061 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2062 "Response $i, exception, session state"
2064 $this->unhook( 'LocalUserCreated' );
2068 $this->unhook( 'LocalUserCreated' );
2070 $this->assertSame( 'http://localhost/', $req->returnToUrl
);
2073 $this->assertNotNull( $ret->loginRequest
, "Response $i, login marker" );
2074 $this->assertContains(
2075 $ret->loginRequest
, $this->managerPriv
->createdAccountAuthenticationRequests
,
2076 "Response $i, login marker"
2081 "MediaWiki\Auth\AuthManager::continueAccountCreation: Account creation succeeded for {user}"
2084 // Set some fields in the expected $response that we couldn't
2085 // know in provideAccountCreation().
2086 $response->username
= $username;
2087 $response->loginRequest
= $ret->loginRequest
;
2089 $this->assertNull( $ret->loginRequest
, "Response $i, login marker" );
2090 $this->assertSame( [], $this->managerPriv
->createdAccountAuthenticationRequests
,
2091 "Response $i, login marker" );
2093 $ret->message
= $this->message( $ret->message
);
2094 $this->assertResponseEquals( $response, $ret, "Response $i, response" );
2095 if ( $success ||
$response->status
=== AuthenticationResponse
::FAIL
) {
2097 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2098 "Response $i, session state"
2100 foreach ( $providers as $p ) {
2101 $this->assertSame( $response->status
, $p->postCalled
,
2102 "Response $i, post-auth callback called" );
2105 $this->assertNotNull(
2106 $this->request
->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2107 "Response $i, session state"
2109 foreach ( $ret->neededRequests
as $neededReq ) {
2110 $this->assertEquals( AuthManager
::ACTION_CREATE
, $neededReq->action
,
2111 "Response $i, neededRequest action" );
2113 $this->assertEquals(
2114 $ret->neededRequests
,
2115 $this->manager
->getAuthenticationRequests( AuthManager
::ACTION_CREATE_CONTINUE
),
2116 "Response $i, continuation check"
2118 foreach ( $providers as $p ) {
2119 $this->assertFalse( $p->postCalled
, "Response $i, post-auth callback not called" );
2124 $this->assertNotEquals( 0, \User
::idFromName( $username ) );
2126 $this->assertEquals( 0, \User
::idFromName( $username ) );
2132 $this->assertSame( $expectLog, $this->logger
->getBuffer() );
2136 $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] )
2140 public function provideAccountCreation() {
2141 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
2142 $good = StatusValue
::newGood();
2145 'Pre-creation test fail in pre' => [
2146 StatusValue
::newFatal( 'fail-from-pre' ), $good, $good,
2150 AuthenticationResponse
::newFail( $this->message( 'fail-from-pre' ) ),
2153 'Pre-creation test fail in primary' => [
2154 $good, StatusValue
::newFatal( 'fail-from-primary' ), $good,
2158 AuthenticationResponse
::newFail( $this->message( 'fail-from-primary' ) ),
2161 'Pre-creation test fail in secondary' => [
2162 $good, $good, StatusValue
::newFatal( 'fail-from-secondary' ),
2166 AuthenticationResponse
::newFail( $this->message( 'fail-from-secondary' ) ),
2169 'Failure in primary' => [
2170 $good, $good, $good,
2172 AuthenticationResponse
::newFail( $this->message( 'fail-from-primary' ) ),
2177 'All primary abstain' => [
2178 $good, $good, $good,
2180 AuthenticationResponse
::newAbstain(),
2184 AuthenticationResponse
::newFail( $this->message( 'authmanager-create-no-primary' ) )
2187 'Primary UI, then redirect, then fail' => [
2188 $good, $good, $good,
2190 AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
2191 AuthenticationResponse
::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
2192 AuthenticationResponse
::newFail( $this->message( 'fail-in-primary-continue' ) ),
2197 'Primary redirect, then abstain' => [
2198 $good, $good, $good,
2200 $tmp = AuthenticationResponse
::newRedirect(
2201 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
2203 AuthenticationResponse
::newAbstain(),
2208 new \
DomainException(
2209 'MockPrimaryAuthenticationProvider::continuePrimaryAccountCreation() returned ABSTAIN'
2213 'Primary UI, then pass; secondary abstain' => [
2214 $good, $good, $good,
2216 $tmp1 = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
2217 AuthenticationResponse
::newPass(),
2220 AuthenticationResponse
::newAbstain(),
2224 'created' => AuthenticationResponse
::newPass( '' ),
2227 'Primary pass; secondary UI then pass' => [
2228 $good, $good, $good,
2230 AuthenticationResponse
::newPass( '' ),
2233 $tmp1 = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
2234 AuthenticationResponse
::newPass( '' ),
2238 AuthenticationResponse
::newPass( '' ),
2241 'Primary pass; secondary fail' => [
2242 $good, $good, $good,
2244 AuthenticationResponse
::newPass(),
2247 AuthenticationResponse
::newFail( $this->message( '...' ) ),
2250 'created' => new \
DomainException(
2251 'MockSecondaryAuthenticationProvider::beginSecondaryAccountCreation() returned FAIL. ' .
2252 'Secondary providers are not allowed to fail account creation, ' .
2253 'that should have been done via testForAccountCreation().'
2261 * @dataProvider provideAccountCreationLogging
2262 * @param bool $isAnon
2263 * @param string|null $logSubtype
2265 public function testAccountCreationLogging( $isAnon, $logSubtype ) {
2266 $creator = $isAnon ?
new \User
: \User
::newFromName( 'UTSysop' );
2267 $username = self
::usernameForCreation();
2269 $this->initializeManager();
2271 // Set up lots of mocks...
2272 $mock = $this->getMockForAbstractClass(
2273 \MediaWiki\Auth\PrimaryAuthenticationProvider
::class, []
2275 $mock->expects( $this->any() )->method( 'getUniqueId' )
2276 ->will( $this->returnValue( 'primary' ) );
2277 $mock->expects( $this->any() )->method( 'testUserForCreation' )
2278 ->will( $this->returnValue( StatusValue
::newGood() ) );
2279 $mock->expects( $this->any() )->method( 'testForAccountCreation' )
2280 ->will( $this->returnValue( StatusValue
::newGood() ) );
2281 $mock->expects( $this->any() )->method( 'accountCreationType' )
2282 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
2283 $mock->expects( $this->any() )->method( 'testUserExists' )
2284 ->will( $this->returnValue( false ) );
2285 $mock->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )
2286 ->will( $this->returnValue( AuthenticationResponse
::newPass( $username ) ) );
2287 $mock->expects( $this->any() )->method( 'finishAccountCreation' )
2288 ->will( $this->returnValue( $logSubtype ) );
2290 $this->primaryauthMocks
= [ $mock ];
2291 $this->initializeManager( true );
2292 $this->logger
->setCollect( true );
2294 $this->config
->set( 'NewUserLog', true );
2296 $dbw = wfGetDB( DB_MASTER
);
2297 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2299 $userReq = new UsernameAuthenticationRequest
;
2300 $userReq->username
= $username;
2301 $reasonReq = new CreationReasonAuthenticationRequest
;
2302 $reasonReq->reason
= $this->toString();
2303 $ret = $this->manager
->beginAccountCreation(
2304 $creator, [ $userReq, $reasonReq ], 'http://localhost/'
2307 $this->assertSame( AuthenticationResponse
::PASS
, $ret->status
);
2309 $user = \User
::newFromName( $username );
2310 $this->assertNotEquals( 0, $user->getId(), 'sanity check' );
2311 $this->assertNotEquals( $creator->getId(), $user->getId(), 'sanity check' );
2313 $data = \DatabaseLogEntry
::getSelectQueryData();
2314 $rows = iterator_to_array( $dbw->select(
2318 'log_id > ' . (int)$maxLogId,
2319 'log_type' => 'newusers'
2325 $this->assertCount( 1, $rows );
2326 $entry = \DatabaseLogEntry
::newFromRow( reset( $rows ) );
2328 $this->assertSame( $logSubtype ?
: ( $isAnon ?
'create' : 'create2' ), $entry->getSubtype() );
2330 $isAnon ?
$user->getId() : $creator->getId(),
2331 $entry->getPerformer()->getId()
2334 $isAnon ?
$user->getName() : $creator->getName(),
2335 $entry->getPerformer()->getName()
2337 $this->assertSame( $user->getUserPage()->getFullText(), $entry->getTarget()->getFullText() );
2338 $this->assertSame( [ '4::userid' => $user->getId() ], $entry->getParameters() );
2339 $this->assertSame( $this->toString(), $entry->getComment() );
2342 public static function provideAccountCreationLogging() {
2347 [ false, 'byemail' ],
2351 public function testAutoAccountCreation() {
2352 // PHPUnit seems to have a bug where it will call the ->with()
2353 // callbacks for our hooks again after the test is run (WTF?), which
2354 // breaks here because $username no longer matches $user by the end of
2356 $workaroundPHPUnitBug = false;
2358 $username = self
::usernameForCreation();
2359 $expectedSource = AuthManager
::AUTOCREATE_SOURCE_SESSION
;
2360 $this->initializeManager();
2362 $this->setGroupPermissions( '*', 'createaccount', true );
2363 $this->setGroupPermissions( '*', 'autocreateaccount', false );
2365 $this->mergeMwGlobalArrayValue( 'wgObjectCaches',
2366 [ __METHOD__
=> [ 'class' => 'HashBagOStuff' ] ] );
2367 $this->setMwGlobals( [ 'wgMainCacheType' => __METHOD__
] );
2369 // Set up lots of mocks...
2371 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
2372 $class = ucfirst( $key ) . 'AuthenticationProvider';
2373 $mocks[$key] = $this->getMockForAbstractClass( "MediaWiki\\Auth\\$class" );
2374 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
2375 ->will( $this->returnValue( $key ) );
2378 $good = StatusValue
::newGood();
2379 $ok = StatusValue
::newFatal( 'ok' );
2380 $callback = $this->callback( function ( $user ) use ( &$username, &$workaroundPHPUnitBug ) {
2381 return $workaroundPHPUnitBug ||
$user->getName() === $username;
2383 $callback2 = $this->callback(
2384 function ( $source ) use ( &$expectedSource, &$workaroundPHPUnitBug ) {
2385 return $workaroundPHPUnitBug ||
$source === $expectedSource;
2389 $mocks['pre']->expects( $this->exactly( 13 ) )->method( 'testUserForCreation' )
2390 ->with( $callback, $callback2 )
2391 ->will( $this->onConsecutiveCalls(
2392 $ok, $ok, $ok, // For testing permissions
2393 StatusValue
::newFatal( 'fail-in-pre' ), $good, $good,
2394 $good, // backoff test
2395 $good, // addToDatabase fails test
2396 $good, // addToDatabase throws test
2397 $good, // addToDatabase exists test
2398 $good, $good, $good // success
2401 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
2402 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
2403 $mocks['primary']->expects( $this->any() )->method( 'testUserExists' )
2404 ->will( $this->returnValue( true ) );
2405 $mocks['primary']->expects( $this->exactly( 9 ) )->method( 'testUserForCreation' )
2406 ->with( $callback, $callback2 )
2407 ->will( $this->onConsecutiveCalls(
2408 StatusValue
::newFatal( 'fail-in-primary' ), $good,
2409 $good, // backoff test
2410 $good, // addToDatabase fails test
2411 $good, // addToDatabase throws test
2412 $good, // addToDatabase exists test
2415 $mocks['primary']->expects( $this->exactly( 3 ) )->method( 'autoCreatedAccount' )
2416 ->with( $callback, $callback2 );
2418 $mocks['secondary']->expects( $this->exactly( 8 ) )->method( 'testUserForCreation' )
2419 ->with( $callback, $callback2 )
2420 ->will( $this->onConsecutiveCalls(
2421 StatusValue
::newFatal( 'fail-in-secondary' ),
2422 $good, // backoff test
2423 $good, // addToDatabase fails test
2424 $good, // addToDatabase throws test
2425 $good, // addToDatabase exists test
2428 $mocks['secondary']->expects( $this->exactly( 3 ) )->method( 'autoCreatedAccount' )
2429 ->with( $callback, $callback2 );
2431 $this->preauthMocks
= [ $mocks['pre'] ];
2432 $this->primaryauthMocks
= [ $mocks['primary'] ];
2433 $this->secondaryauthMocks
= [ $mocks['secondary'] ];
2434 $this->initializeManager( true );
2435 $session = $this->request
->getSession();
2437 $logger = new \
TestLogger( true, function ( $m ) {
2438 $m = str_replace( 'MediaWiki\\Auth\\AuthManager::autoCreateUser: ', '', $m );
2441 $this->manager
->setLogger( $logger );
2444 $user = \User
::newFromName( 'UTSysop' );
2445 $this->manager
->autoCreateUser( $user, 'InvalidSource', true );
2446 $this->fail( 'Expected exception not thrown' );
2447 } catch ( \InvalidArgumentException
$ex ) {
2448 $this->assertSame( 'Unknown auto-creation source: InvalidSource', $ex->getMessage() );
2451 // First, check an existing user
2453 $user = \User
::newFromName( 'UTSysop' );
2454 $this->hook( 'LocalUserCreated', $this->never() );
2455 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2456 $this->unhook( 'LocalUserCreated' );
2457 $expect = \Status
::newGood();
2458 $expect->warning( 'userexists' );
2459 $this->assertEquals( $expect, $ret );
2460 $this->assertNotEquals( 0, $user->getId() );
2461 $this->assertSame( 'UTSysop', $user->getName() );
2462 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2463 $this->assertSame( [
2464 [ LogLevel
::DEBUG
, '{username} already exists locally' ],
2465 ], $logger->getBuffer() );
2466 $logger->clearBuffer();
2469 $user = \User
::newFromName( 'UTSysop' );
2470 $this->hook( 'LocalUserCreated', $this->never() );
2471 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, false );
2472 $this->unhook( 'LocalUserCreated' );
2473 $expect = \Status
::newGood();
2474 $expect->warning( 'userexists' );
2475 $this->assertEquals( $expect, $ret );
2476 $this->assertNotEquals( 0, $user->getId() );
2477 $this->assertSame( 'UTSysop', $user->getName() );
2478 $this->assertEquals( 0, $session->getUser()->getId() );
2479 $this->assertSame( [
2480 [ LogLevel
::DEBUG
, '{username} already exists locally' ],
2481 ], $logger->getBuffer() );
2482 $logger->clearBuffer();
2484 // Wiki is read-only
2486 $readOnlyMode = \MediaWiki\MediaWikiServices
::getInstance()->getReadOnlyMode();
2487 $readOnlyMode->setReason( 'Because' );
2488 $user = \User
::newFromName( $username );
2489 $this->hook( 'LocalUserCreated', $this->never() );
2490 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2491 $this->unhook( 'LocalUserCreated' );
2492 $this->assertEquals( \Status
::newFatal( wfMessage( 'readonlytext', 'Because' ) ), $ret );
2493 $this->assertEquals( 0, $user->getId() );
2494 $this->assertNotEquals( $username, $user->getName() );
2495 $this->assertEquals( 0, $session->getUser()->getId() );
2496 $this->assertSame( [
2497 [ LogLevel
::DEBUG
, 'denied by wfReadOnly(): {reason}' ],
2498 ], $logger->getBuffer() );
2499 $logger->clearBuffer();
2500 $readOnlyMode->setReason( false );
2502 // Session blacklisted
2504 $session->set( 'AuthManager::AutoCreateBlacklist', 'test' );
2505 $user = \User
::newFromName( $username );
2506 $this->hook( 'LocalUserCreated', $this->never() );
2507 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2508 $this->unhook( 'LocalUserCreated' );
2509 $this->assertEquals( \Status
::newFatal( 'test' ), $ret );
2510 $this->assertEquals( 0, $user->getId() );
2511 $this->assertNotEquals( $username, $user->getName() );
2512 $this->assertEquals( 0, $session->getUser()->getId() );
2513 $this->assertSame( [
2514 [ LogLevel
::DEBUG
, 'blacklisted in session {sessionid}' ],
2515 ], $logger->getBuffer() );
2516 $logger->clearBuffer();
2519 $session->set( 'AuthManager::AutoCreateBlacklist', StatusValue
::newFatal( 'test2' ) );
2520 $user = \User
::newFromName( $username );
2521 $this->hook( 'LocalUserCreated', $this->never() );
2522 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2523 $this->unhook( 'LocalUserCreated' );
2524 $this->assertEquals( \Status
::newFatal( 'test2' ), $ret );
2525 $this->assertEquals( 0, $user->getId() );
2526 $this->assertNotEquals( $username, $user->getName() );
2527 $this->assertEquals( 0, $session->getUser()->getId() );
2528 $this->assertSame( [
2529 [ LogLevel
::DEBUG
, 'blacklisted in session {sessionid}' ],
2530 ], $logger->getBuffer() );
2531 $logger->clearBuffer();
2535 $user = \User
::newFromName( $username . '@' );
2536 $this->hook( 'LocalUserCreated', $this->never() );
2537 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2538 $this->unhook( 'LocalUserCreated' );
2539 $this->assertEquals( \Status
::newFatal( 'noname' ), $ret );
2540 $this->assertEquals( 0, $user->getId() );
2541 $this->assertNotEquals( $username . '@', $user->getId() );
2542 $this->assertEquals( 0, $session->getUser()->getId() );
2543 $this->assertSame( [
2544 [ LogLevel
::DEBUG
, 'name "{username}" is not creatable' ],
2545 ], $logger->getBuffer() );
2546 $logger->clearBuffer();
2547 $this->assertSame( 'noname', $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2549 // IP unable to create accounts
2550 $this->setGroupPermissions( '*', 'createaccount', false );
2551 $this->setGroupPermissions( '*', 'autocreateaccount', false );
2553 $user = \User
::newFromName( $username );
2554 $this->hook( 'LocalUserCreated', $this->never() );
2555 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2556 $this->unhook( 'LocalUserCreated' );
2557 $this->assertEquals( \Status
::newFatal( 'authmanager-autocreate-noperm' ), $ret );
2558 $this->assertEquals( 0, $user->getId() );
2559 $this->assertNotEquals( $username, $user->getName() );
2560 $this->assertEquals( 0, $session->getUser()->getId() );
2561 $this->assertSame( [
2562 [ LogLevel
::DEBUG
, 'IP lacks the ability to create or autocreate accounts' ],
2563 ], $logger->getBuffer() );
2564 $logger->clearBuffer();
2566 'authmanager-autocreate-noperm', $session->get( 'AuthManager::AutoCreateBlacklist' )
2569 // maintenance scripts always work
2570 $expectedSource = AuthManager
::AUTOCREATE_SOURCE_MAINT
;
2571 $this->setGroupPermissions( '*', 'createaccount', false );
2572 $this->setGroupPermissions( '*', 'autocreateaccount', false );
2574 $user = \User
::newFromName( $username );
2575 $this->hook( 'LocalUserCreated', $this->never() );
2576 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_MAINT
, true );
2577 $this->unhook( 'LocalUserCreated' );
2578 $this->assertEquals( \Status
::newFatal( 'ok' ), $ret );
2580 // Test that both permutations of permissions are allowed
2581 // (this hits the two "ok" entries in $mocks['pre'])
2582 $expectedSource = AuthManager
::AUTOCREATE_SOURCE_SESSION
;
2583 $this->setGroupPermissions( '*', 'createaccount', false );
2584 $this->setGroupPermissions( '*', 'autocreateaccount', true );
2586 $user = \User
::newFromName( $username );
2587 $this->hook( 'LocalUserCreated', $this->never() );
2588 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2589 $this->unhook( 'LocalUserCreated' );
2590 $this->assertEquals( \Status
::newFatal( 'ok' ), $ret );
2592 $this->setGroupPermissions( '*', 'createaccount', true );
2593 $this->setGroupPermissions( '*', 'autocreateaccount', false );
2595 $user = \User
::newFromName( $username );
2596 $this->hook( 'LocalUserCreated', $this->never() );
2597 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2598 $this->unhook( 'LocalUserCreated' );
2599 $this->assertEquals( \Status
::newFatal( 'ok' ), $ret );
2600 $logger->clearBuffer();
2604 $user = \User
::newFromName( $username );
2605 $this->hook( 'LocalUserCreated', $this->never() );
2606 $cache = \ObjectCache
::getLocalClusterInstance();
2607 $lock = $cache->getScopedLock( $cache->makeGlobalKey( 'account', md5( $username ) ) );
2608 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2610 $this->unhook( 'LocalUserCreated' );
2611 $this->assertEquals( \Status
::newFatal( 'usernameinprogress' ), $ret );
2612 $this->assertEquals( 0, $user->getId() );
2613 $this->assertNotEquals( $username, $user->getName() );
2614 $this->assertEquals( 0, $session->getUser()->getId() );
2615 $this->assertSame( [
2616 [ LogLevel
::DEBUG
, 'Could not acquire account creation lock' ],
2617 ], $logger->getBuffer() );
2618 $logger->clearBuffer();
2620 // Test pre-authentication provider fail
2622 $user = \User
::newFromName( $username );
2623 $this->hook( 'LocalUserCreated', $this->never() );
2624 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2625 $this->unhook( 'LocalUserCreated' );
2626 $this->assertEquals( \Status
::newFatal( 'fail-in-pre' ), $ret );
2627 $this->assertEquals( 0, $user->getId() );
2628 $this->assertNotEquals( $username, $user->getName() );
2629 $this->assertEquals( 0, $session->getUser()->getId() );
2630 $this->assertSame( [
2631 [ LogLevel
::DEBUG
, 'Provider denied creation of {username}: {reason}' ],
2632 ], $logger->getBuffer() );
2633 $logger->clearBuffer();
2634 $this->assertEquals(
2635 StatusValue
::newFatal( 'fail-in-pre' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2639 $user = \User
::newFromName( $username );
2640 $this->hook( 'LocalUserCreated', $this->never() );
2641 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2642 $this->unhook( 'LocalUserCreated' );
2643 $this->assertEquals( \Status
::newFatal( 'fail-in-primary' ), $ret );
2644 $this->assertEquals( 0, $user->getId() );
2645 $this->assertNotEquals( $username, $user->getName() );
2646 $this->assertEquals( 0, $session->getUser()->getId() );
2647 $this->assertSame( [
2648 [ LogLevel
::DEBUG
, 'Provider denied creation of {username}: {reason}' ],
2649 ], $logger->getBuffer() );
2650 $logger->clearBuffer();
2651 $this->assertEquals(
2652 StatusValue
::newFatal( 'fail-in-primary' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2656 $user = \User
::newFromName( $username );
2657 $this->hook( 'LocalUserCreated', $this->never() );
2658 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2659 $this->unhook( 'LocalUserCreated' );
2660 $this->assertEquals( \Status
::newFatal( 'fail-in-secondary' ), $ret );
2661 $this->assertEquals( 0, $user->getId() );
2662 $this->assertNotEquals( $username, $user->getName() );
2663 $this->assertEquals( 0, $session->getUser()->getId() );
2664 $this->assertSame( [
2665 [ LogLevel
::DEBUG
, 'Provider denied creation of {username}: {reason}' ],
2666 ], $logger->getBuffer() );
2667 $logger->clearBuffer();
2668 $this->assertEquals(
2669 StatusValue
::newFatal( 'fail-in-secondary' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2673 $cache = \ObjectCache
::getLocalClusterInstance();
2674 $backoffKey = $cache->makeKey( 'AuthManager', 'autocreate-failed', md5( $username ) );
2675 $cache->set( $backoffKey, true );
2677 $user = \User
::newFromName( $username );
2678 $this->hook( 'LocalUserCreated', $this->never() );
2679 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2680 $this->unhook( 'LocalUserCreated' );
2681 $this->assertEquals( \Status
::newFatal( 'authmanager-autocreate-exception' ), $ret );
2682 $this->assertEquals( 0, $user->getId() );
2683 $this->assertNotEquals( $username, $user->getName() );
2684 $this->assertEquals( 0, $session->getUser()->getId() );
2685 $this->assertSame( [
2686 [ LogLevel
::DEBUG
, '{username} denied by prior creation attempt failures' ],
2687 ], $logger->getBuffer() );
2688 $logger->clearBuffer();
2689 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2690 $cache->delete( $backoffKey );
2692 // Test addToDatabase fails
2694 $user = $this->getMockBuilder( \User
::class )
2695 ->setMethods( [ 'addToDatabase' ] )->getMock();
2696 $user->expects( $this->once() )->method( 'addToDatabase' )
2697 ->will( $this->returnValue( \Status
::newFatal( 'because' ) ) );
2698 $user->setName( $username );
2699 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2700 $this->assertEquals( \Status
::newFatal( 'because' ), $ret );
2701 $this->assertEquals( 0, $user->getId() );
2702 $this->assertNotEquals( $username, $user->getName() );
2703 $this->assertEquals( 0, $session->getUser()->getId() );
2704 $this->assertSame( [
2705 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {from}' ],
2706 [ LogLevel
::ERROR
, '{username} failed with message {msg}' ],
2707 ], $logger->getBuffer() );
2708 $logger->clearBuffer();
2709 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2711 // Test addToDatabase throws an exception
2712 $cache = \ObjectCache
::getLocalClusterInstance();
2713 $backoffKey = $cache->makeKey( 'AuthManager', 'autocreate-failed', md5( $username ) );
2714 $this->assertFalse( $cache->get( $backoffKey ), 'sanity check' );
2716 $user = $this->getMockBuilder( \User
::class )
2717 ->setMethods( [ 'addToDatabase' ] )->getMock();
2718 $user->expects( $this->once() )->method( 'addToDatabase' )
2719 ->will( $this->throwException( new \
Exception( 'Excepted' ) ) );
2720 $user->setName( $username );
2722 $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2723 $this->fail( 'Expected exception not thrown' );
2724 } catch ( \Exception
$ex ) {
2725 $this->assertSame( 'Excepted', $ex->getMessage() );
2727 $this->assertEquals( 0, $user->getId() );
2728 $this->assertEquals( 0, $session->getUser()->getId() );
2729 $this->assertSame( [
2730 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {from}' ],
2731 [ LogLevel
::ERROR
, '{username} failed with exception {exception}' ],
2732 ], $logger->getBuffer() );
2733 $logger->clearBuffer();
2734 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2735 $this->assertNotEquals( false, $cache->get( $backoffKey ) );
2736 $cache->delete( $backoffKey );
2738 // Test addToDatabase fails because the user already exists.
2740 $user = $this->getMockBuilder( \User
::class )
2741 ->setMethods( [ 'addToDatabase' ] )->getMock();
2742 $user->expects( $this->once() )->method( 'addToDatabase' )
2743 ->will( $this->returnCallback( function () use ( $username, &$user ) {
2744 $oldUser = \User
::newFromName( $username );
2745 $status = $oldUser->addToDatabase();
2746 $this->assertTrue( $status->isOK(), 'sanity check' );
2747 $user->setId( $oldUser->getId() );
2748 return \Status
::newFatal( 'userexists' );
2750 $user->setName( $username );
2751 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2752 $expect = \Status
::newGood();
2753 $expect->warning( 'userexists' );
2754 $this->assertEquals( $expect, $ret );
2755 $this->assertNotEquals( 0, $user->getId() );
2756 $this->assertEquals( $username, $user->getName() );
2757 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2758 $this->assertSame( [
2759 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {from}' ],
2760 [ LogLevel
::INFO
, '{username} already exists locally (race)' ],
2761 ], $logger->getBuffer() );
2762 $logger->clearBuffer();
2763 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2767 $username = self
::usernameForCreation();
2768 $user = \User
::newFromName( $username );
2769 $this->hook( 'LocalUserCreated', $this->once() )
2770 ->with( $callback, $this->equalTo( true ) );
2771 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, true );
2772 $this->unhook( 'LocalUserCreated' );
2773 $this->assertEquals( \Status
::newGood(), $ret );
2774 $this->assertNotEquals( 0, $user->getId() );
2775 $this->assertEquals( $username, $user->getName() );
2776 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2777 $this->assertSame( [
2778 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {from}' ],
2779 ], $logger->getBuffer() );
2780 $logger->clearBuffer();
2782 $dbw = wfGetDB( DB_MASTER
);
2783 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2785 $username = self
::usernameForCreation();
2786 $user = \User
::newFromName( $username );
2787 $this->hook( 'LocalUserCreated', $this->once() )
2788 ->with( $callback, $this->equalTo( true ) );
2789 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, false );
2790 $this->unhook( 'LocalUserCreated' );
2791 $this->assertEquals( \Status
::newGood(), $ret );
2792 $this->assertNotEquals( 0, $user->getId() );
2793 $this->assertEquals( $username, $user->getName() );
2794 $this->assertEquals( 0, $session->getUser()->getId() );
2795 $this->assertSame( [
2796 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {from}' ],
2797 ], $logger->getBuffer() );
2798 $logger->clearBuffer();
2801 $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] )
2804 $this->config
->set( 'NewUserLog', true );
2806 $username = self
::usernameForCreation();
2807 $user = \User
::newFromName( $username );
2808 $ret = $this->manager
->autoCreateUser( $user, AuthManager
::AUTOCREATE_SOURCE_SESSION
, false );
2809 $this->assertEquals( \Status
::newGood(), $ret );
2810 $logger->clearBuffer();
2812 $data = \DatabaseLogEntry
::getSelectQueryData();
2813 $rows = iterator_to_array( $dbw->select(
2817 'log_id > ' . (int)$maxLogId,
2818 'log_type' => 'newusers'
2824 $this->assertCount( 1, $rows );
2825 $entry = \DatabaseLogEntry
::newFromRow( reset( $rows ) );
2827 $this->assertSame( 'autocreate', $entry->getSubtype() );
2828 $this->assertSame( $user->getId(), $entry->getPerformer()->getId() );
2829 $this->assertSame( $user->getName(), $entry->getPerformer()->getName() );
2830 $this->assertSame( $user->getUserPage()->getFullText(), $entry->getTarget()->getFullText() );
2831 $this->assertSame( [ '4::userid' => $user->getId() ], $entry->getParameters() );
2833 $workaroundPHPUnitBug = true;
2837 * @dataProvider provideGetAuthenticationRequests
2838 * @param string $action
2839 * @param array $expect
2840 * @param array $state
2842 public function testGetAuthenticationRequests( $action, $expect, $state = [] ) {
2843 $makeReq = function ( $key ) use ( $action ) {
2844 $req = $this->createMock( AuthenticationRequest
::class );
2845 $req->expects( $this->any() )->method( 'getUniqueId' )
2846 ->will( $this->returnValue( $key ) );
2847 $req->action
= $action === AuthManager
::ACTION_UNLINK ? AuthManager
::ACTION_REMOVE
: $action;
2851 $cmpReqs = function ( $a, $b ) {
2852 $ret = strcmp( get_class( $a ), get_class( $b ) );
2854 $ret = strcmp( $a->key
, $b->key
);
2859 $good = StatusValue
::newGood();
2862 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
2863 $class = ucfirst( $key ) . 'AuthenticationProvider';
2864 $mocks[$key] = $this->getMockBuilder( "MediaWiki\\Auth\\$class" )
2866 'getUniqueId', 'getAuthenticationRequests', 'providerAllowsAuthenticationDataChange',
2868 ->getMockForAbstractClass();
2869 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
2870 ->will( $this->returnValue( $key ) );
2871 $mocks[$key]->expects( $this->any() )->method( 'getAuthenticationRequests' )
2872 ->will( $this->returnCallback( function ( $action ) use ( $key, $makeReq ) {
2873 return [ $makeReq( "$key-$action" ), $makeReq( 'generic' ) ];
2875 $mocks[$key]->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
2876 ->will( $this->returnValue( $good ) );
2881 PrimaryAuthenticationProvider
::TYPE_NONE
,
2882 PrimaryAuthenticationProvider
::TYPE_CREATE
,
2883 PrimaryAuthenticationProvider
::TYPE_LINK
2885 $class = 'PrimaryAuthenticationProvider';
2886 $mocks["primary-$type"] = $this->getMockBuilder( "MediaWiki\\Auth\\$class" )
2888 'getUniqueId', 'accountCreationType', 'getAuthenticationRequests',
2889 'providerAllowsAuthenticationDataChange',
2891 ->getMockForAbstractClass();
2892 $mocks["primary-$type"]->expects( $this->any() )->method( 'getUniqueId' )
2893 ->will( $this->returnValue( "primary-$type" ) );
2894 $mocks["primary-$type"]->expects( $this->any() )->method( 'accountCreationType' )
2895 ->will( $this->returnValue( $type ) );
2896 $mocks["primary-$type"]->expects( $this->any() )->method( 'getAuthenticationRequests' )
2897 ->will( $this->returnCallback( function ( $action ) use ( $type, $makeReq ) {
2898 return [ $makeReq( "primary-$type-$action" ), $makeReq( 'generic' ) ];
2900 $mocks["primary-$type"]->expects( $this->any() )
2901 ->method( 'providerAllowsAuthenticationDataChange' )
2902 ->will( $this->returnValue( $good ) );
2903 $this->primaryauthMocks
[] = $mocks["primary-$type"];
2906 $mocks['primary2'] = $this->getMockBuilder( PrimaryAuthenticationProvider
::class )
2908 'getUniqueId', 'accountCreationType', 'getAuthenticationRequests',
2909 'providerAllowsAuthenticationDataChange',
2911 ->getMockForAbstractClass();
2912 $mocks['primary2']->expects( $this->any() )->method( 'getUniqueId' )
2913 ->will( $this->returnValue( 'primary2' ) );
2914 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
2915 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
2916 $mocks['primary2']->expects( $this->any() )->method( 'getAuthenticationRequests' )
2917 ->will( $this->returnValue( [] ) );
2918 $mocks['primary2']->expects( $this->any() )
2919 ->method( 'providerAllowsAuthenticationDataChange' )
2920 ->will( $this->returnCallback( function ( $req ) use ( $good ) {
2921 return $req->key
=== 'generic' ? StatusValue
::newFatal( 'no' ) : $good;
2923 $this->primaryauthMocks
[] = $mocks['primary2'];
2925 $this->preauthMocks
= [ $mocks['pre'] ];
2926 $this->secondaryauthMocks
= [ $mocks['secondary'] ];
2927 $this->initializeManager( true );
2930 if ( isset( $state['continueRequests'] ) ) {
2931 $state['continueRequests'] = array_map( $makeReq, $state['continueRequests'] );
2933 if ( $action === AuthManager
::ACTION_LOGIN_CONTINUE
) {
2934 $this->request
->getSession()->setSecret( 'AuthManager::authnState', $state );
2935 } elseif ( $action === AuthManager
::ACTION_CREATE_CONTINUE
) {
2936 $this->request
->getSession()->setSecret( 'AuthManager::accountCreationState', $state );
2937 } elseif ( $action === AuthManager
::ACTION_LINK_CONTINUE
) {
2938 $this->request
->getSession()->setSecret( 'AuthManager::accountLinkState', $state );
2942 $expectReqs = array_map( $makeReq, $expect );
2943 if ( $action === AuthManager
::ACTION_LOGIN
) {
2944 $req = new RememberMeAuthenticationRequest
;
2945 $req->action
= $action;
2946 $req->required
= AuthenticationRequest
::REQUIRED
;
2947 $expectReqs[] = $req;
2948 } elseif ( $action === AuthManager
::ACTION_CREATE
) {
2949 $req = new UsernameAuthenticationRequest
;
2950 $req->action
= $action;
2951 $expectReqs[] = $req;
2952 $req = new UserDataAuthenticationRequest
;
2953 $req->action
= $action;
2954 $req->required
= AuthenticationRequest
::REQUIRED
;
2955 $expectReqs[] = $req;
2957 usort( $expectReqs, $cmpReqs );
2959 $actual = $this->manager
->getAuthenticationRequests( $action );
2960 foreach ( $actual as $req ) {
2961 // Don't test this here.
2962 $req->required
= AuthenticationRequest
::REQUIRED
;
2964 usort( $actual, $cmpReqs );
2966 $this->assertEquals( $expectReqs, $actual );
2968 // Test CreationReasonAuthenticationRequest gets returned
2969 if ( $action === AuthManager
::ACTION_CREATE
) {
2970 $req = new CreationReasonAuthenticationRequest
;
2971 $req->action
= $action;
2972 $req->required
= AuthenticationRequest
::REQUIRED
;
2973 $expectReqs[] = $req;
2974 usort( $expectReqs, $cmpReqs );
2976 $actual = $this->manager
->getAuthenticationRequests( $action, \User
::newFromName( 'UTSysop' ) );
2977 foreach ( $actual as $req ) {
2978 // Don't test this here.
2979 $req->required
= AuthenticationRequest
::REQUIRED
;
2981 usort( $actual, $cmpReqs );
2983 $this->assertEquals( $expectReqs, $actual );
2987 public static function provideGetAuthenticationRequests() {
2990 AuthManager
::ACTION_LOGIN
,
2991 [ 'pre-login', 'primary-none-login', 'primary-create-login',
2992 'primary-link-login', 'secondary-login', 'generic' ],
2995 AuthManager
::ACTION_CREATE
,
2996 [ 'pre-create', 'primary-none-create', 'primary-create-create',
2997 'primary-link-create', 'secondary-create', 'generic' ],
3000 AuthManager
::ACTION_LINK
,
3001 [ 'primary-link-link', 'generic' ],
3004 AuthManager
::ACTION_CHANGE
,
3005 [ 'primary-none-change', 'primary-create-change', 'primary-link-change',
3006 'secondary-change' ],
3009 AuthManager
::ACTION_REMOVE
,
3010 [ 'primary-none-remove', 'primary-create-remove', 'primary-link-remove',
3011 'secondary-remove' ],
3014 AuthManager
::ACTION_UNLINK
,
3015 [ 'primary-link-remove' ],
3018 AuthManager
::ACTION_LOGIN_CONTINUE
,
3022 AuthManager
::ACTION_LOGIN_CONTINUE
,
3023 $reqs = [ 'continue-login', 'foo', 'bar' ],
3025 'continueRequests' => $reqs,
3029 AuthManager
::ACTION_CREATE_CONTINUE
,
3033 AuthManager
::ACTION_CREATE_CONTINUE
,
3034 $reqs = [ 'continue-create', 'foo', 'bar' ],
3036 'continueRequests' => $reqs,
3040 AuthManager
::ACTION_LINK_CONTINUE
,
3044 AuthManager
::ACTION_LINK_CONTINUE
,
3045 $reqs = [ 'continue-link', 'foo', 'bar' ],
3047 'continueRequests' => $reqs,
3053 public function testGetAuthenticationRequestsRequired() {
3054 $makeReq = function ( $key, $required ) {
3055 $req = $this->createMock( AuthenticationRequest
::class );
3056 $req->expects( $this->any() )->method( 'getUniqueId' )
3057 ->will( $this->returnValue( $key ) );
3058 $req->action
= AuthManager
::ACTION_LOGIN
;
3060 $req->required
= $required;
3063 $cmpReqs = function ( $a, $b ) {
3064 $ret = strcmp( get_class( $a ), get_class( $b ) );
3066 $ret = strcmp( $a->key
, $b->key
);
3071 $good = StatusValue
::newGood();
3073 $primary1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3074 $primary1->expects( $this->any() )->method( 'getUniqueId' )
3075 ->will( $this->returnValue( 'primary1' ) );
3076 $primary1->expects( $this->any() )->method( 'accountCreationType' )
3077 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
3078 $primary1->expects( $this->any() )->method( 'getAuthenticationRequests' )
3079 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3081 $makeReq( "primary-shared", AuthenticationRequest
::REQUIRED
),
3082 $makeReq( "required", AuthenticationRequest
::REQUIRED
),
3083 $makeReq( "optional", AuthenticationRequest
::OPTIONAL
),
3084 $makeReq( "foo", AuthenticationRequest
::REQUIRED
),
3085 $makeReq( "bar", AuthenticationRequest
::REQUIRED
),
3086 $makeReq( "baz", AuthenticationRequest
::OPTIONAL
),
3090 $primary2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3091 $primary2->expects( $this->any() )->method( 'getUniqueId' )
3092 ->will( $this->returnValue( 'primary2' ) );
3093 $primary2->expects( $this->any() )->method( 'accountCreationType' )
3094 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
3095 $primary2->expects( $this->any() )->method( 'getAuthenticationRequests' )
3096 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3098 $makeReq( "primary-shared", AuthenticationRequest
::REQUIRED
),
3099 $makeReq( "required2", AuthenticationRequest
::REQUIRED
),
3100 $makeReq( "optional2", AuthenticationRequest
::OPTIONAL
),
3104 $secondary = $this->getMockForAbstractClass( SecondaryAuthenticationProvider
::class );
3105 $secondary->expects( $this->any() )->method( 'getUniqueId' )
3106 ->will( $this->returnValue( 'secondary' ) );
3107 $secondary->expects( $this->any() )->method( 'getAuthenticationRequests' )
3108 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3110 $makeReq( "foo", AuthenticationRequest
::OPTIONAL
),
3111 $makeReq( "bar", AuthenticationRequest
::REQUIRED
),
3112 $makeReq( "baz", AuthenticationRequest
::REQUIRED
),
3116 $rememberReq = new RememberMeAuthenticationRequest
;
3117 $rememberReq->action
= AuthManager
::ACTION_LOGIN
;
3119 $this->primaryauthMocks
= [ $primary1, $primary2 ];
3120 $this->secondaryauthMocks
= [ $secondary ];
3121 $this->initializeManager( true );
3123 $actual = $this->manager
->getAuthenticationRequests( AuthManager
::ACTION_LOGIN
);
3126 $makeReq( "primary-shared", AuthenticationRequest
::PRIMARY_REQUIRED
),
3127 $makeReq( "required", AuthenticationRequest
::PRIMARY_REQUIRED
),
3128 $makeReq( "required2", AuthenticationRequest
::PRIMARY_REQUIRED
),
3129 $makeReq( "optional", AuthenticationRequest
::OPTIONAL
),
3130 $makeReq( "optional2", AuthenticationRequest
::OPTIONAL
),
3131 $makeReq( "foo", AuthenticationRequest
::PRIMARY_REQUIRED
),
3132 $makeReq( "bar", AuthenticationRequest
::REQUIRED
),
3133 $makeReq( "baz", AuthenticationRequest
::REQUIRED
),
3135 usort( $actual, $cmpReqs );
3136 usort( $expected, $cmpReqs );
3137 $this->assertEquals( $expected, $actual );
3139 $this->primaryauthMocks
= [ $primary1 ];
3140 $this->secondaryauthMocks
= [ $secondary ];
3141 $this->initializeManager( true );
3143 $actual = $this->manager
->getAuthenticationRequests( AuthManager
::ACTION_LOGIN
);
3146 $makeReq( "primary-shared", AuthenticationRequest
::PRIMARY_REQUIRED
),
3147 $makeReq( "required", AuthenticationRequest
::PRIMARY_REQUIRED
),
3148 $makeReq( "optional", AuthenticationRequest
::OPTIONAL
),
3149 $makeReq( "foo", AuthenticationRequest
::PRIMARY_REQUIRED
),
3150 $makeReq( "bar", AuthenticationRequest
::REQUIRED
),
3151 $makeReq( "baz", AuthenticationRequest
::REQUIRED
),
3153 usort( $actual, $cmpReqs );
3154 usort( $expected, $cmpReqs );
3155 $this->assertEquals( $expected, $actual );
3158 public function testAllowsPropertyChange() {
3160 foreach ( [ 'primary', 'secondary' ] as $key ) {
3161 $class = ucfirst( $key ) . 'AuthenticationProvider';
3162 $mocks[$key] = $this->getMockForAbstractClass( "MediaWiki\\Auth\\$class" );
3163 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
3164 ->will( $this->returnValue( $key ) );
3165 $mocks[$key]->expects( $this->any() )->method( 'providerAllowsPropertyChange' )
3166 ->will( $this->returnCallback( function ( $prop ) use ( $key ) {
3167 return $prop !== $key;
3171 $this->primaryauthMocks
= [ $mocks['primary'] ];
3172 $this->secondaryauthMocks
= [ $mocks['secondary'] ];
3173 $this->initializeManager( true );
3175 $this->assertTrue( $this->manager
->allowsPropertyChange( 'foo' ) );
3176 $this->assertFalse( $this->manager
->allowsPropertyChange( 'primary' ) );
3177 $this->assertFalse( $this->manager
->allowsPropertyChange( 'secondary' ) );
3180 public function testAutoCreateOnLogin() {
3181 $username = self
::usernameForCreation();
3183 $req = $this->createMock( AuthenticationRequest
::class );
3185 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3186 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'primary' ) );
3187 $mock->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
3188 ->will( $this->returnValue( AuthenticationResponse
::newPass( $username ) ) );
3189 $mock->expects( $this->any() )->method( 'accountCreationType' )
3190 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
3191 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
3192 $mock->expects( $this->any() )->method( 'testUserForCreation' )
3193 ->will( $this->returnValue( StatusValue
::newGood() ) );
3195 $mock2 = $this->getMockForAbstractClass( SecondaryAuthenticationProvider
::class );
3196 $mock2->expects( $this->any() )->method( 'getUniqueId' )
3197 ->will( $this->returnValue( 'secondary' ) );
3198 $mock2->expects( $this->any() )->method( 'beginSecondaryAuthentication' )->will(
3200 AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) )
3203 $mock2->expects( $this->any() )->method( 'continueSecondaryAuthentication' )
3204 ->will( $this->returnValue( AuthenticationResponse
::newAbstain() ) );
3205 $mock2->expects( $this->any() )->method( 'testUserForCreation' )
3206 ->will( $this->returnValue( StatusValue
::newGood() ) );
3208 $this->primaryauthMocks
= [ $mock ];
3209 $this->secondaryauthMocks
= [ $mock2 ];
3210 $this->initializeManager( true );
3211 $this->manager
->setLogger( new \Psr\Log\
NullLogger() );
3212 $session = $this->request
->getSession();
3215 $this->assertSame( 0, \User
::newFromName( $username )->getId(),
3218 $callback = $this->callback( function ( $user ) use ( $username ) {
3219 return $user->getName() === $username;
3222 $this->hook( 'UserLoggedIn', $this->never() );
3223 $this->hook( 'LocalUserCreated', $this->once() )->with( $callback, $this->equalTo( true ) );
3224 $ret = $this->manager
->beginAuthentication( [], 'http://localhost/' );
3225 $this->unhook( 'LocalUserCreated' );
3226 $this->unhook( 'UserLoggedIn' );
3227 $this->assertSame( AuthenticationResponse
::UI
, $ret->status
);
3229 $id = (int)\User
::newFromName( $username )->getId();
3230 $this->assertNotSame( 0, \User
::newFromName( $username )->getId() );
3231 $this->assertSame( 0, $session->getUser()->getId() );
3233 $this->hook( 'UserLoggedIn', $this->once() )->with( $callback );
3234 $this->hook( 'LocalUserCreated', $this->never() );
3235 $ret = $this->manager
->continueAuthentication( [] );
3236 $this->unhook( 'LocalUserCreated' );
3237 $this->unhook( 'UserLoggedIn' );
3238 $this->assertSame( AuthenticationResponse
::PASS
, $ret->status
);
3239 $this->assertSame( $username, $ret->username
);
3240 $this->assertSame( $id, $session->getUser()->getId() );
3243 public function testAutoCreateFailOnLogin() {
3244 $username = self
::usernameForCreation();
3246 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3247 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'primary' ) );
3248 $mock->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
3249 ->will( $this->returnValue( AuthenticationResponse
::newPass( $username ) ) );
3250 $mock->expects( $this->any() )->method( 'accountCreationType' )
3251 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
3252 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
3253 $mock->expects( $this->any() )->method( 'testUserForCreation' )
3254 ->will( $this->returnValue( StatusValue
::newFatal( 'fail-from-primary' ) ) );
3256 $this->primaryauthMocks
= [ $mock ];
3257 $this->initializeManager( true );
3258 $this->manager
->setLogger( new \Psr\Log\
NullLogger() );
3259 $session = $this->request
->getSession();
3262 $this->assertSame( 0, $session->getUser()->getId(),
3264 $this->assertSame( 0, \User
::newFromName( $username )->getId(),
3267 $this->hook( 'UserLoggedIn', $this->never() );
3268 $this->hook( 'LocalUserCreated', $this->never() );
3269 $ret = $this->manager
->beginAuthentication( [], 'http://localhost/' );
3270 $this->unhook( 'LocalUserCreated' );
3271 $this->unhook( 'UserLoggedIn' );
3272 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
3273 $this->assertSame( 'authmanager-authn-autocreate-failed', $ret->message
->getKey() );
3275 $this->assertSame( 0, \User
::newFromName( $username )->getId() );
3276 $this->assertSame( 0, $session->getUser()->getId() );
3279 public function testAuthenticationSessionData() {
3280 $this->initializeManager( true );
3282 $this->assertNull( $this->manager
->getAuthenticationSessionData( 'foo' ) );
3283 $this->manager
->setAuthenticationSessionData( 'foo', 'foo!' );
3284 $this->manager
->setAuthenticationSessionData( 'bar', 'bar!' );
3285 $this->assertSame( 'foo!', $this->manager
->getAuthenticationSessionData( 'foo' ) );
3286 $this->assertSame( 'bar!', $this->manager
->getAuthenticationSessionData( 'bar' ) );
3287 $this->manager
->removeAuthenticationSessionData( 'foo' );
3288 $this->assertNull( $this->manager
->getAuthenticationSessionData( 'foo' ) );
3289 $this->assertSame( 'bar!', $this->manager
->getAuthenticationSessionData( 'bar' ) );
3290 $this->manager
->removeAuthenticationSessionData( 'bar' );
3291 $this->assertNull( $this->manager
->getAuthenticationSessionData( 'bar' ) );
3293 $this->manager
->setAuthenticationSessionData( 'foo', 'foo!' );
3294 $this->manager
->setAuthenticationSessionData( 'bar', 'bar!' );
3295 $this->manager
->removeAuthenticationSessionData( null );
3296 $this->assertNull( $this->manager
->getAuthenticationSessionData( 'foo' ) );
3297 $this->assertNull( $this->manager
->getAuthenticationSessionData( 'bar' ) );
3300 public function testCanLinkAccounts() {
3302 PrimaryAuthenticationProvider
::TYPE_CREATE
=> true,
3303 PrimaryAuthenticationProvider
::TYPE_LINK
=> true,
3304 PrimaryAuthenticationProvider
::TYPE_NONE
=> false,
3307 foreach ( $types as $type => $can ) {
3308 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3309 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $type ) );
3310 $mock->expects( $this->any() )->method( 'accountCreationType' )
3311 ->will( $this->returnValue( $type ) );
3312 $this->primaryauthMocks
= [ $mock ];
3313 $this->initializeManager( true );
3314 $this->assertSame( $can, $this->manager
->canCreateAccounts(), $type );
3318 public function testBeginAccountLink() {
3319 $user = \User
::newFromName( 'UTSysop' );
3320 $this->initializeManager();
3322 $this->request
->getSession()->setSecret( 'AuthManager::accountLinkState', 'test' );
3324 $this->manager
->beginAccountLink( $user, [], 'http://localhost/' );
3325 $this->fail( 'Expected exception not thrown' );
3326 } catch ( \LogicException
$ex ) {
3327 $this->assertEquals( 'Account linking is not possible', $ex->getMessage() );
3329 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3331 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3332 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
3333 $mock->expects( $this->any() )->method( 'accountCreationType' )
3334 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
3335 $this->primaryauthMocks
= [ $mock ];
3336 $this->initializeManager( true );
3338 $ret = $this->manager
->beginAccountLink( new \User
, [], 'http://localhost/' );
3339 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
3340 $this->assertSame( 'noname', $ret->message
->getKey() );
3342 $ret = $this->manager
->beginAccountLink(
3343 \User
::newFromName( 'UTDoesNotExist' ), [], 'http://localhost/'
3345 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
3346 $this->assertSame( 'authmanager-userdoesnotexist', $ret->message
->getKey() );
3349 public function testContinueAccountLink() {
3350 $user = \User
::newFromName( 'UTSysop' );
3351 $this->initializeManager();
3354 'userid' => $user->getId(),
3355 'username' => $user->getName(),
3360 $this->manager
->continueAccountLink( [] );
3361 $this->fail( 'Expected exception not thrown' );
3362 } catch ( \LogicException
$ex ) {
3363 $this->assertEquals( 'Account linking is not possible', $ex->getMessage() );
3366 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider
::class );
3367 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
3368 $mock->expects( $this->any() )->method( 'accountCreationType' )
3369 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
3370 $mock->expects( $this->any() )->method( 'beginPrimaryAccountLink' )->will(
3371 $this->returnValue( AuthenticationResponse
::newFail( $this->message( 'fail' ) ) )
3373 $this->primaryauthMocks
= [ $mock ];
3374 $this->initializeManager( true );
3376 $this->request
->getSession()->setSecret( 'AuthManager::accountLinkState', null );
3377 $ret = $this->manager
->continueAccountLink( [] );
3378 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
3379 $this->assertSame( 'authmanager-link-not-in-progress', $ret->message
->getKey() );
3381 $this->request
->getSession()->setSecret( 'AuthManager::accountLinkState',
3382 [ 'username' => $user->getName() . '<>' ] +
$session );
3383 $ret = $this->manager
->continueAccountLink( [] );
3384 $this->assertSame( AuthenticationResponse
::FAIL
, $ret->status
);
3385 $this->assertSame( 'noname', $ret->message
->getKey() );
3386 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3388 $id = $user->getId();
3389 $this->request
->getSession()->setSecret( 'AuthManager::accountLinkState',
3390 [ 'userid' => $id +
1 ] +
$session );
3392 $ret = $this->manager
->continueAccountLink( [] );
3393 $this->fail( 'Expected exception not thrown' );
3394 } catch ( \UnexpectedValueException
$ex ) {
3395 $this->assertEquals(
3396 "User \"{$user->getName()}\" is valid, but ID $id !== " . ( $id +
1 ) . '!',
3400 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3404 * @dataProvider provideAccountLink
3405 * @param StatusValue $preTest
3406 * @param array $primaryResponses
3407 * @param array $managerResponses
3409 public function testAccountLink(
3410 StatusValue
$preTest, array $primaryResponses, array $managerResponses
3412 $user = \User
::newFromName( 'UTSysop' );
3414 $this->initializeManager();
3416 // Set up lots of mocks...
3417 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
3418 $req->primary
= $primaryResponses;
3421 foreach ( [ 'pre', 'primary' ] as $key ) {
3422 $class = ucfirst( $key ) . 'AuthenticationProvider';
3423 $mocks[$key] = $this->getMockForAbstractClass(
3424 "MediaWiki\\Auth\\$class", [], "Mock$class"
3426 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
3427 ->will( $this->returnValue( $key ) );
3429 for ( $i = 2; $i <= 3; $i++
) {
3430 $mocks[$key . $i] = $this->getMockForAbstractClass(
3431 "MediaWiki\\Auth\\$class", [], "Mock$class"
3433 $mocks[$key . $i]->expects( $this->any() )->method( 'getUniqueId' )
3434 ->will( $this->returnValue( $key . $i ) );
3438 $mocks['pre']->expects( $this->any() )->method( 'testForAccountLink' )
3439 ->will( $this->returnCallback(
3441 use ( $user, $preTest )
3443 $this->assertSame( $user->getId(), $u->getId() );
3444 $this->assertSame( $user->getName(), $u->getName() );
3449 $mocks['pre2']->expects( $this->atMost( 1 ) )->method( 'testForAccountLink' )
3450 ->will( $this->returnValue( StatusValue
::newGood() ) );
3452 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
3453 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
3454 $ct = count( $req->primary
);
3455 $callback = $this->returnCallback( function ( $u, $reqs ) use ( $user, $req ) {
3456 $this->assertSame( $user->getId(), $u->getId() );
3457 $this->assertSame( $user->getName(), $u->getName() );
3459 foreach ( $reqs as $r ) {
3460 $this->assertSame( $user->getName(), $r->username
);
3461 $foundReq = $foundReq ||
get_class( $r ) === get_class( $req );
3463 $this->assertTrue( $foundReq, '$reqs contains $req' );
3464 return array_shift( $req->primary
);
3466 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
3467 ->method( 'beginPrimaryAccountLink' )
3468 ->will( $callback );
3469 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
3470 ->method( 'continuePrimaryAccountLink' )
3471 ->will( $callback );
3473 $abstain = AuthenticationResponse
::newAbstain();
3474 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
3475 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_LINK
) );
3476 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAccountLink' )
3477 ->will( $this->returnValue( $abstain ) );
3478 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAccountLink' );
3479 $mocks['primary3']->expects( $this->any() )->method( 'accountCreationType' )
3480 ->will( $this->returnValue( PrimaryAuthenticationProvider
::TYPE_CREATE
) );
3481 $mocks['primary3']->expects( $this->never() )->method( 'beginPrimaryAccountLink' );
3482 $mocks['primary3']->expects( $this->never() )->method( 'continuePrimaryAccountLink' );
3484 $this->preauthMocks
= [ $mocks['pre'], $mocks['pre2'] ];
3485 $this->primaryauthMocks
= [ $mocks['primary3'], $mocks['primary2'], $mocks['primary'] ];
3486 $this->logger
= new \
TestLogger( true, function ( $message, $level ) {
3487 return $level === LogLevel
::DEBUG ?
null : $message;
3489 $this->initializeManager( true );
3491 $constraint = \PHPUnit_Framework_Assert
::logicalOr(
3492 $this->equalTo( AuthenticationResponse
::PASS
),
3493 $this->equalTo( AuthenticationResponse
::FAIL
)
3495 $providers = array_merge( $this->preauthMocks
, $this->primaryauthMocks
);
3496 foreach ( $providers as $p ) {
3497 $p->postCalled
= false;
3498 $p->expects( $this->atMost( 1 ) )->method( 'postAccountLink' )
3499 ->willReturnCallback( function ( $user, $response ) use ( $constraint, $p ) {
3500 $this->assertInstanceOf( \User
::class, $user );
3501 $this->assertSame( 'UTSysop', $user->getName() );
3502 $this->assertInstanceOf( AuthenticationResponse
::class, $response );
3503 $this->assertThat( $response->status
, $constraint );
3504 $p->postCalled
= $response->status
;
3511 foreach ( $managerResponses as $i => $response ) {
3512 if ( $response instanceof AuthenticationResponse
&&
3513 $response->status
=== AuthenticationResponse
::PASS
3515 $expectLog[] = [ LogLevel
::INFO
, 'Account linked to {user} by primary' ];
3521 $ret = $this->manager
->beginAccountLink( $user, [ $req ], 'http://localhost/' );
3523 $ret = $this->manager
->continueAccountLink( [ $req ] );
3525 if ( $response instanceof \Exception
) {
3526 $this->fail( 'Expected exception not thrown', "Response $i" );
3528 } catch ( \Exception
$ex ) {
3529 if ( !$response instanceof \Exception
) {
3532 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
3533 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3534 "Response $i, exception, session state" );
3538 $this->assertSame( 'http://localhost/', $req->returnToUrl
);
3540 $ret->message
= $this->message( $ret->message
);
3541 $this->assertResponseEquals( $response, $ret, "Response $i, response" );
3542 if ( $response->status
=== AuthenticationResponse
::PASS ||
3543 $response->status
=== AuthenticationResponse
::FAIL
3545 $this->assertNull( $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3546 "Response $i, session state" );
3547 foreach ( $providers as $p ) {
3548 $this->assertSame( $response->status
, $p->postCalled
,
3549 "Response $i, post-auth callback called" );
3552 $this->assertNotNull(
3553 $this->request
->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3554 "Response $i, session state"
3556 foreach ( $ret->neededRequests
as $neededReq ) {
3557 $this->assertEquals( AuthManager
::ACTION_LINK
, $neededReq->action
,
3558 "Response $i, neededRequest action" );
3560 $this->assertEquals(
3561 $ret->neededRequests
,
3562 $this->manager
->getAuthenticationRequests( AuthManager
::ACTION_LINK_CONTINUE
),
3563 "Response $i, continuation check"
3565 foreach ( $providers as $p ) {
3566 $this->assertFalse( $p->postCalled
, "Response $i, post-auth callback not called" );
3573 $this->assertSame( $expectLog, $this->logger
->getBuffer() );
3576 public function provideAccountLink() {
3577 $req = $this->getMockForAbstractClass( AuthenticationRequest
::class );
3578 $good = StatusValue
::newGood();
3581 'Pre-link test fail in pre' => [
3582 StatusValue
::newFatal( 'fail-from-pre' ),
3585 AuthenticationResponse
::newFail( $this->message( 'fail-from-pre' ) ),
3588 'Failure in primary' => [
3591 AuthenticationResponse
::newFail( $this->message( 'fail-from-primary' ) ),
3595 'All primary abstain' => [
3598 AuthenticationResponse
::newAbstain(),
3601 AuthenticationResponse
::newFail( $this->message( 'authmanager-link-no-primary' ) )
3604 'Primary UI, then redirect, then fail' => [
3607 AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
3608 AuthenticationResponse
::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
3609 AuthenticationResponse
::newFail( $this->message( 'fail-in-primary-continue' ) ),
3613 'Primary redirect, then abstain' => [
3616 $tmp = AuthenticationResponse
::newRedirect(
3617 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
3619 AuthenticationResponse
::newAbstain(),
3623 new \
DomainException(
3624 'MockPrimaryAuthenticationProvider::continuePrimaryAccountLink() returned ABSTAIN'
3628 'Primary UI, then pass' => [
3631 $tmp1 = AuthenticationResponse
::newUI( [ $req ], $this->message( '...' ) ),
3632 AuthenticationResponse
::newPass(),
3636 AuthenticationResponse
::newPass( '' ),
3642 AuthenticationResponse
::newPass( '' ),
3645 AuthenticationResponse
::newPass( '' ),