dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge "mw.widgets.Complex*: Fix setDisabled"
[lhc/web/wiklou.git] / tests / phpunit / includes / auth / AuthManagerTest.php
1 <?php
2
3 namespace MediaWiki\Auth;
4
5 use MediaWiki\Session\SessionInfo;
6 use MediaWiki\Session\UserInfo;
7 use Psr\Log\LogLevel;
8 use StatusValue;
9 use Wikimedia\ScopedCallback;
10
11 /**
12 * @group AuthManager
13 * @group Database
14 * @covers MediaWiki\Auth\AuthManager
15 */
16 class AuthManagerTest extends \MediaWikiTestCase {
17 /** @var WebRequest */
18 protected $request;
19 /** @var Config */
20 protected $config;
21 /** @var \\Psr\\Log\\LoggerInterface */
22 protected $logger;
23
24 protected $preauthMocks = [];
25 protected $primaryauthMocks = [];
26 protected $secondaryauthMocks = [];
27
28 /** @var AuthManager */
29 protected $manager;
30 /** @var TestingAccessWrapper */
31 protected $managerPriv;
32
33 protected function setUp() {
34 parent::setUp();
35
36 $this->setMwGlobals( [ 'wgAuth' => null ] );
37 $this->stashMwGlobals( [ 'wgHooks' ] );
38 }
39
40 /**
41 * Sets a mock on a hook
42 * @param string $hook
43 * @param object $expect From $this->once(), $this->never(), etc.
44 * @return object $mock->expects( $expect )->method( ... ).
45 */
46 protected function hook( $hook, $expect ) {
47 global $wgHooks;
48 $mock = $this->getMockBuilder( __CLASS__ )
49 ->setMethods( [ "on$hook" ] )
50 ->getMock();
51 $wgHooks[$hook] = [ $mock ];
52 return $mock->expects( $expect )->method( "on$hook" );
53 }
54
55 /**
56 * Unsets a hook
57 * @param string $hook
58 */
59 protected function unhook( $hook ) {
60 global $wgHooks;
61 $wgHooks[$hook] = [];
62 }
63
64 /**
65 * Ensure a value is a clean Message object
66 * @param string|Message $key
67 * @param array $params
68 * @return Message
69 */
70 protected function message( $key, $params = [] ) {
71 if ( $key === null ) {
72 return null;
73 }
74 if ( $key instanceof \MessageSpecifier ) {
75 $params = $key->getParams();
76 $key = $key->getKey();
77 }
78 return new \Message( $key, $params, \Language::factory( 'en' ) );
79 }
80
81 /**
82 * Initialize the AuthManagerConfig variable in $this->config
83 *
84 * Uses data from the various 'mocks' fields.
85 */
86 protected function initializeConfig() {
87 $config = [
88 'preauth' => [
89 ],
90 'primaryauth' => [
91 ],
92 'secondaryauth' => [
93 ],
94 ];
95
96 foreach ( [ 'preauth', 'primaryauth', 'secondaryauth' ] as $type ) {
97 $key = $type . 'Mocks';
98 foreach ( $this->$key as $mock ) {
99 $config[$type][$mock->getUniqueId()] = [ 'factory' => function () use ( $mock ) {
100 return $mock;
101 } ];
102 }
103 }
104
105 $this->config->set( 'AuthManagerConfig', $config );
106 $this->config->set( 'LanguageCode', 'en' );
107 $this->config->set( 'NewUserLog', false );
108 }
109
110 /**
111 * Initialize $this->manager
112 * @param bool $regen Force a call to $this->initializeConfig()
113 */
114 protected function initializeManager( $regen = false ) {
115 if ( $regen || !$this->config ) {
116 $this->config = new \HashConfig();
117 }
118 if ( $regen || !$this->request ) {
119 $this->request = new \FauxRequest();
120 }
121 if ( !$this->logger ) {
122 $this->logger = new \TestLogger();
123 }
124
125 if ( $regen || !$this->config->has( 'AuthManagerConfig' ) ) {
126 $this->initializeConfig();
127 }
128 $this->manager = new AuthManager( $this->request, $this->config );
129 $this->manager->setLogger( $this->logger );
130 $this->managerPriv = \TestingAccessWrapper::newFromObject( $this->manager );
131 }
132
133 /**
134 * Setup SessionManager with a mock session provider
135 * @param bool|null $canChangeUser If non-null, canChangeUser will be mocked to return this
136 * @param array $methods Additional methods to mock
137 * @return array (MediaWiki\Session\SessionProvider, ScopedCallback)
138 */
139 protected function getMockSessionProvider( $canChangeUser = null, array $methods = [] ) {
140 if ( !$this->config ) {
141 $this->config = new \HashConfig();
142 $this->initializeConfig();
143 }
144 $this->config->set( 'ObjectCacheSessionExpiry', 100 );
145
146 $methods[] = '__toString';
147 $methods[] = 'describe';
148 if ( $canChangeUser !== null ) {
149 $methods[] = 'canChangeUser';
150 }
151 $provider = $this->getMockBuilder( 'DummySessionProvider' )
152 ->setMethods( $methods )
153 ->getMock();
154 $provider->expects( $this->any() )->method( '__toString' )
155 ->will( $this->returnValue( 'MockSessionProvider' ) );
156 $provider->expects( $this->any() )->method( 'describe' )
157 ->will( $this->returnValue( 'MockSessionProvider sessions' ) );
158 if ( $canChangeUser !== null ) {
159 $provider->expects( $this->any() )->method( 'canChangeUser' )
160 ->will( $this->returnValue( $canChangeUser ) );
161 }
162 $this->config->set( 'SessionProviders', [
163 [ 'factory' => function () use ( $provider ) {
164 return $provider;
165 } ],
166 ] );
167
168 $manager = new \MediaWiki\Session\SessionManager( [
169 'config' => $this->config,
170 'logger' => new \Psr\Log\NullLogger(),
171 'store' => new \HashBagOStuff(),
172 ] );
173 \TestingAccessWrapper::newFromObject( $manager )->getProvider( (string)$provider );
174
175 $reset = \MediaWiki\Session\TestUtils::setSessionManagerSingleton( $manager );
176
177 if ( $this->request ) {
178 $manager->getSessionForRequest( $this->request );
179 }
180
181 return [ $provider, $reset ];
182 }
183
184 public function testSingleton() {
185 // Temporarily clear out the global singleton, if any, to test creating
186 // one.
187 $rProp = new \ReflectionProperty( AuthManager::class, 'instance' );
188 $rProp->setAccessible( true );
189 $old = $rProp->getValue();
190 $cb = new ScopedCallback( [ $rProp, 'setValue' ], [ $old ] );
191 $rProp->setValue( null );
192
193 $singleton = AuthManager::singleton();
194 $this->assertInstanceOf( AuthManager::class, AuthManager::singleton() );
195 $this->assertSame( $singleton, AuthManager::singleton() );
196 $this->assertSame( \RequestContext::getMain()->getRequest(), $singleton->getRequest() );
197 $this->assertSame(
198 \RequestContext::getMain()->getConfig(),
199 \TestingAccessWrapper::newFromObject( $singleton )->config
200 );
201 }
202
203 public function testCanAuthenticateNow() {
204 $this->initializeManager();
205
206 list( $provider, $reset ) = $this->getMockSessionProvider( false );
207 $this->assertFalse( $this->manager->canAuthenticateNow() );
208 ScopedCallback::consume( $reset );
209
210 list( $provider, $reset ) = $this->getMockSessionProvider( true );
211 $this->assertTrue( $this->manager->canAuthenticateNow() );
212 ScopedCallback::consume( $reset );
213 }
214
215 public function testNormalizeUsername() {
216 $mocks = [
217 $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class ),
218 $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class ),
219 $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class ),
220 $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class ),
221 ];
222 foreach ( $mocks as $key => $mock ) {
223 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $key ) );
224 }
225 $mocks[0]->expects( $this->once() )->method( 'providerNormalizeUsername' )
226 ->with( $this->identicalTo( 'XYZ' ) )
227 ->willReturn( 'Foo' );
228 $mocks[1]->expects( $this->once() )->method( 'providerNormalizeUsername' )
229 ->with( $this->identicalTo( 'XYZ' ) )
230 ->willReturn( 'Foo' );
231 $mocks[2]->expects( $this->once() )->method( 'providerNormalizeUsername' )
232 ->with( $this->identicalTo( 'XYZ' ) )
233 ->willReturn( null );
234 $mocks[3]->expects( $this->once() )->method( 'providerNormalizeUsername' )
235 ->with( $this->identicalTo( 'XYZ' ) )
236 ->willReturn( 'Bar!' );
237
238 $this->primaryauthMocks = $mocks;
239
240 $this->initializeManager();
241
242 $this->assertSame( [ 'Foo', 'Bar!' ], $this->manager->normalizeUsername( 'XYZ' ) );
243 }
244
245 /**
246 * @dataProvider provideSecuritySensitiveOperationStatus
247 * @param bool $mutableSession
248 */
249 public function testSecuritySensitiveOperationStatus( $mutableSession ) {
250 $this->logger = new \Psr\Log\NullLogger();
251 $user = \User::newFromName( 'UTSysop' );
252 $provideUser = null;
253 $reauth = $mutableSession ? AuthManager::SEC_REAUTH : AuthManager::SEC_FAIL;
254
255 list( $provider, $reset ) = $this->getMockSessionProvider(
256 $mutableSession, [ 'provideSessionInfo' ]
257 );
258 $provider->expects( $this->any() )->method( 'provideSessionInfo' )
259 ->will( $this->returnCallback( function () use ( $provider, &$provideUser ) {
260 return new SessionInfo( SessionInfo::MIN_PRIORITY, [
261 'provider' => $provider,
262 'id' => \DummySessionProvider::ID,
263 'persisted' => true,
264 'userInfo' => UserInfo::newFromUser( $provideUser, true )
265 ] );
266 } ) );
267 $this->initializeManager();
268
269 $this->config->set( 'ReauthenticateTime', [] );
270 $this->config->set( 'AllowSecuritySensitiveOperationIfCannotReauthenticate', [] );
271 $provideUser = new \User;
272 $session = $provider->getManager()->getSessionForRequest( $this->request );
273 $this->assertSame( 0, $session->getUser()->getId(), 'sanity check' );
274
275 // Anonymous user => reauth
276 $session->set( 'AuthManager:lastAuthId', 0 );
277 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
278 $this->assertSame( $reauth, $this->manager->securitySensitiveOperationStatus( 'foo' ) );
279
280 $provideUser = $user;
281 $session = $provider->getManager()->getSessionForRequest( $this->request );
282 $this->assertSame( $user->getId(), $session->getUser()->getId(), 'sanity check' );
283
284 // Error for no default (only gets thrown for non-anonymous user)
285 $session->set( 'AuthManager:lastAuthId', $user->getId() + 1 );
286 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
287 try {
288 $this->manager->securitySensitiveOperationStatus( 'foo' );
289 $this->fail( 'Expected exception not thrown' );
290 } catch ( \UnexpectedValueException $ex ) {
291 $this->assertSame(
292 $mutableSession
293 ? '$wgReauthenticateTime lacks a default'
294 : '$wgAllowSecuritySensitiveOperationIfCannotReauthenticate lacks a default',
295 $ex->getMessage()
296 );
297 }
298
299 if ( $mutableSession ) {
300 $this->config->set( 'ReauthenticateTime', [
301 'test' => 100,
302 'test2' => -1,
303 'default' => 10,
304 ] );
305
306 // Mismatched user ID
307 $session->set( 'AuthManager:lastAuthId', $user->getId() + 1 );
308 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
309 $this->assertSame(
310 AuthManager::SEC_REAUTH, $this->manager->securitySensitiveOperationStatus( 'foo' )
311 );
312 $this->assertSame(
313 AuthManager::SEC_REAUTH, $this->manager->securitySensitiveOperationStatus( 'test' )
314 );
315 $this->assertSame(
316 AuthManager::SEC_OK, $this->manager->securitySensitiveOperationStatus( 'test2' )
317 );
318
319 // Missing time
320 $session->set( 'AuthManager:lastAuthId', $user->getId() );
321 $session->set( 'AuthManager:lastAuthTimestamp', null );
322 $this->assertSame(
323 AuthManager::SEC_REAUTH, $this->manager->securitySensitiveOperationStatus( 'foo' )
324 );
325 $this->assertSame(
326 AuthManager::SEC_REAUTH, $this->manager->securitySensitiveOperationStatus( 'test' )
327 );
328 $this->assertSame(
329 AuthManager::SEC_OK, $this->manager->securitySensitiveOperationStatus( 'test2' )
330 );
331
332 // Recent enough to pass
333 $session->set( 'AuthManager:lastAuthTimestamp', time() - 5 );
334 $this->assertSame(
335 AuthManager::SEC_OK, $this->manager->securitySensitiveOperationStatus( 'foo' )
336 );
337
338 // Not recent enough to pass
339 $session->set( 'AuthManager:lastAuthTimestamp', time() - 20 );
340 $this->assertSame(
341 AuthManager::SEC_REAUTH, $this->manager->securitySensitiveOperationStatus( 'foo' )
342 );
343 // But recent enough for the 'test' operation
344 $this->assertSame(
345 AuthManager::SEC_OK, $this->manager->securitySensitiveOperationStatus( 'test' )
346 );
347 } else {
348 $this->config->set( 'AllowSecuritySensitiveOperationIfCannotReauthenticate', [
349 'test' => false,
350 'default' => true,
351 ] );
352
353 $this->assertEquals(
354 AuthManager::SEC_OK, $this->manager->securitySensitiveOperationStatus( 'foo' )
355 );
356
357 $this->assertEquals(
358 AuthManager::SEC_FAIL, $this->manager->securitySensitiveOperationStatus( 'test' )
359 );
360 }
361
362 // Test hook, all three possible values
363 foreach ( [
364 AuthManager::SEC_OK => AuthManager::SEC_OK,
365 AuthManager::SEC_REAUTH => $reauth,
366 AuthManager::SEC_FAIL => AuthManager::SEC_FAIL,
367 ] as $hook => $expect ) {
368 $this->hook( 'SecuritySensitiveOperationStatus', $this->exactly( 2 ) )
369 ->with(
370 $this->anything(),
371 $this->anything(),
372 $this->callback( function ( $s ) use ( $session ) {
373 return $s->getId() === $session->getId();
374 } ),
375 $mutableSession ? $this->equalTo( 500, 1 ) : $this->equalTo( -1 )
376 )
377 ->will( $this->returnCallback( function ( &$v ) use ( $hook ) {
378 $v = $hook;
379 return true;
380 } ) );
381 $session->set( 'AuthManager:lastAuthTimestamp', time() - 500 );
382 $this->assertEquals(
383 $expect, $this->manager->securitySensitiveOperationStatus( 'test' ), "hook $hook"
384 );
385 $this->assertEquals(
386 $expect, $this->manager->securitySensitiveOperationStatus( 'test2' ), "hook $hook"
387 );
388 $this->unhook( 'SecuritySensitiveOperationStatus' );
389 }
390
391 ScopedCallback::consume( $reset );
392 }
393
394 public function onSecuritySensitiveOperationStatus( &$status, $operation, $session, $time ) {
395 }
396
397 public static function provideSecuritySensitiveOperationStatus() {
398 return [
399 [ true ],
400 [ false ],
401 ];
402 }
403
404 /**
405 * @dataProvider provideUserCanAuthenticate
406 * @param bool $primary1Can
407 * @param bool $primary2Can
408 * @param bool $expect
409 */
410 public function testUserCanAuthenticate( $primary1Can, $primary2Can, $expect ) {
411 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
412 $mock1->expects( $this->any() )->method( 'getUniqueId' )
413 ->will( $this->returnValue( 'primary1' ) );
414 $mock1->expects( $this->any() )->method( 'testUserCanAuthenticate' )
415 ->with( $this->equalTo( 'UTSysop' ) )
416 ->will( $this->returnValue( $primary1Can ) );
417 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
418 $mock2->expects( $this->any() )->method( 'getUniqueId' )
419 ->will( $this->returnValue( 'primary2' ) );
420 $mock2->expects( $this->any() )->method( 'testUserCanAuthenticate' )
421 ->with( $this->equalTo( 'UTSysop' ) )
422 ->will( $this->returnValue( $primary2Can ) );
423 $this->primaryauthMocks = [ $mock1, $mock2 ];
424
425 $this->initializeManager( true );
426 $this->assertSame( $expect, $this->manager->userCanAuthenticate( 'UTSysop' ) );
427 }
428
429 public static function provideUserCanAuthenticate() {
430 return [
431 [ false, false, false ],
432 [ true, false, true ],
433 [ false, true, true ],
434 [ true, true, true ],
435 ];
436 }
437
438 public function testRevokeAccessForUser() {
439 $this->initializeManager();
440
441 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
442 $mock->expects( $this->any() )->method( 'getUniqueId' )
443 ->will( $this->returnValue( 'primary' ) );
444 $mock->expects( $this->once() )->method( 'providerRevokeAccessForUser' )
445 ->with( $this->equalTo( 'UTSysop' ) );
446 $this->primaryauthMocks = [ $mock ];
447
448 $this->initializeManager( true );
449 $this->logger->setCollect( true );
450
451 $this->manager->revokeAccessForUser( 'UTSysop' );
452
453 $this->assertSame( [
454 [ LogLevel::INFO, 'Revoking access for {user}' ],
455 ], $this->logger->getBuffer() );
456 }
457
458 public function testProviderCreation() {
459 $mocks = [
460 'pre' => $this->getMockForAbstractClass( PreAuthenticationProvider::class ),
461 'primary' => $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class ),
462 'secondary' => $this->getMockForAbstractClass( SecondaryAuthenticationProvider::class ),
463 ];
464 foreach ( $mocks as $key => $mock ) {
465 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $key ) );
466 $mock->expects( $this->once() )->method( 'setLogger' );
467 $mock->expects( $this->once() )->method( 'setManager' );
468 $mock->expects( $this->once() )->method( 'setConfig' );
469 }
470 $this->preauthMocks = [ $mocks['pre'] ];
471 $this->primaryauthMocks = [ $mocks['primary'] ];
472 $this->secondaryauthMocks = [ $mocks['secondary'] ];
473
474 // Normal operation
475 $this->initializeManager();
476 $this->assertSame(
477 $mocks['primary'],
478 $this->managerPriv->getAuthenticationProvider( 'primary' )
479 );
480 $this->assertSame(
481 $mocks['secondary'],
482 $this->managerPriv->getAuthenticationProvider( 'secondary' )
483 );
484 $this->assertSame(
485 $mocks['pre'],
486 $this->managerPriv->getAuthenticationProvider( 'pre' )
487 );
488 $this->assertSame(
489 [ 'pre' => $mocks['pre'] ],
490 $this->managerPriv->getPreAuthenticationProviders()
491 );
492 $this->assertSame(
493 [ 'primary' => $mocks['primary'] ],
494 $this->managerPriv->getPrimaryAuthenticationProviders()
495 );
496 $this->assertSame(
497 [ 'secondary' => $mocks['secondary'] ],
498 $this->managerPriv->getSecondaryAuthenticationProviders()
499 );
500
501 // Duplicate IDs
502 $mock1 = $this->getMockForAbstractClass( PreAuthenticationProvider::class );
503 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
504 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
505 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
506 $this->preauthMocks = [ $mock1 ];
507 $this->primaryauthMocks = [ $mock2 ];
508 $this->secondaryauthMocks = [];
509 $this->initializeManager( true );
510 try {
511 $this->managerPriv->getAuthenticationProvider( 'Y' );
512 $this->fail( 'Expected exception not thrown' );
513 } catch ( \RuntimeException $ex ) {
514 $class1 = get_class( $mock1 );
515 $class2 = get_class( $mock2 );
516 $this->assertSame(
517 "Duplicate specifications for id X (classes $class1 and $class2)", $ex->getMessage()
518 );
519 }
520
521 // Wrong classes
522 $mock = $this->getMockForAbstractClass( AuthenticationProvider::class );
523 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
524 $class = get_class( $mock );
525 $this->preauthMocks = [ $mock ];
526 $this->primaryauthMocks = [ $mock ];
527 $this->secondaryauthMocks = [ $mock ];
528 $this->initializeManager( true );
529 try {
530 $this->managerPriv->getPreAuthenticationProviders();
531 $this->fail( 'Expected exception not thrown' );
532 } catch ( \RuntimeException $ex ) {
533 $this->assertSame(
534 "Expected instance of MediaWiki\\Auth\\PreAuthenticationProvider, got $class",
535 $ex->getMessage()
536 );
537 }
538 try {
539 $this->managerPriv->getPrimaryAuthenticationProviders();
540 $this->fail( 'Expected exception not thrown' );
541 } catch ( \RuntimeException $ex ) {
542 $this->assertSame(
543 "Expected instance of MediaWiki\\Auth\\PrimaryAuthenticationProvider, got $class",
544 $ex->getMessage()
545 );
546 }
547 try {
548 $this->managerPriv->getSecondaryAuthenticationProviders();
549 $this->fail( 'Expected exception not thrown' );
550 } catch ( \RuntimeException $ex ) {
551 $this->assertSame(
552 "Expected instance of MediaWiki\\Auth\\SecondaryAuthenticationProvider, got $class",
553 $ex->getMessage()
554 );
555 }
556
557 // Sorting
558 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
559 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
560 $mock3 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
561 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'A' ) );
562 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
563 $mock3->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'C' ) );
564 $this->preauthMocks = [];
565 $this->primaryauthMocks = [ $mock1, $mock2, $mock3 ];
566 $this->secondaryauthMocks = [];
567 $this->initializeConfig();
568 $config = $this->config->get( 'AuthManagerConfig' );
569
570 $this->initializeManager( false );
571 $this->assertSame(
572 [ 'A' => $mock1, 'B' => $mock2, 'C' => $mock3 ],
573 $this->managerPriv->getPrimaryAuthenticationProviders(),
574 'sanity check'
575 );
576
577 $config['primaryauth']['A']['sort'] = 100;
578 $config['primaryauth']['C']['sort'] = -1;
579 $this->config->set( 'AuthManagerConfig', $config );
580 $this->initializeManager( false );
581 $this->assertSame(
582 [ 'C' => $mock3, 'B' => $mock2, 'A' => $mock1 ],
583 $this->managerPriv->getPrimaryAuthenticationProviders()
584 );
585 }
586
587 public function testSetDefaultUserOptions() {
588 $this->initializeManager();
589
590 $context = \RequestContext::getMain();
591 $reset = new ScopedCallback( [ $context, 'setLanguage' ], [ $context->getLanguage() ] );
592 $context->setLanguage( 'de' );
593 $this->setMwGlobals( 'wgContLang', \Language::factory( 'zh' ) );
594
595 $user = \User::newFromName( self::usernameForCreation() );
596 $user->addToDatabase();
597 $oldToken = $user->getToken();
598 $this->managerPriv->setDefaultUserOptions( $user, false );
599 $user->saveSettings();
600 $this->assertNotEquals( $oldToken, $user->getToken() );
601 $this->assertSame( 'zh', $user->getOption( 'language' ) );
602 $this->assertSame( 'zh', $user->getOption( 'variant' ) );
603
604 $user = \User::newFromName( self::usernameForCreation() );
605 $user->addToDatabase();
606 $oldToken = $user->getToken();
607 $this->managerPriv->setDefaultUserOptions( $user, true );
608 $user->saveSettings();
609 $this->assertNotEquals( $oldToken, $user->getToken() );
610 $this->assertSame( 'de', $user->getOption( 'language' ) );
611 $this->assertSame( 'zh', $user->getOption( 'variant' ) );
612
613 $this->setMwGlobals( 'wgContLang', \Language::factory( 'en' ) );
614
615 $user = \User::newFromName( self::usernameForCreation() );
616 $user->addToDatabase();
617 $oldToken = $user->getToken();
618 $this->managerPriv->setDefaultUserOptions( $user, true );
619 $user->saveSettings();
620 $this->assertNotEquals( $oldToken, $user->getToken() );
621 $this->assertSame( 'de', $user->getOption( 'language' ) );
622 $this->assertSame( null, $user->getOption( 'variant' ) );
623 }
624
625 public function testForcePrimaryAuthenticationProviders() {
626 $mockA = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
627 $mockB = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
628 $mockB2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
629 $mockA->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'A' ) );
630 $mockB->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
631 $mockB2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'B' ) );
632 $this->primaryauthMocks = [ $mockA ];
633
634 $this->logger = new \TestLogger( true );
635
636 // Test without first initializing the configured providers
637 $this->initializeManager();
638 $this->manager->forcePrimaryAuthenticationProviders( [ $mockB ], 'testing' );
639 $this->assertSame(
640 [ 'B' => $mockB ], $this->managerPriv->getPrimaryAuthenticationProviders()
641 );
642 $this->assertSame( null, $this->managerPriv->getAuthenticationProvider( 'A' ) );
643 $this->assertSame( $mockB, $this->managerPriv->getAuthenticationProvider( 'B' ) );
644 $this->assertSame( [
645 [ LogLevel::WARNING, 'Overriding AuthManager primary authn because testing' ],
646 ], $this->logger->getBuffer() );
647 $this->logger->clearBuffer();
648
649 // Test with first initializing the configured providers
650 $this->initializeManager();
651 $this->assertSame( $mockA, $this->managerPriv->getAuthenticationProvider( 'A' ) );
652 $this->assertSame( null, $this->managerPriv->getAuthenticationProvider( 'B' ) );
653 $this->request->getSession()->setSecret( 'AuthManager::authnState', 'test' );
654 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState', 'test' );
655 $this->manager->forcePrimaryAuthenticationProviders( [ $mockB ], 'testing' );
656 $this->assertSame(
657 [ 'B' => $mockB ], $this->managerPriv->getPrimaryAuthenticationProviders()
658 );
659 $this->assertSame( null, $this->managerPriv->getAuthenticationProvider( 'A' ) );
660 $this->assertSame( $mockB, $this->managerPriv->getAuthenticationProvider( 'B' ) );
661 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::authnState' ) );
662 $this->assertNull(
663 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
664 );
665 $this->assertSame( [
666 [ LogLevel::WARNING, 'Overriding AuthManager primary authn because testing' ],
667 [
668 LogLevel::WARNING,
669 'PrimaryAuthenticationProviders have already been accessed! I hope nothing breaks.'
670 ],
671 ], $this->logger->getBuffer() );
672 $this->logger->clearBuffer();
673
674 // Test duplicate IDs
675 $this->initializeManager();
676 try {
677 $this->manager->forcePrimaryAuthenticationProviders( [ $mockB, $mockB2 ], 'testing' );
678 $this->fail( 'Expected exception not thrown' );
679 } catch ( \RuntimeException $ex ) {
680 $class1 = get_class( $mockB );
681 $class2 = get_class( $mockB2 );
682 $this->assertSame(
683 "Duplicate specifications for id B (classes $class2 and $class1)", $ex->getMessage()
684 );
685 }
686
687 // Wrong classes
688 $mock = $this->getMockForAbstractClass( AuthenticationProvider::class );
689 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
690 $class = get_class( $mock );
691 try {
692 $this->manager->forcePrimaryAuthenticationProviders( [ $mock ], 'testing' );
693 $this->fail( 'Expected exception not thrown' );
694 } catch ( \RuntimeException $ex ) {
695 $this->assertSame(
696 "Expected instance of MediaWiki\\Auth\\PrimaryAuthenticationProvider, got $class",
697 $ex->getMessage()
698 );
699 }
700 }
701
702 public function testBeginAuthentication() {
703 $this->initializeManager();
704
705 // Immutable session
706 list( $provider, $reset ) = $this->getMockSessionProvider( false );
707 $this->hook( 'UserLoggedIn', $this->never() );
708 $this->request->getSession()->setSecret( 'AuthManager::authnState', 'test' );
709 try {
710 $this->manager->beginAuthentication( [], 'http://localhost/' );
711 $this->fail( 'Expected exception not thrown' );
712 } catch ( \LogicException $ex ) {
713 $this->assertSame( 'Authentication is not possible now', $ex->getMessage() );
714 }
715 $this->unhook( 'UserLoggedIn' );
716 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::authnState' ) );
717 ScopedCallback::consume( $reset );
718 $this->initializeManager( true );
719
720 // CreatedAccountAuthenticationRequest
721 $user = \User::newFromName( 'UTSysop' );
722 $reqs = [
723 new CreatedAccountAuthenticationRequest( $user->getId(), $user->getName() )
724 ];
725 $this->hook( 'UserLoggedIn', $this->never() );
726 try {
727 $this->manager->beginAuthentication( $reqs, 'http://localhost/' );
728 $this->fail( 'Expected exception not thrown' );
729 } catch ( \LogicException $ex ) {
730 $this->assertSame(
731 'CreatedAccountAuthenticationRequests are only valid on the same AuthManager ' .
732 'that created the account',
733 $ex->getMessage()
734 );
735 }
736 $this->unhook( 'UserLoggedIn' );
737
738 $this->request->getSession()->clear();
739 $this->request->getSession()->setSecret( 'AuthManager::authnState', 'test' );
740 $this->managerPriv->createdAccountAuthenticationRequests = [ $reqs[0] ];
741 $this->hook( 'UserLoggedIn', $this->once() )
742 ->with( $this->callback( function ( $u ) use ( $user ) {
743 return $user->getId() === $u->getId() && $user->getName() === $u->getName();
744 } ) );
745 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->once() );
746 $this->logger->setCollect( true );
747 $ret = $this->manager->beginAuthentication( $reqs, 'http://localhost/' );
748 $this->logger->setCollect( false );
749 $this->unhook( 'UserLoggedIn' );
750 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
751 $this->assertSame( AuthenticationResponse::PASS, $ret->status );
752 $this->assertSame( $user->getName(), $ret->username );
753 $this->assertSame( $user->getId(), $this->request->getSessionData( 'AuthManager:lastAuthId' ) );
754 $this->assertEquals(
755 time(), $this->request->getSessionData( 'AuthManager:lastAuthTimestamp' ),
756 'timestamp ±1', 1
757 );
758 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::authnState' ) );
759 $this->assertSame( $user->getId(), $this->request->getSession()->getUser()->getId() );
760 $this->assertSame( [
761 [ LogLevel::INFO, 'Logging in {user} after account creation' ],
762 ], $this->logger->getBuffer() );
763 }
764
765 public function testCreateFromLogin() {
766 $user = \User::newFromName( 'UTSysop' );
767 $req1 = $this->createMock( AuthenticationRequest::class );
768 $req2 = $this->createMock( AuthenticationRequest::class );
769 $req3 = $this->createMock( AuthenticationRequest::class );
770 $userReq = new UsernameAuthenticationRequest;
771 $userReq->username = 'UTDummy';
772
773 $req1->returnToUrl = 'http://localhost/';
774 $req2->returnToUrl = 'http://localhost/';
775 $req3->returnToUrl = 'http://localhost/';
776 $req3->username = 'UTDummy';
777 $userReq->returnToUrl = 'http://localhost/';
778
779 // Passing one into beginAuthentication(), and an immediate FAIL
780 $primary = $this->getMockForAbstractClass( AbstractPrimaryAuthenticationProvider::class );
781 $this->primaryauthMocks = [ $primary ];
782 $this->initializeManager( true );
783 $res = AuthenticationResponse::newFail( wfMessage( 'foo' ) );
784 $res->createRequest = $req1;
785 $primary->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
786 ->will( $this->returnValue( $res ) );
787 $createReq = new CreateFromLoginAuthenticationRequest(
788 null, [ $req2->getUniqueId() => $req2 ]
789 );
790 $this->logger->setCollect( true );
791 $ret = $this->manager->beginAuthentication( [ $createReq ], 'http://localhost/' );
792 $this->logger->setCollect( false );
793 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
794 $this->assertInstanceOf( CreateFromLoginAuthenticationRequest::class, $ret->createRequest );
795 $this->assertSame( $req1, $ret->createRequest->createRequest );
796 $this->assertEquals( [ $req2->getUniqueId() => $req2 ], $ret->createRequest->maybeLink );
797
798 // UI, then FAIL in beginAuthentication()
799 $primary = $this->getMockBuilder( AbstractPrimaryAuthenticationProvider::class )
800 ->setMethods( [ 'continuePrimaryAuthentication' ] )
801 ->getMockForAbstractClass();
802 $this->primaryauthMocks = [ $primary ];
803 $this->initializeManager( true );
804 $primary->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
805 ->will( $this->returnValue(
806 AuthenticationResponse::newUI( [ $req1 ], wfMessage( 'foo' ) )
807 ) );
808 $res = AuthenticationResponse::newFail( wfMessage( 'foo' ) );
809 $res->createRequest = $req2;
810 $primary->expects( $this->any() )->method( 'continuePrimaryAuthentication' )
811 ->will( $this->returnValue( $res ) );
812 $this->logger->setCollect( true );
813 $ret = $this->manager->beginAuthentication( [], 'http://localhost/' );
814 $this->assertSame( AuthenticationResponse::UI, $ret->status, 'sanity check' );
815 $ret = $this->manager->continueAuthentication( [] );
816 $this->logger->setCollect( false );
817 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
818 $this->assertInstanceOf( CreateFromLoginAuthenticationRequest::class, $ret->createRequest );
819 $this->assertSame( $req2, $ret->createRequest->createRequest );
820 $this->assertEquals( [], $ret->createRequest->maybeLink );
821
822 // Pass into beginAccountCreation(), see that maybeLink and createRequest get copied
823 $primary = $this->getMockForAbstractClass( AbstractPrimaryAuthenticationProvider::class );
824 $this->primaryauthMocks = [ $primary ];
825 $this->initializeManager( true );
826 $createReq = new CreateFromLoginAuthenticationRequest( $req3, [ $req2 ] );
827 $createReq->returnToUrl = 'http://localhost/';
828 $createReq->username = 'UTDummy';
829 $res = AuthenticationResponse::newUI( [ $req1 ], wfMessage( 'foo' ) );
830 $primary->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )
831 ->with( $this->anything(), $this->anything(), [ $userReq, $createReq, $req3 ] )
832 ->will( $this->returnValue( $res ) );
833 $primary->expects( $this->any() )->method( 'accountCreationType' )
834 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
835 $this->logger->setCollect( true );
836 $ret = $this->manager->beginAccountCreation(
837 $user, [ $userReq, $createReq ], 'http://localhost/'
838 );
839 $this->logger->setCollect( false );
840 $this->assertSame( AuthenticationResponse::UI, $ret->status );
841 $state = $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' );
842 $this->assertNotNull( $state );
843 $this->assertEquals( [ $userReq, $createReq, $req3 ], $state['reqs'] );
844 $this->assertEquals( [ $req2 ], $state['maybeLink'] );
845 }
846
847 /**
848 * @dataProvider provideAuthentication
849 * @param StatusValue $preResponse
850 * @param array $primaryResponses
851 * @param array $secondaryResponses
852 * @param array $managerResponses
853 * @param bool $link Whether the primary authentication provider is a "link" provider
854 */
855 public function testAuthentication(
856 StatusValue $preResponse, array $primaryResponses, array $secondaryResponses,
857 array $managerResponses, $link = false
858 ) {
859 $this->initializeManager();
860 $user = \User::newFromName( 'UTSysop' );
861 $id = $user->getId();
862 $name = $user->getName();
863
864 // Set up lots of mocks...
865 $req = new RememberMeAuthenticationRequest;
866 $req->rememberMe = (bool)rand( 0, 1 );
867 $req->pre = $preResponse;
868 $req->primary = $primaryResponses;
869 $req->secondary = $secondaryResponses;
870 $mocks = [];
871 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
872 $class = ucfirst( $key ) . 'AuthenticationProvider';
873 $mocks[$key] = $this->getMockForAbstractClass(
874 "MediaWiki\\Auth\\$class", [], "Mock$class"
875 );
876 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
877 ->will( $this->returnValue( $key ) );
878 $mocks[$key . '2'] = $this->getMockForAbstractClass(
879 "MediaWiki\\Auth\\$class", [], "Mock$class"
880 );
881 $mocks[$key . '2']->expects( $this->any() )->method( 'getUniqueId' )
882 ->will( $this->returnValue( $key . '2' ) );
883 $mocks[$key . '3'] = $this->getMockForAbstractClass(
884 "MediaWiki\\Auth\\$class", [], "Mock$class"
885 );
886 $mocks[$key . '3']->expects( $this->any() )->method( 'getUniqueId' )
887 ->will( $this->returnValue( $key . '3' ) );
888 }
889 foreach ( $mocks as $mock ) {
890 $mock->expects( $this->any() )->method( 'getAuthenticationRequests' )
891 ->will( $this->returnValue( [] ) );
892 }
893
894 $mocks['pre']->expects( $this->once() )->method( 'testForAuthentication' )
895 ->will( $this->returnCallback( function ( $reqs ) use ( $req ) {
896 $this->assertContains( $req, $reqs );
897 return $req->pre;
898 } ) );
899
900 $ct = count( $req->primary );
901 $callback = $this->returnCallback( function ( $reqs ) use ( $req ) {
902 $this->assertContains( $req, $reqs );
903 return array_shift( $req->primary );
904 } );
905 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
906 ->method( 'beginPrimaryAuthentication' )
907 ->will( $callback );
908 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
909 ->method( 'continuePrimaryAuthentication' )
910 ->will( $callback );
911 if ( $link ) {
912 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
913 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
914 }
915
916 $ct = count( $req->secondary );
917 $callback = $this->returnCallback( function ( $user, $reqs ) use ( $id, $name, $req ) {
918 $this->assertSame( $id, $user->getId() );
919 $this->assertSame( $name, $user->getName() );
920 $this->assertContains( $req, $reqs );
921 return array_shift( $req->secondary );
922 } );
923 $mocks['secondary']->expects( $this->exactly( min( 1, $ct ) ) )
924 ->method( 'beginSecondaryAuthentication' )
925 ->will( $callback );
926 $mocks['secondary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
927 ->method( 'continueSecondaryAuthentication' )
928 ->will( $callback );
929
930 $abstain = AuthenticationResponse::newAbstain();
931 $mocks['pre2']->expects( $this->atMost( 1 ) )->method( 'testForAuthentication' )
932 ->will( $this->returnValue( StatusValue::newGood() ) );
933 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAuthentication' )
934 ->will( $this->returnValue( $abstain ) );
935 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAuthentication' );
936 $mocks['secondary2']->expects( $this->atMost( 1 ) )->method( 'beginSecondaryAuthentication' )
937 ->will( $this->returnValue( $abstain ) );
938 $mocks['secondary2']->expects( $this->never() )->method( 'continueSecondaryAuthentication' );
939 $mocks['secondary3']->expects( $this->atMost( 1 ) )->method( 'beginSecondaryAuthentication' )
940 ->will( $this->returnValue( $abstain ) );
941 $mocks['secondary3']->expects( $this->never() )->method( 'continueSecondaryAuthentication' );
942
943 $this->preauthMocks = [ $mocks['pre'], $mocks['pre2'] ];
944 $this->primaryauthMocks = [ $mocks['primary'], $mocks['primary2'] ];
945 $this->secondaryauthMocks = [
946 $mocks['secondary3'], $mocks['secondary'], $mocks['secondary2'],
947 // So linking happens
948 new ConfirmLinkSecondaryAuthenticationProvider,
949 ];
950 $this->initializeManager( true );
951 $this->logger->setCollect( true );
952
953 $constraint = \PHPUnit_Framework_Assert::logicalOr(
954 $this->equalTo( AuthenticationResponse::PASS ),
955 $this->equalTo( AuthenticationResponse::FAIL )
956 );
957 $providers = array_filter(
958 array_merge(
959 $this->preauthMocks, $this->primaryauthMocks, $this->secondaryauthMocks
960 ),
961 function ( $p ) {
962 return is_callable( [ $p, 'expects' ] );
963 }
964 );
965 foreach ( $providers as $p ) {
966 $p->postCalled = false;
967 $p->expects( $this->atMost( 1 ) )->method( 'postAuthentication' )
968 ->willReturnCallback( function ( $user, $response ) use ( $constraint, $p ) {
969 if ( $user !== null ) {
970 $this->assertInstanceOf( 'User', $user );
971 $this->assertSame( 'UTSysop', $user->getName() );
972 }
973 $this->assertInstanceOf( AuthenticationResponse::class, $response );
974 $this->assertThat( $response->status, $constraint );
975 $p->postCalled = $response->status;
976 } );
977 }
978
979 $session = $this->request->getSession();
980 $session->setRememberUser( !$req->rememberMe );
981
982 foreach ( $managerResponses as $i => $response ) {
983 $success = $response instanceof AuthenticationResponse &&
984 $response->status === AuthenticationResponse::PASS;
985 if ( $success ) {
986 $this->hook( 'UserLoggedIn', $this->once() )
987 ->with( $this->callback( function ( $user ) use ( $id, $name ) {
988 return $user->getId() === $id && $user->getName() === $name;
989 } ) );
990 } else {
991 $this->hook( 'UserLoggedIn', $this->never() );
992 }
993 if ( $success || (
994 $response instanceof AuthenticationResponse &&
995 $response->status === AuthenticationResponse::FAIL &&
996 $response->message->getKey() !== 'authmanager-authn-not-in-progress' &&
997 $response->message->getKey() !== 'authmanager-authn-no-primary'
998 )
999 ) {
1000 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->once() );
1001 } else {
1002 $this->hook( 'AuthManagerLoginAuthenticateAudit', $this->never() );
1003 }
1004
1005 $ex = null;
1006 try {
1007 if ( !$i ) {
1008 $ret = $this->manager->beginAuthentication( [ $req ], 'http://localhost/' );
1009 } else {
1010 $ret = $this->manager->continueAuthentication( [ $req ] );
1011 }
1012 if ( $response instanceof \Exception ) {
1013 $this->fail( 'Expected exception not thrown', "Response $i" );
1014 }
1015 } catch ( \Exception $ex ) {
1016 if ( !$response instanceof \Exception ) {
1017 throw $ex;
1018 }
1019 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
1020 $this->assertNull( $session->getSecret( 'AuthManager::authnState' ),
1021 "Response $i, exception, session state" );
1022 $this->unhook( 'UserLoggedIn' );
1023 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
1024 return;
1025 }
1026
1027 $this->unhook( 'UserLoggedIn' );
1028 $this->unhook( 'AuthManagerLoginAuthenticateAudit' );
1029
1030 $this->assertSame( 'http://localhost/', $req->returnToUrl );
1031
1032 $ret->message = $this->message( $ret->message );
1033 $this->assertEquals( $response, $ret, "Response $i, response" );
1034 if ( $success ) {
1035 $this->assertSame( $id, $session->getUser()->getId(),
1036 "Response $i, authn" );
1037 } else {
1038 $this->assertSame( 0, $session->getUser()->getId(),
1039 "Response $i, authn" );
1040 }
1041 if ( $success || $response->status === AuthenticationResponse::FAIL ) {
1042 $this->assertNull( $session->getSecret( 'AuthManager::authnState' ),
1043 "Response $i, session state" );
1044 foreach ( $providers as $p ) {
1045 $this->assertSame( $response->status, $p->postCalled,
1046 "Response $i, post-auth callback called" );
1047 }
1048 } else {
1049 $this->assertNotNull( $session->getSecret( 'AuthManager::authnState' ),
1050 "Response $i, session state" );
1051 foreach ( $ret->neededRequests as $neededReq ) {
1052 $this->assertEquals( AuthManager::ACTION_LOGIN, $neededReq->action,
1053 "Response $i, neededRequest action" );
1054 }
1055 $this->assertEquals(
1056 $ret->neededRequests,
1057 $this->manager->getAuthenticationRequests( AuthManager::ACTION_LOGIN_CONTINUE ),
1058 "Response $i, continuation check"
1059 );
1060 foreach ( $providers as $p ) {
1061 $this->assertFalse( $p->postCalled, "Response $i, post-auth callback not called" );
1062 }
1063 }
1064
1065 $state = $session->getSecret( 'AuthManager::authnState' );
1066 $maybeLink = isset( $state['maybeLink'] ) ? $state['maybeLink'] : [];
1067 if ( $link && $response->status === AuthenticationResponse::RESTART ) {
1068 $this->assertEquals(
1069 $response->createRequest->maybeLink,
1070 $maybeLink,
1071 "Response $i, maybeLink"
1072 );
1073 } else {
1074 $this->assertEquals( [], $maybeLink, "Response $i, maybeLink" );
1075 }
1076 }
1077
1078 if ( $success ) {
1079 $this->assertSame( $req->rememberMe, $session->shouldRememberUser(),
1080 'rememberMe checkbox had effect' );
1081 } else {
1082 $this->assertNotSame( $req->rememberMe, $session->shouldRememberUser(),
1083 'rememberMe checkbox wasn\'t applied' );
1084 }
1085 }
1086
1087 public function provideAuthentication() {
1088 $rememberReq = new RememberMeAuthenticationRequest;
1089 $rememberReq->action = AuthManager::ACTION_LOGIN;
1090
1091 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
1092 $req->foobar = 'baz';
1093 $restartResponse = AuthenticationResponse::newRestart(
1094 $this->message( 'authmanager-authn-no-local-user' )
1095 );
1096 $restartResponse->neededRequests = [ $rememberReq ];
1097
1098 $restartResponse2Pass = AuthenticationResponse::newPass( null );
1099 $restartResponse2Pass->linkRequest = $req;
1100 $restartResponse2 = AuthenticationResponse::newRestart(
1101 $this->message( 'authmanager-authn-no-local-user-link' )
1102 );
1103 $restartResponse2->createRequest = new CreateFromLoginAuthenticationRequest(
1104 null, [ $req->getUniqueId() => $req ]
1105 );
1106 $restartResponse2->createRequest->action = AuthManager::ACTION_LOGIN;
1107 $restartResponse2->neededRequests = [ $rememberReq, $restartResponse2->createRequest ];
1108
1109 $userName = 'UTSysop';
1110
1111 return [
1112 'Failure in pre-auth' => [
1113 StatusValue::newFatal( 'fail-from-pre' ),
1114 [],
1115 [],
1116 [
1117 AuthenticationResponse::newFail( $this->message( 'fail-from-pre' ) ),
1118 AuthenticationResponse::newFail(
1119 $this->message( 'authmanager-authn-not-in-progress' )
1120 ),
1121 ]
1122 ],
1123 'Failure in primary' => [
1124 StatusValue::newGood(),
1125 $tmp = [
1126 AuthenticationResponse::newFail( $this->message( 'fail-from-primary' ) ),
1127 ],
1128 [],
1129 $tmp
1130 ],
1131 'All primary abstain' => [
1132 StatusValue::newGood(),
1133 [
1134 AuthenticationResponse::newAbstain(),
1135 ],
1136 [],
1137 [
1138 AuthenticationResponse::newFail( $this->message( 'authmanager-authn-no-primary' ) )
1139 ]
1140 ],
1141 'Primary UI, then redirect, then fail' => [
1142 StatusValue::newGood(),
1143 $tmp = [
1144 AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
1145 AuthenticationResponse::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
1146 AuthenticationResponse::newFail( $this->message( 'fail-in-primary-continue' ) ),
1147 ],
1148 [],
1149 $tmp
1150 ],
1151 'Primary redirect, then abstain' => [
1152 StatusValue::newGood(),
1153 [
1154 $tmp = AuthenticationResponse::newRedirect(
1155 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
1156 ),
1157 AuthenticationResponse::newAbstain(),
1158 ],
1159 [],
1160 [
1161 $tmp,
1162 new \DomainException(
1163 'MockPrimaryAuthenticationProvider::continuePrimaryAuthentication() returned ABSTAIN'
1164 )
1165 ]
1166 ],
1167 'Primary UI, then pass with no local user' => [
1168 StatusValue::newGood(),
1169 [
1170 $tmp = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
1171 AuthenticationResponse::newPass( null ),
1172 ],
1173 [],
1174 [
1175 $tmp,
1176 $restartResponse,
1177 ]
1178 ],
1179 'Primary UI, then pass with no local user (link type)' => [
1180 StatusValue::newGood(),
1181 [
1182 $tmp = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
1183 $restartResponse2Pass,
1184 ],
1185 [],
1186 [
1187 $tmp,
1188 $restartResponse2,
1189 ],
1190 true
1191 ],
1192 'Primary pass with invalid username' => [
1193 StatusValue::newGood(),
1194 [
1195 AuthenticationResponse::newPass( '<>' ),
1196 ],
1197 [],
1198 [
1199 new \DomainException( 'MockPrimaryAuthenticationProvider returned an invalid username: <>' ),
1200 ]
1201 ],
1202 'Secondary fail' => [
1203 StatusValue::newGood(),
1204 [
1205 AuthenticationResponse::newPass( $userName ),
1206 ],
1207 $tmp = [
1208 AuthenticationResponse::newFail( $this->message( 'fail-in-secondary' ) ),
1209 ],
1210 $tmp
1211 ],
1212 'Secondary UI, then abstain' => [
1213 StatusValue::newGood(),
1214 [
1215 AuthenticationResponse::newPass( $userName ),
1216 ],
1217 [
1218 $tmp = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
1219 AuthenticationResponse::newAbstain()
1220 ],
1221 [
1222 $tmp,
1223 AuthenticationResponse::newPass( $userName ),
1224 ]
1225 ],
1226 'Secondary pass' => [
1227 StatusValue::newGood(),
1228 [
1229 AuthenticationResponse::newPass( $userName ),
1230 ],
1231 [
1232 AuthenticationResponse::newPass()
1233 ],
1234 [
1235 AuthenticationResponse::newPass( $userName ),
1236 ]
1237 ],
1238 ];
1239 }
1240
1241 /**
1242 * @dataProvider provideUserExists
1243 * @param bool $primary1Exists
1244 * @param bool $primary2Exists
1245 * @param bool $expect
1246 */
1247 public function testUserExists( $primary1Exists, $primary2Exists, $expect ) {
1248 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1249 $mock1->expects( $this->any() )->method( 'getUniqueId' )
1250 ->will( $this->returnValue( 'primary1' ) );
1251 $mock1->expects( $this->any() )->method( 'testUserExists' )
1252 ->with( $this->equalTo( 'UTSysop' ) )
1253 ->will( $this->returnValue( $primary1Exists ) );
1254 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1255 $mock2->expects( $this->any() )->method( 'getUniqueId' )
1256 ->will( $this->returnValue( 'primary2' ) );
1257 $mock2->expects( $this->any() )->method( 'testUserExists' )
1258 ->with( $this->equalTo( 'UTSysop' ) )
1259 ->will( $this->returnValue( $primary2Exists ) );
1260 $this->primaryauthMocks = [ $mock1, $mock2 ];
1261
1262 $this->initializeManager( true );
1263 $this->assertSame( $expect, $this->manager->userExists( 'UTSysop' ) );
1264 }
1265
1266 public static function provideUserExists() {
1267 return [
1268 [ false, false, false ],
1269 [ true, false, true ],
1270 [ false, true, true ],
1271 [ true, true, true ],
1272 ];
1273 }
1274
1275 /**
1276 * @dataProvider provideAllowsAuthenticationDataChange
1277 * @param StatusValue $primaryReturn
1278 * @param StatusValue $secondaryReturn
1279 * @param Status $expect
1280 */
1281 public function testAllowsAuthenticationDataChange( $primaryReturn, $secondaryReturn, $expect ) {
1282 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
1283
1284 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1285 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '1' ) );
1286 $mock1->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
1287 ->with( $this->equalTo( $req ) )
1288 ->will( $this->returnValue( $primaryReturn ) );
1289 $mock2 = $this->getMockForAbstractClass( SecondaryAuthenticationProvider::class );
1290 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '2' ) );
1291 $mock2->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
1292 ->with( $this->equalTo( $req ) )
1293 ->will( $this->returnValue( $secondaryReturn ) );
1294
1295 $this->primaryauthMocks = [ $mock1 ];
1296 $this->secondaryauthMocks = [ $mock2 ];
1297 $this->initializeManager( true );
1298 $this->assertEquals( $expect, $this->manager->allowsAuthenticationDataChange( $req ) );
1299 }
1300
1301 public static function provideAllowsAuthenticationDataChange() {
1302 $ignored = \Status::newGood( 'ignored' );
1303 $ignored->warning( 'authmanager-change-not-supported' );
1304
1305 $okFromPrimary = StatusValue::newGood();
1306 $okFromPrimary->warning( 'warning-from-primary' );
1307 $okFromSecondary = StatusValue::newGood();
1308 $okFromSecondary->warning( 'warning-from-secondary' );
1309
1310 return [
1311 [
1312 StatusValue::newGood(),
1313 StatusValue::newGood(),
1314 \Status::newGood(),
1315 ],
1316 [
1317 StatusValue::newGood(),
1318 StatusValue::newGood( 'ignore' ),
1319 \Status::newGood(),
1320 ],
1321 [
1322 StatusValue::newGood( 'ignored' ),
1323 StatusValue::newGood(),
1324 \Status::newGood(),
1325 ],
1326 [
1327 StatusValue::newGood( 'ignored' ),
1328 StatusValue::newGood( 'ignored' ),
1329 $ignored,
1330 ],
1331 [
1332 StatusValue::newFatal( 'fail from primary' ),
1333 StatusValue::newGood(),
1334 \Status::newFatal( 'fail from primary' ),
1335 ],
1336 [
1337 $okFromPrimary,
1338 StatusValue::newGood(),
1339 \Status::wrap( $okFromPrimary ),
1340 ],
1341 [
1342 StatusValue::newGood(),
1343 StatusValue::newFatal( 'fail from secondary' ),
1344 \Status::newFatal( 'fail from secondary' ),
1345 ],
1346 [
1347 StatusValue::newGood(),
1348 $okFromSecondary,
1349 \Status::wrap( $okFromSecondary ),
1350 ],
1351 ];
1352 }
1353
1354 public function testChangeAuthenticationData() {
1355 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
1356 $req->username = 'UTSysop';
1357
1358 $mock1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1359 $mock1->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '1' ) );
1360 $mock1->expects( $this->once() )->method( 'providerChangeAuthenticationData' )
1361 ->with( $this->equalTo( $req ) );
1362 $mock2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1363 $mock2->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( '2' ) );
1364 $mock2->expects( $this->once() )->method( 'providerChangeAuthenticationData' )
1365 ->with( $this->equalTo( $req ) );
1366
1367 $this->primaryauthMocks = [ $mock1, $mock2 ];
1368 $this->initializeManager( true );
1369 $this->logger->setCollect( true );
1370 $this->manager->changeAuthenticationData( $req );
1371 $this->assertSame( [
1372 [ LogLevel::INFO, 'Changing authentication data for {user} class {what}' ],
1373 ], $this->logger->getBuffer() );
1374 }
1375
1376 public function testCanCreateAccounts() {
1377 $types = [
1378 PrimaryAuthenticationProvider::TYPE_CREATE => true,
1379 PrimaryAuthenticationProvider::TYPE_LINK => true,
1380 PrimaryAuthenticationProvider::TYPE_NONE => false,
1381 ];
1382
1383 foreach ( $types as $type => $can ) {
1384 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1385 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $type ) );
1386 $mock->expects( $this->any() )->method( 'accountCreationType' )
1387 ->will( $this->returnValue( $type ) );
1388 $this->primaryauthMocks = [ $mock ];
1389 $this->initializeManager( true );
1390 $this->assertSame( $can, $this->manager->canCreateAccounts(), $type );
1391 }
1392 }
1393
1394 public function testCheckAccountCreatePermissions() {
1395 global $wgGroupPermissions;
1396
1397 $this->stashMwGlobals( [ 'wgGroupPermissions' ] );
1398
1399 $this->initializeManager( true );
1400
1401 $wgGroupPermissions['*']['createaccount'] = true;
1402 $this->assertEquals(
1403 \Status::newGood(),
1404 $this->manager->checkAccountCreatePermissions( new \User )
1405 );
1406
1407 $this->setMwGlobals( [ 'wgReadOnly' => 'Because' ] );
1408 $this->assertEquals(
1409 \Status::newFatal( 'readonlytext', 'Because' ),
1410 $this->manager->checkAccountCreatePermissions( new \User )
1411 );
1412 $this->setMwGlobals( [ 'wgReadOnly' => false ] );
1413
1414 $wgGroupPermissions['*']['createaccount'] = false;
1415 $status = $this->manager->checkAccountCreatePermissions( new \User );
1416 $this->assertFalse( $status->isOK() );
1417 $this->assertTrue( $status->hasMessage( 'badaccess-groups' ) );
1418 $wgGroupPermissions['*']['createaccount'] = true;
1419
1420 $user = \User::newFromName( 'UTBlockee' );
1421 if ( $user->getID() == 0 ) {
1422 $user->addToDatabase();
1423 \TestUser::setPasswordForUser( $user, 'UTBlockeePassword' );
1424 $user->saveSettings();
1425 }
1426 $oldBlock = \Block::newFromTarget( 'UTBlockee' );
1427 if ( $oldBlock ) {
1428 // An old block will prevent our new one from saving.
1429 $oldBlock->delete();
1430 }
1431 $blockOptions = [
1432 'address' => 'UTBlockee',
1433 'user' => $user->getID(),
1434 'reason' => __METHOD__,
1435 'expiry' => time() + 100500,
1436 'createAccount' => true,
1437 ];
1438 $block = new \Block( $blockOptions );
1439 $block->insert();
1440 $status = $this->manager->checkAccountCreatePermissions( $user );
1441 $this->assertFalse( $status->isOK() );
1442 $this->assertTrue( $status->hasMessage( 'cantcreateaccount-text' ) );
1443
1444 $blockOptions = [
1445 'address' => '127.0.0.0/24',
1446 'reason' => __METHOD__,
1447 'expiry' => time() + 100500,
1448 'createAccount' => true,
1449 ];
1450 $block = new \Block( $blockOptions );
1451 $block->insert();
1452 $scopeVariable = new ScopedCallback( [ $block, 'delete' ] );
1453 $status = $this->manager->checkAccountCreatePermissions( new \User );
1454 $this->assertFalse( $status->isOK() );
1455 $this->assertTrue( $status->hasMessage( 'cantcreateaccount-range-text' ) );
1456 ScopedCallback::consume( $scopeVariable );
1457
1458 $this->setMwGlobals( [
1459 'wgEnableDnsBlacklist' => true,
1460 'wgDnsBlacklistUrls' => [
1461 'local.wmftest.net', // This will resolve for every subdomain, which works to test "listed?"
1462 ],
1463 'wgProxyWhitelist' => [],
1464 ] );
1465 $status = $this->manager->checkAccountCreatePermissions( new \User );
1466 $this->assertFalse( $status->isOK() );
1467 $this->assertTrue( $status->hasMessage( 'sorbs_create_account_reason' ) );
1468 $this->setMwGlobals( 'wgProxyWhitelist', [ '127.0.0.1' ] );
1469 $status = $this->manager->checkAccountCreatePermissions( new \User );
1470 $this->assertTrue( $status->isGood() );
1471 }
1472
1473 /**
1474 * @param string $uniq
1475 * @return string
1476 */
1477 private static function usernameForCreation( $uniq = '' ) {
1478 $i = 0;
1479 do {
1480 $username = "UTAuthManagerTestAccountCreation" . $uniq . ++$i;
1481 } while ( \User::newFromName( $username )->getId() !== 0 );
1482 return $username;
1483 }
1484
1485 public function testCanCreateAccount() {
1486 $username = self::usernameForCreation();
1487 $this->initializeManager();
1488
1489 $this->assertEquals(
1490 \Status::newFatal( 'authmanager-create-disabled' ),
1491 $this->manager->canCreateAccount( $username )
1492 );
1493
1494 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1495 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1496 $mock->expects( $this->any() )->method( 'accountCreationType' )
1497 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1498 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
1499 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1500 ->will( $this->returnValue( StatusValue::newGood() ) );
1501 $this->primaryauthMocks = [ $mock ];
1502 $this->initializeManager( true );
1503
1504 $this->assertEquals(
1505 \Status::newFatal( 'userexists' ),
1506 $this->manager->canCreateAccount( $username )
1507 );
1508
1509 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1510 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1511 $mock->expects( $this->any() )->method( 'accountCreationType' )
1512 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1513 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1514 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1515 ->will( $this->returnValue( StatusValue::newGood() ) );
1516 $this->primaryauthMocks = [ $mock ];
1517 $this->initializeManager( true );
1518
1519 $this->assertEquals(
1520 \Status::newFatal( 'noname' ),
1521 $this->manager->canCreateAccount( $username . '<>' )
1522 );
1523
1524 $this->assertEquals(
1525 \Status::newFatal( 'userexists' ),
1526 $this->manager->canCreateAccount( 'UTSysop' )
1527 );
1528
1529 $this->assertEquals(
1530 \Status::newGood(),
1531 $this->manager->canCreateAccount( $username )
1532 );
1533
1534 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1535 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1536 $mock->expects( $this->any() )->method( 'accountCreationType' )
1537 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1538 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1539 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1540 ->will( $this->returnValue( StatusValue::newFatal( 'fail' ) ) );
1541 $this->primaryauthMocks = [ $mock ];
1542 $this->initializeManager( true );
1543
1544 $this->assertEquals(
1545 \Status::newFatal( 'fail' ),
1546 $this->manager->canCreateAccount( $username )
1547 );
1548 }
1549
1550 public function testBeginAccountCreation() {
1551 $creator = \User::newFromName( 'UTSysop' );
1552 $userReq = new UsernameAuthenticationRequest;
1553 $this->logger = new \TestLogger( false, function ( $message, $level ) {
1554 return $level === LogLevel::DEBUG ? null : $message;
1555 } );
1556 $this->initializeManager();
1557
1558 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState', 'test' );
1559 $this->hook( 'LocalUserCreated', $this->never() );
1560 try {
1561 $this->manager->beginAccountCreation(
1562 $creator, [], 'http://localhost/'
1563 );
1564 $this->fail( 'Expected exception not thrown' );
1565 } catch ( \LogicException $ex ) {
1566 $this->assertEquals( 'Account creation is not possible', $ex->getMessage() );
1567 }
1568 $this->unhook( 'LocalUserCreated' );
1569 $this->assertNull(
1570 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1571 );
1572
1573 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1574 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1575 $mock->expects( $this->any() )->method( 'accountCreationType' )
1576 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1577 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
1578 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1579 ->will( $this->returnValue( StatusValue::newGood() ) );
1580 $this->primaryauthMocks = [ $mock ];
1581 $this->initializeManager( true );
1582
1583 $this->hook( 'LocalUserCreated', $this->never() );
1584 $ret = $this->manager->beginAccountCreation( $creator, [], 'http://localhost/' );
1585 $this->unhook( 'LocalUserCreated' );
1586 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1587 $this->assertSame( 'noname', $ret->message->getKey() );
1588
1589 $this->hook( 'LocalUserCreated', $this->never() );
1590 $userReq->username = self::usernameForCreation();
1591 $userReq2 = new UsernameAuthenticationRequest;
1592 $userReq2->username = $userReq->username . 'X';
1593 $ret = $this->manager->beginAccountCreation(
1594 $creator, [ $userReq, $userReq2 ], 'http://localhost/'
1595 );
1596 $this->unhook( 'LocalUserCreated' );
1597 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1598 $this->assertSame( 'noname', $ret->message->getKey() );
1599
1600 $this->setMwGlobals( [ 'wgReadOnly' => 'Because' ] );
1601 $this->hook( 'LocalUserCreated', $this->never() );
1602 $userReq->username = self::usernameForCreation();
1603 $ret = $this->manager->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1604 $this->unhook( 'LocalUserCreated' );
1605 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1606 $this->assertSame( 'readonlytext', $ret->message->getKey() );
1607 $this->assertSame( [ 'Because' ], $ret->message->getParams() );
1608 $this->setMwGlobals( [ 'wgReadOnly' => false ] );
1609
1610 $this->hook( 'LocalUserCreated', $this->never() );
1611 $userReq->username = self::usernameForCreation();
1612 $ret = $this->manager->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1613 $this->unhook( 'LocalUserCreated' );
1614 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1615 $this->assertSame( 'userexists', $ret->message->getKey() );
1616
1617 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1618 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1619 $mock->expects( $this->any() )->method( 'accountCreationType' )
1620 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1621 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1622 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1623 ->will( $this->returnValue( StatusValue::newFatal( 'fail' ) ) );
1624 $this->primaryauthMocks = [ $mock ];
1625 $this->initializeManager( true );
1626
1627 $this->hook( 'LocalUserCreated', $this->never() );
1628 $userReq->username = self::usernameForCreation();
1629 $ret = $this->manager->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1630 $this->unhook( 'LocalUserCreated' );
1631 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1632 $this->assertSame( 'fail', $ret->message->getKey() );
1633
1634 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1635 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1636 $mock->expects( $this->any() )->method( 'accountCreationType' )
1637 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1638 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1639 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1640 ->will( $this->returnValue( StatusValue::newGood() ) );
1641 $this->primaryauthMocks = [ $mock ];
1642 $this->initializeManager( true );
1643
1644 $this->hook( 'LocalUserCreated', $this->never() );
1645 $userReq->username = self::usernameForCreation() . '<>';
1646 $ret = $this->manager->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1647 $this->unhook( 'LocalUserCreated' );
1648 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1649 $this->assertSame( 'noname', $ret->message->getKey() );
1650
1651 $this->hook( 'LocalUserCreated', $this->never() );
1652 $userReq->username = $creator->getName();
1653 $ret = $this->manager->beginAccountCreation( $creator, [ $userReq ], 'http://localhost/' );
1654 $this->unhook( 'LocalUserCreated' );
1655 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1656 $this->assertSame( 'userexists', $ret->message->getKey() );
1657
1658 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1659 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1660 $mock->expects( $this->any() )->method( 'accountCreationType' )
1661 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1662 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1663 $mock->expects( $this->any() )->method( 'testUserForCreation' )
1664 ->will( $this->returnValue( StatusValue::newGood() ) );
1665 $mock->expects( $this->any() )->method( 'testForAccountCreation' )
1666 ->will( $this->returnValue( StatusValue::newFatal( 'fail' ) ) );
1667 $this->primaryauthMocks = [ $mock ];
1668 $this->initializeManager( true );
1669
1670 $req = $this->getMockBuilder( UserDataAuthenticationRequest::class )
1671 ->setMethods( [ 'populateUser' ] )
1672 ->getMock();
1673 $req->expects( $this->any() )->method( 'populateUser' )
1674 ->willReturn( \StatusValue::newFatal( 'populatefail' ) );
1675 $userReq->username = self::usernameForCreation();
1676 $ret = $this->manager->beginAccountCreation(
1677 $creator, [ $userReq, $req ], 'http://localhost/'
1678 );
1679 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1680 $this->assertSame( 'populatefail', $ret->message->getKey() );
1681
1682 $req = new UserDataAuthenticationRequest;
1683 $userReq->username = self::usernameForCreation();
1684
1685 $ret = $this->manager->beginAccountCreation(
1686 $creator, [ $userReq, $req ], 'http://localhost/'
1687 );
1688 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1689 $this->assertSame( 'fail', $ret->message->getKey() );
1690
1691 $this->manager->beginAccountCreation(
1692 \User::newFromName( $userReq->username ), [ $userReq, $req ], 'http://localhost/'
1693 );
1694 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1695 $this->assertSame( 'fail', $ret->message->getKey() );
1696 }
1697
1698 public function testContinueAccountCreation() {
1699 $creator = \User::newFromName( 'UTSysop' );
1700 $username = self::usernameForCreation();
1701 $this->logger = new \TestLogger( false, function ( $message, $level ) {
1702 return $level === LogLevel::DEBUG ? null : $message;
1703 } );
1704 $this->initializeManager();
1705
1706 $session = [
1707 'userid' => 0,
1708 'username' => $username,
1709 'creatorid' => 0,
1710 'creatorname' => $username,
1711 'reqs' => [],
1712 'primary' => null,
1713 'primaryResponse' => null,
1714 'secondary' => [],
1715 'ranPreTests' => true,
1716 ];
1717
1718 $this->hook( 'LocalUserCreated', $this->never() );
1719 try {
1720 $this->manager->continueAccountCreation( [] );
1721 $this->fail( 'Expected exception not thrown' );
1722 } catch ( \LogicException $ex ) {
1723 $this->assertEquals( 'Account creation is not possible', $ex->getMessage() );
1724 }
1725 $this->unhook( 'LocalUserCreated' );
1726
1727 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
1728 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
1729 $mock->expects( $this->any() )->method( 'accountCreationType' )
1730 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1731 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( false ) );
1732 $mock->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )->will(
1733 $this->returnValue( AuthenticationResponse::newFail( $this->message( 'fail' ) ) )
1734 );
1735 $this->primaryauthMocks = [ $mock ];
1736 $this->initializeManager( true );
1737
1738 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState', null );
1739 $this->hook( 'LocalUserCreated', $this->never() );
1740 $ret = $this->manager->continueAccountCreation( [] );
1741 $this->unhook( 'LocalUserCreated' );
1742 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1743 $this->assertSame( 'authmanager-create-not-in-progress', $ret->message->getKey() );
1744
1745 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1746 [ 'username' => "$username<>" ] + $session );
1747 $this->hook( 'LocalUserCreated', $this->never() );
1748 $ret = $this->manager->continueAccountCreation( [] );
1749 $this->unhook( 'LocalUserCreated' );
1750 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1751 $this->assertSame( 'noname', $ret->message->getKey() );
1752 $this->assertNull(
1753 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1754 );
1755
1756 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState', $session );
1757 $this->hook( 'LocalUserCreated', $this->never() );
1758 $cache = \ObjectCache::getLocalClusterInstance();
1759 $lock = $cache->getScopedLock( $cache->makeGlobalKey( 'account', md5( $username ) ) );
1760 $ret = $this->manager->continueAccountCreation( [] );
1761 unset( $lock );
1762 $this->unhook( 'LocalUserCreated' );
1763 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1764 $this->assertSame( 'usernameinprogress', $ret->message->getKey() );
1765 // This error shouldn't remove the existing session, because the
1766 // raced-with process "owns" it.
1767 $this->assertSame(
1768 $session, $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1769 );
1770
1771 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1772 [ 'username' => $creator->getName() ] + $session );
1773 $this->setMwGlobals( [ 'wgReadOnly' => 'Because' ] );
1774 $this->hook( 'LocalUserCreated', $this->never() );
1775 $ret = $this->manager->continueAccountCreation( [] );
1776 $this->unhook( 'LocalUserCreated' );
1777 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1778 $this->assertSame( 'readonlytext', $ret->message->getKey() );
1779 $this->assertSame( [ 'Because' ], $ret->message->getParams() );
1780 $this->setMwGlobals( [ 'wgReadOnly' => false ] );
1781
1782 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1783 [ 'username' => $creator->getName() ] + $session );
1784 $this->hook( 'LocalUserCreated', $this->never() );
1785 $ret = $this->manager->continueAccountCreation( [] );
1786 $this->unhook( 'LocalUserCreated' );
1787 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1788 $this->assertSame( 'userexists', $ret->message->getKey() );
1789 $this->assertNull(
1790 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1791 );
1792
1793 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1794 [ 'userid' => $creator->getId() ] + $session );
1795 $this->hook( 'LocalUserCreated', $this->never() );
1796 try {
1797 $ret = $this->manager->continueAccountCreation( [] );
1798 $this->fail( 'Expected exception not thrown' );
1799 } catch ( \UnexpectedValueException $ex ) {
1800 $this->assertEquals( "User \"{$username}\" should exist now, but doesn't!", $ex->getMessage() );
1801 }
1802 $this->unhook( 'LocalUserCreated' );
1803 $this->assertNull(
1804 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1805 );
1806
1807 $id = $creator->getId();
1808 $name = $creator->getName();
1809 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1810 [ 'username' => $name, 'userid' => $id + 1 ] + $session );
1811 $this->hook( 'LocalUserCreated', $this->never() );
1812 try {
1813 $ret = $this->manager->continueAccountCreation( [] );
1814 $this->fail( 'Expected exception not thrown' );
1815 } catch ( \UnexpectedValueException $ex ) {
1816 $this->assertEquals(
1817 "User \"{$name}\" exists, but ID $id != " . ( $id + 1 ) . '!', $ex->getMessage()
1818 );
1819 }
1820 $this->unhook( 'LocalUserCreated' );
1821 $this->assertNull(
1822 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1823 );
1824
1825 $req = $this->getMockBuilder( UserDataAuthenticationRequest::class )
1826 ->setMethods( [ 'populateUser' ] )
1827 ->getMock();
1828 $req->expects( $this->any() )->method( 'populateUser' )
1829 ->willReturn( \StatusValue::newFatal( 'populatefail' ) );
1830 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState',
1831 [ 'reqs' => [ $req ] ] + $session );
1832 $ret = $this->manager->continueAccountCreation( [] );
1833 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
1834 $this->assertSame( 'populatefail', $ret->message->getKey() );
1835 $this->assertNull(
1836 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' )
1837 );
1838 }
1839
1840 /**
1841 * @dataProvider provideAccountCreation
1842 * @param StatusValue $preTest
1843 * @param StatusValue $primaryTest
1844 * @param StatusValue $secondaryTest
1845 * @param array $primaryResponses
1846 * @param array $secondaryResponses
1847 * @param array $managerResponses
1848 */
1849 public function testAccountCreation(
1850 StatusValue $preTest, $primaryTest, $secondaryTest,
1851 array $primaryResponses, array $secondaryResponses, array $managerResponses
1852 ) {
1853 $creator = \User::newFromName( 'UTSysop' );
1854 $username = self::usernameForCreation();
1855
1856 $this->initializeManager();
1857
1858 // Set up lots of mocks...
1859 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
1860 $req->preTest = $preTest;
1861 $req->primaryTest = $primaryTest;
1862 $req->secondaryTest = $secondaryTest;
1863 $req->primary = $primaryResponses;
1864 $req->secondary = $secondaryResponses;
1865 $mocks = [];
1866 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
1867 $class = ucfirst( $key ) . 'AuthenticationProvider';
1868 $mocks[$key] = $this->getMockForAbstractClass(
1869 "MediaWiki\\Auth\\$class", [], "Mock$class"
1870 );
1871 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
1872 ->will( $this->returnValue( $key ) );
1873 $mocks[$key]->expects( $this->any() )->method( 'testUserForCreation' )
1874 ->will( $this->returnValue( StatusValue::newGood() ) );
1875 $mocks[$key]->expects( $this->any() )->method( 'testForAccountCreation' )
1876 ->will( $this->returnCallback(
1877 function ( $user, $creatorIn, $reqs )
1878 use ( $username, $creator, $req, $key )
1879 {
1880 $this->assertSame( $username, $user->getName() );
1881 $this->assertSame( $creator->getId(), $creatorIn->getId() );
1882 $this->assertSame( $creator->getName(), $creatorIn->getName() );
1883 $foundReq = false;
1884 foreach ( $reqs as $r ) {
1885 $this->assertSame( $username, $r->username );
1886 $foundReq = $foundReq || get_class( $r ) === get_class( $req );
1887 }
1888 $this->assertTrue( $foundReq, '$reqs contains $req' );
1889 $k = $key . 'Test';
1890 return $req->$k;
1891 }
1892 ) );
1893
1894 for ( $i = 2; $i <= 3; $i++ ) {
1895 $mocks[$key . $i] = $this->getMockForAbstractClass(
1896 "MediaWiki\\Auth\\$class", [], "Mock$class"
1897 );
1898 $mocks[$key . $i]->expects( $this->any() )->method( 'getUniqueId' )
1899 ->will( $this->returnValue( $key . $i ) );
1900 $mocks[$key . $i]->expects( $this->any() )->method( 'testUserForCreation' )
1901 ->will( $this->returnValue( StatusValue::newGood() ) );
1902 $mocks[$key . $i]->expects( $this->atMost( 1 ) )->method( 'testForAccountCreation' )
1903 ->will( $this->returnValue( StatusValue::newGood() ) );
1904 }
1905 }
1906
1907 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
1908 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
1909 $mocks['primary']->expects( $this->any() )->method( 'testUserExists' )
1910 ->will( $this->returnValue( false ) );
1911 $ct = count( $req->primary );
1912 $callback = $this->returnCallback( function ( $user, $creator, $reqs ) use ( $username, $req ) {
1913 $this->assertSame( $username, $user->getName() );
1914 $this->assertSame( 'UTSysop', $creator->getName() );
1915 $foundReq = false;
1916 foreach ( $reqs as $r ) {
1917 $this->assertSame( $username, $r->username );
1918 $foundReq = $foundReq || get_class( $r ) === get_class( $req );
1919 }
1920 $this->assertTrue( $foundReq, '$reqs contains $req' );
1921 return array_shift( $req->primary );
1922 } );
1923 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
1924 ->method( 'beginPrimaryAccountCreation' )
1925 ->will( $callback );
1926 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
1927 ->method( 'continuePrimaryAccountCreation' )
1928 ->will( $callback );
1929
1930 $ct = count( $req->secondary );
1931 $callback = $this->returnCallback( function ( $user, $creator, $reqs ) use ( $username, $req ) {
1932 $this->assertSame( $username, $user->getName() );
1933 $this->assertSame( 'UTSysop', $creator->getName() );
1934 $foundReq = false;
1935 foreach ( $reqs as $r ) {
1936 $this->assertSame( $username, $r->username );
1937 $foundReq = $foundReq || get_class( $r ) === get_class( $req );
1938 }
1939 $this->assertTrue( $foundReq, '$reqs contains $req' );
1940 return array_shift( $req->secondary );
1941 } );
1942 $mocks['secondary']->expects( $this->exactly( min( 1, $ct ) ) )
1943 ->method( 'beginSecondaryAccountCreation' )
1944 ->will( $callback );
1945 $mocks['secondary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
1946 ->method( 'continueSecondaryAccountCreation' )
1947 ->will( $callback );
1948
1949 $abstain = AuthenticationResponse::newAbstain();
1950 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
1951 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
1952 $mocks['primary2']->expects( $this->any() )->method( 'testUserExists' )
1953 ->will( $this->returnValue( false ) );
1954 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAccountCreation' )
1955 ->will( $this->returnValue( $abstain ) );
1956 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAccountCreation' );
1957 $mocks['primary3']->expects( $this->any() )->method( 'accountCreationType' )
1958 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_NONE ) );
1959 $mocks['primary3']->expects( $this->any() )->method( 'testUserExists' )
1960 ->will( $this->returnValue( false ) );
1961 $mocks['primary3']->expects( $this->never() )->method( 'beginPrimaryAccountCreation' );
1962 $mocks['primary3']->expects( $this->never() )->method( 'continuePrimaryAccountCreation' );
1963 $mocks['secondary2']->expects( $this->atMost( 1 ) )
1964 ->method( 'beginSecondaryAccountCreation' )
1965 ->will( $this->returnValue( $abstain ) );
1966 $mocks['secondary2']->expects( $this->never() )->method( 'continueSecondaryAccountCreation' );
1967 $mocks['secondary3']->expects( $this->atMost( 1 ) )
1968 ->method( 'beginSecondaryAccountCreation' )
1969 ->will( $this->returnValue( $abstain ) );
1970 $mocks['secondary3']->expects( $this->never() )->method( 'continueSecondaryAccountCreation' );
1971
1972 $this->preauthMocks = [ $mocks['pre'], $mocks['pre2'] ];
1973 $this->primaryauthMocks = [ $mocks['primary3'], $mocks['primary'], $mocks['primary2'] ];
1974 $this->secondaryauthMocks = [
1975 $mocks['secondary3'], $mocks['secondary'], $mocks['secondary2']
1976 ];
1977
1978 $this->logger = new \TestLogger( true, function ( $message, $level ) {
1979 return $level === LogLevel::DEBUG ? null : $message;
1980 } );
1981 $expectLog = [];
1982 $this->initializeManager( true );
1983
1984 $constraint = \PHPUnit_Framework_Assert::logicalOr(
1985 $this->equalTo( AuthenticationResponse::PASS ),
1986 $this->equalTo( AuthenticationResponse::FAIL )
1987 );
1988 $providers = array_merge(
1989 $this->preauthMocks, $this->primaryauthMocks, $this->secondaryauthMocks
1990 );
1991 foreach ( $providers as $p ) {
1992 $p->postCalled = false;
1993 $p->expects( $this->atMost( 1 ) )->method( 'postAccountCreation' )
1994 ->willReturnCallback( function ( $user, $creator, $response )
1995 use ( $constraint, $p, $username )
1996 {
1997 $this->assertInstanceOf( 'User', $user );
1998 $this->assertSame( $username, $user->getName() );
1999 $this->assertSame( 'UTSysop', $creator->getName() );
2000 $this->assertInstanceOf( AuthenticationResponse::class, $response );
2001 $this->assertThat( $response->status, $constraint );
2002 $p->postCalled = $response->status;
2003 } );
2004 }
2005
2006 // We're testing with $wgNewUserLog = false, so assert that it worked
2007 $dbw = wfGetDB( DB_MASTER );
2008 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2009
2010 $first = true;
2011 $created = false;
2012 foreach ( $managerResponses as $i => $response ) {
2013 $success = $response instanceof AuthenticationResponse &&
2014 $response->status === AuthenticationResponse::PASS;
2015 if ( $i === 'created' ) {
2016 $created = true;
2017 $this->hook( 'LocalUserCreated', $this->once() )
2018 ->with(
2019 $this->callback( function ( $user ) use ( $username ) {
2020 return $user->getName() === $username;
2021 } ),
2022 $this->equalTo( false )
2023 );
2024 $expectLog[] = [ LogLevel::INFO, "Creating user {user} during account creation" ];
2025 } else {
2026 $this->hook( 'LocalUserCreated', $this->never() );
2027 }
2028
2029 $ex = null;
2030 try {
2031 if ( $first ) {
2032 $userReq = new UsernameAuthenticationRequest;
2033 $userReq->username = $username;
2034 $ret = $this->manager->beginAccountCreation(
2035 $creator, [ $userReq, $req ], 'http://localhost/'
2036 );
2037 } else {
2038 $ret = $this->manager->continueAccountCreation( [ $req ] );
2039 }
2040 if ( $response instanceof \Exception ) {
2041 $this->fail( 'Expected exception not thrown', "Response $i" );
2042 }
2043 } catch ( \Exception $ex ) {
2044 if ( !$response instanceof \Exception ) {
2045 throw $ex;
2046 }
2047 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
2048 $this->assertNull(
2049 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2050 "Response $i, exception, session state"
2051 );
2052 $this->unhook( 'LocalUserCreated' );
2053 return;
2054 }
2055
2056 $this->unhook( 'LocalUserCreated' );
2057
2058 $this->assertSame( 'http://localhost/', $req->returnToUrl );
2059
2060 if ( $success ) {
2061 $this->assertNotNull( $ret->loginRequest, "Response $i, login marker" );
2062 $this->assertContains(
2063 $ret->loginRequest, $this->managerPriv->createdAccountAuthenticationRequests,
2064 "Response $i, login marker"
2065 );
2066
2067 $expectLog[] = [
2068 LogLevel::INFO,
2069 "MediaWiki\Auth\AuthManager::continueAccountCreation: Account creation succeeded for {user}"
2070 ];
2071
2072 // Set some fields in the expected $response that we couldn't
2073 // know in provideAccountCreation().
2074 $response->username = $username;
2075 $response->loginRequest = $ret->loginRequest;
2076 } else {
2077 $this->assertNull( $ret->loginRequest, "Response $i, login marker" );
2078 $this->assertSame( [], $this->managerPriv->createdAccountAuthenticationRequests,
2079 "Response $i, login marker" );
2080 }
2081 $ret->message = $this->message( $ret->message );
2082 $this->assertEquals( $response, $ret, "Response $i, response" );
2083 if ( $success || $response->status === AuthenticationResponse::FAIL ) {
2084 $this->assertNull(
2085 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2086 "Response $i, session state"
2087 );
2088 foreach ( $providers as $p ) {
2089 $this->assertSame( $response->status, $p->postCalled,
2090 "Response $i, post-auth callback called" );
2091 }
2092 } else {
2093 $this->assertNotNull(
2094 $this->request->getSession()->getSecret( 'AuthManager::accountCreationState' ),
2095 "Response $i, session state"
2096 );
2097 foreach ( $ret->neededRequests as $neededReq ) {
2098 $this->assertEquals( AuthManager::ACTION_CREATE, $neededReq->action,
2099 "Response $i, neededRequest action" );
2100 }
2101 $this->assertEquals(
2102 $ret->neededRequests,
2103 $this->manager->getAuthenticationRequests( AuthManager::ACTION_CREATE_CONTINUE ),
2104 "Response $i, continuation check"
2105 );
2106 foreach ( $providers as $p ) {
2107 $this->assertFalse( $p->postCalled, "Response $i, post-auth callback not called" );
2108 }
2109 }
2110
2111 if ( $created ) {
2112 $this->assertNotEquals( 0, \User::idFromName( $username ) );
2113 } else {
2114 $this->assertEquals( 0, \User::idFromName( $username ) );
2115 }
2116
2117 $first = false;
2118 }
2119
2120 $this->assertSame( $expectLog, $this->logger->getBuffer() );
2121
2122 $this->assertSame(
2123 $maxLogId,
2124 $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] )
2125 );
2126 }
2127
2128 public function provideAccountCreation() {
2129 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
2130 $good = StatusValue::newGood();
2131
2132 return [
2133 'Pre-creation test fail in pre' => [
2134 StatusValue::newFatal( 'fail-from-pre' ), $good, $good,
2135 [],
2136 [],
2137 [
2138 AuthenticationResponse::newFail( $this->message( 'fail-from-pre' ) ),
2139 ]
2140 ],
2141 'Pre-creation test fail in primary' => [
2142 $good, StatusValue::newFatal( 'fail-from-primary' ), $good,
2143 [],
2144 [],
2145 [
2146 AuthenticationResponse::newFail( $this->message( 'fail-from-primary' ) ),
2147 ]
2148 ],
2149 'Pre-creation test fail in secondary' => [
2150 $good, $good, StatusValue::newFatal( 'fail-from-secondary' ),
2151 [],
2152 [],
2153 [
2154 AuthenticationResponse::newFail( $this->message( 'fail-from-secondary' ) ),
2155 ]
2156 ],
2157 'Failure in primary' => [
2158 $good, $good, $good,
2159 $tmp = [
2160 AuthenticationResponse::newFail( $this->message( 'fail-from-primary' ) ),
2161 ],
2162 [],
2163 $tmp
2164 ],
2165 'All primary abstain' => [
2166 $good, $good, $good,
2167 [
2168 AuthenticationResponse::newAbstain(),
2169 ],
2170 [],
2171 [
2172 AuthenticationResponse::newFail( $this->message( 'authmanager-create-no-primary' ) )
2173 ]
2174 ],
2175 'Primary UI, then redirect, then fail' => [
2176 $good, $good, $good,
2177 $tmp = [
2178 AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
2179 AuthenticationResponse::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
2180 AuthenticationResponse::newFail( $this->message( 'fail-in-primary-continue' ) ),
2181 ],
2182 [],
2183 $tmp
2184 ],
2185 'Primary redirect, then abstain' => [
2186 $good, $good, $good,
2187 [
2188 $tmp = AuthenticationResponse::newRedirect(
2189 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
2190 ),
2191 AuthenticationResponse::newAbstain(),
2192 ],
2193 [],
2194 [
2195 $tmp,
2196 new \DomainException(
2197 'MockPrimaryAuthenticationProvider::continuePrimaryAccountCreation() returned ABSTAIN'
2198 )
2199 ]
2200 ],
2201 'Primary UI, then pass; secondary abstain' => [
2202 $good, $good, $good,
2203 [
2204 $tmp1 = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
2205 AuthenticationResponse::newPass(),
2206 ],
2207 [
2208 AuthenticationResponse::newAbstain(),
2209 ],
2210 [
2211 $tmp1,
2212 'created' => AuthenticationResponse::newPass( '' ),
2213 ]
2214 ],
2215 'Primary pass; secondary UI then pass' => [
2216 $good, $good, $good,
2217 [
2218 AuthenticationResponse::newPass( '' ),
2219 ],
2220 [
2221 $tmp1 = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
2222 AuthenticationResponse::newPass( '' ),
2223 ],
2224 [
2225 'created' => $tmp1,
2226 AuthenticationResponse::newPass( '' ),
2227 ]
2228 ],
2229 'Primary pass; secondary fail' => [
2230 $good, $good, $good,
2231 [
2232 AuthenticationResponse::newPass(),
2233 ],
2234 [
2235 AuthenticationResponse::newFail( $this->message( '...' ) ),
2236 ],
2237 [
2238 'created' => new \DomainException(
2239 'MockSecondaryAuthenticationProvider::beginSecondaryAccountCreation() returned FAIL. ' .
2240 'Secondary providers are not allowed to fail account creation, ' .
2241 'that should have been done via testForAccountCreation().'
2242 )
2243 ]
2244 ],
2245 ];
2246 }
2247
2248 /**
2249 * @dataProvider provideAccountCreationLogging
2250 * @param bool $isAnon
2251 * @param string|null $logSubtype
2252 */
2253 public function testAccountCreationLogging( $isAnon, $logSubtype ) {
2254 $creator = $isAnon ? new \User : \User::newFromName( 'UTSysop' );
2255 $username = self::usernameForCreation();
2256
2257 $this->initializeManager();
2258
2259 // Set up lots of mocks...
2260 $mock = $this->getMockForAbstractClass(
2261 "MediaWiki\\Auth\\PrimaryAuthenticationProvider", []
2262 );
2263 $mock->expects( $this->any() )->method( 'getUniqueId' )
2264 ->will( $this->returnValue( 'primary' ) );
2265 $mock->expects( $this->any() )->method( 'testUserForCreation' )
2266 ->will( $this->returnValue( StatusValue::newGood() ) );
2267 $mock->expects( $this->any() )->method( 'testForAccountCreation' )
2268 ->will( $this->returnValue( StatusValue::newGood() ) );
2269 $mock->expects( $this->any() )->method( 'accountCreationType' )
2270 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
2271 $mock->expects( $this->any() )->method( 'testUserExists' )
2272 ->will( $this->returnValue( false ) );
2273 $mock->expects( $this->any() )->method( 'beginPrimaryAccountCreation' )
2274 ->will( $this->returnValue( AuthenticationResponse::newPass( $username ) ) );
2275 $mock->expects( $this->any() )->method( 'finishAccountCreation' )
2276 ->will( $this->returnValue( $logSubtype ) );
2277
2278 $this->primaryauthMocks = [ $mock ];
2279 $this->initializeManager( true );
2280 $this->logger->setCollect( true );
2281
2282 $this->config->set( 'NewUserLog', true );
2283
2284 $dbw = wfGetDB( DB_MASTER );
2285 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2286
2287 $userReq = new UsernameAuthenticationRequest;
2288 $userReq->username = $username;
2289 $reasonReq = new CreationReasonAuthenticationRequest;
2290 $reasonReq->reason = $this->toString();
2291 $ret = $this->manager->beginAccountCreation(
2292 $creator, [ $userReq, $reasonReq ], 'http://localhost/'
2293 );
2294
2295 $this->assertSame( AuthenticationResponse::PASS, $ret->status );
2296
2297 $user = \User::newFromName( $username );
2298 $this->assertNotEquals( 0, $user->getId(), 'sanity check' );
2299 $this->assertNotEquals( $creator->getId(), $user->getId(), 'sanity check' );
2300
2301 $data = \DatabaseLogEntry::getSelectQueryData();
2302 $rows = iterator_to_array( $dbw->select(
2303 $data['tables'],
2304 $data['fields'],
2305 [
2306 'log_id > ' . (int)$maxLogId,
2307 'log_type' => 'newusers'
2308 ] + $data['conds'],
2309 __METHOD__,
2310 $data['options'],
2311 $data['join_conds']
2312 ) );
2313 $this->assertCount( 1, $rows );
2314 $entry = \DatabaseLogEntry::newFromRow( reset( $rows ) );
2315
2316 $this->assertSame( $logSubtype ?: ( $isAnon ? 'create' : 'create2' ), $entry->getSubtype() );
2317 $this->assertSame(
2318 $isAnon ? $user->getId() : $creator->getId(),
2319 $entry->getPerformer()->getId()
2320 );
2321 $this->assertSame(
2322 $isAnon ? $user->getName() : $creator->getName(),
2323 $entry->getPerformer()->getName()
2324 );
2325 $this->assertSame( $user->getUserPage()->getFullText(), $entry->getTarget()->getFullText() );
2326 $this->assertSame( [ '4::userid' => $user->getId() ], $entry->getParameters() );
2327 $this->assertSame( $this->toString(), $entry->getComment() );
2328 }
2329
2330 public static function provideAccountCreationLogging() {
2331 return [
2332 [ true, null ],
2333 [ true, 'foobar' ],
2334 [ false, null ],
2335 [ false, 'byemail' ],
2336 ];
2337 }
2338
2339 public function testAutoAccountCreation() {
2340 global $wgGroupPermissions, $wgHooks;
2341
2342 // PHPUnit seems to have a bug where it will call the ->with()
2343 // callbacks for our hooks again after the test is run (WTF?), which
2344 // breaks here because $username no longer matches $user by the end of
2345 // the testing.
2346 $workaroundPHPUnitBug = false;
2347
2348 $username = self::usernameForCreation();
2349 $this->initializeManager();
2350
2351 $this->stashMwGlobals( [ 'wgGroupPermissions' ] );
2352 $wgGroupPermissions['*']['createaccount'] = true;
2353 $wgGroupPermissions['*']['autocreateaccount'] = false;
2354
2355 \ObjectCache::$instances[__METHOD__] = new \HashBagOStuff();
2356 $this->setMwGlobals( [ 'wgMainCacheType' => __METHOD__ ] );
2357
2358 // Set up lots of mocks...
2359 $mocks = [];
2360 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
2361 $class = ucfirst( $key ) . 'AuthenticationProvider';
2362 $mocks[$key] = $this->getMockForAbstractClass(
2363 "MediaWiki\\Auth\\$class", [], "Mock$class"
2364 );
2365 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
2366 ->will( $this->returnValue( $key ) );
2367 }
2368
2369 $good = StatusValue::newGood();
2370 $callback = $this->callback( function ( $user ) use ( &$username, &$workaroundPHPUnitBug ) {
2371 return $workaroundPHPUnitBug || $user->getName() === $username;
2372 } );
2373
2374 $mocks['pre']->expects( $this->exactly( 12 ) )->method( 'testUserForCreation' )
2375 ->with( $callback, $this->identicalTo( AuthManager::AUTOCREATE_SOURCE_SESSION ) )
2376 ->will( $this->onConsecutiveCalls(
2377 StatusValue::newFatal( 'ok' ), StatusValue::newFatal( 'ok' ), // For testing permissions
2378 StatusValue::newFatal( 'fail-in-pre' ), $good, $good,
2379 $good, // backoff test
2380 $good, // addToDatabase fails test
2381 $good, // addToDatabase throws test
2382 $good, // addToDatabase exists test
2383 $good, $good, $good // success
2384 ) );
2385
2386 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
2387 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
2388 $mocks['primary']->expects( $this->any() )->method( 'testUserExists' )
2389 ->will( $this->returnValue( true ) );
2390 $mocks['primary']->expects( $this->exactly( 9 ) )->method( 'testUserForCreation' )
2391 ->with( $callback, $this->identicalTo( AuthManager::AUTOCREATE_SOURCE_SESSION ) )
2392 ->will( $this->onConsecutiveCalls(
2393 StatusValue::newFatal( 'fail-in-primary' ), $good,
2394 $good, // backoff test
2395 $good, // addToDatabase fails test
2396 $good, // addToDatabase throws test
2397 $good, // addToDatabase exists test
2398 $good, $good, $good
2399 ) );
2400 $mocks['primary']->expects( $this->exactly( 3 ) )->method( 'autoCreatedAccount' )
2401 ->with( $callback, $this->identicalTo( AuthManager::AUTOCREATE_SOURCE_SESSION ) );
2402
2403 $mocks['secondary']->expects( $this->exactly( 8 ) )->method( 'testUserForCreation' )
2404 ->with( $callback, $this->identicalTo( AuthManager::AUTOCREATE_SOURCE_SESSION ) )
2405 ->will( $this->onConsecutiveCalls(
2406 StatusValue::newFatal( 'fail-in-secondary' ),
2407 $good, // backoff test
2408 $good, // addToDatabase fails test
2409 $good, // addToDatabase throws test
2410 $good, // addToDatabase exists test
2411 $good, $good, $good
2412 ) );
2413 $mocks['secondary']->expects( $this->exactly( 3 ) )->method( 'autoCreatedAccount' )
2414 ->with( $callback, $this->identicalTo( AuthManager::AUTOCREATE_SOURCE_SESSION ) );
2415
2416 $this->preauthMocks = [ $mocks['pre'] ];
2417 $this->primaryauthMocks = [ $mocks['primary'] ];
2418 $this->secondaryauthMocks = [ $mocks['secondary'] ];
2419 $this->initializeManager( true );
2420 $session = $this->request->getSession();
2421
2422 $logger = new \TestLogger( true, function ( $m ) {
2423 $m = str_replace( 'MediaWiki\\Auth\\AuthManager::autoCreateUser: ', '', $m );
2424 return $m;
2425 } );
2426 $this->manager->setLogger( $logger );
2427
2428 try {
2429 $user = \User::newFromName( 'UTSysop' );
2430 $this->manager->autoCreateUser( $user, 'InvalidSource', true );
2431 $this->fail( 'Expected exception not thrown' );
2432 } catch ( \InvalidArgumentException $ex ) {
2433 $this->assertSame( 'Unknown auto-creation source: InvalidSource', $ex->getMessage() );
2434 }
2435
2436 // First, check an existing user
2437 $session->clear();
2438 $user = \User::newFromName( 'UTSysop' );
2439 $this->hook( 'LocalUserCreated', $this->never() );
2440 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2441 $this->unhook( 'LocalUserCreated' );
2442 $expect = \Status::newGood();
2443 $expect->warning( 'userexists' );
2444 $this->assertEquals( $expect, $ret );
2445 $this->assertNotEquals( 0, $user->getId() );
2446 $this->assertSame( 'UTSysop', $user->getName() );
2447 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2448 $this->assertSame( [
2449 [ LogLevel::DEBUG, '{username} already exists locally' ],
2450 ], $logger->getBuffer() );
2451 $logger->clearBuffer();
2452
2453 $session->clear();
2454 $user = \User::newFromName( 'UTSysop' );
2455 $this->hook( 'LocalUserCreated', $this->never() );
2456 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, false );
2457 $this->unhook( 'LocalUserCreated' );
2458 $expect = \Status::newGood();
2459 $expect->warning( 'userexists' );
2460 $this->assertEquals( $expect, $ret );
2461 $this->assertNotEquals( 0, $user->getId() );
2462 $this->assertSame( 'UTSysop', $user->getName() );
2463 $this->assertEquals( 0, $session->getUser()->getId() );
2464 $this->assertSame( [
2465 [ LogLevel::DEBUG, '{username} already exists locally' ],
2466 ], $logger->getBuffer() );
2467 $logger->clearBuffer();
2468
2469 // Wiki is read-only
2470 $session->clear();
2471 $this->setMwGlobals( [ 'wgReadOnly' => 'Because' ] );
2472 $user = \User::newFromName( $username );
2473 $this->hook( 'LocalUserCreated', $this->never() );
2474 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2475 $this->unhook( 'LocalUserCreated' );
2476 $this->assertEquals( \Status::newFatal( 'readonlytext', 'Because' ), $ret );
2477 $this->assertEquals( 0, $user->getId() );
2478 $this->assertNotEquals( $username, $user->getName() );
2479 $this->assertEquals( 0, $session->getUser()->getId() );
2480 $this->assertSame( [
2481 [ LogLevel::DEBUG, 'denied by wfReadOnly(): {reason}' ],
2482 ], $logger->getBuffer() );
2483 $logger->clearBuffer();
2484 $this->setMwGlobals( [ 'wgReadOnly' => false ] );
2485
2486 // Session blacklisted
2487 $session->clear();
2488 $session->set( 'AuthManager::AutoCreateBlacklist', 'test' );
2489 $user = \User::newFromName( $username );
2490 $this->hook( 'LocalUserCreated', $this->never() );
2491 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2492 $this->unhook( 'LocalUserCreated' );
2493 $this->assertEquals( \Status::newFatal( 'test' ), $ret );
2494 $this->assertEquals( 0, $user->getId() );
2495 $this->assertNotEquals( $username, $user->getName() );
2496 $this->assertEquals( 0, $session->getUser()->getId() );
2497 $this->assertSame( [
2498 [ LogLevel::DEBUG, 'blacklisted in session {sessionid}' ],
2499 ], $logger->getBuffer() );
2500 $logger->clearBuffer();
2501
2502 $session->clear();
2503 $session->set( 'AuthManager::AutoCreateBlacklist', StatusValue::newFatal( 'test2' ) );
2504 $user = \User::newFromName( $username );
2505 $this->hook( 'LocalUserCreated', $this->never() );
2506 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2507 $this->unhook( 'LocalUserCreated' );
2508 $this->assertEquals( \Status::newFatal( 'test2' ), $ret );
2509 $this->assertEquals( 0, $user->getId() );
2510 $this->assertNotEquals( $username, $user->getName() );
2511 $this->assertEquals( 0, $session->getUser()->getId() );
2512 $this->assertSame( [
2513 [ LogLevel::DEBUG, 'blacklisted in session {sessionid}' ],
2514 ], $logger->getBuffer() );
2515 $logger->clearBuffer();
2516
2517 // Uncreatable name
2518 $session->clear();
2519 $user = \User::newFromName( $username . '@' );
2520 $this->hook( 'LocalUserCreated', $this->never() );
2521 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2522 $this->unhook( 'LocalUserCreated' );
2523 $this->assertEquals( \Status::newFatal( 'noname' ), $ret );
2524 $this->assertEquals( 0, $user->getId() );
2525 $this->assertNotEquals( $username . '@', $user->getId() );
2526 $this->assertEquals( 0, $session->getUser()->getId() );
2527 $this->assertSame( [
2528 [ LogLevel::DEBUG, 'name "{username}" is not creatable' ],
2529 ], $logger->getBuffer() );
2530 $logger->clearBuffer();
2531 $this->assertSame( 'noname', $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2532
2533 // IP unable to create accounts
2534 $wgGroupPermissions['*']['createaccount'] = false;
2535 $wgGroupPermissions['*']['autocreateaccount'] = false;
2536 $session->clear();
2537 $user = \User::newFromName( $username );
2538 $this->hook( 'LocalUserCreated', $this->never() );
2539 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2540 $this->unhook( 'LocalUserCreated' );
2541 $this->assertEquals( \Status::newFatal( 'authmanager-autocreate-noperm' ), $ret );
2542 $this->assertEquals( 0, $user->getId() );
2543 $this->assertNotEquals( $username, $user->getName() );
2544 $this->assertEquals( 0, $session->getUser()->getId() );
2545 $this->assertSame( [
2546 [ LogLevel::DEBUG, 'IP lacks the ability to create or autocreate accounts' ],
2547 ], $logger->getBuffer() );
2548 $logger->clearBuffer();
2549 $this->assertSame(
2550 'authmanager-autocreate-noperm', $session->get( 'AuthManager::AutoCreateBlacklist' )
2551 );
2552
2553 // Test that both permutations of permissions are allowed
2554 // (this hits the two "ok" entries in $mocks['pre'])
2555 $wgGroupPermissions['*']['createaccount'] = false;
2556 $wgGroupPermissions['*']['autocreateaccount'] = true;
2557 $session->clear();
2558 $user = \User::newFromName( $username );
2559 $this->hook( 'LocalUserCreated', $this->never() );
2560 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2561 $this->unhook( 'LocalUserCreated' );
2562 $this->assertEquals( \Status::newFatal( 'ok' ), $ret );
2563
2564 $wgGroupPermissions['*']['createaccount'] = true;
2565 $wgGroupPermissions['*']['autocreateaccount'] = false;
2566 $session->clear();
2567 $user = \User::newFromName( $username );
2568 $this->hook( 'LocalUserCreated', $this->never() );
2569 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2570 $this->unhook( 'LocalUserCreated' );
2571 $this->assertEquals( \Status::newFatal( 'ok' ), $ret );
2572 $logger->clearBuffer();
2573
2574 // Test lock fail
2575 $session->clear();
2576 $user = \User::newFromName( $username );
2577 $this->hook( 'LocalUserCreated', $this->never() );
2578 $cache = \ObjectCache::getLocalClusterInstance();
2579 $lock = $cache->getScopedLock( $cache->makeGlobalKey( 'account', md5( $username ) ) );
2580 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2581 unset( $lock );
2582 $this->unhook( 'LocalUserCreated' );
2583 $this->assertEquals( \Status::newFatal( 'usernameinprogress' ), $ret );
2584 $this->assertEquals( 0, $user->getId() );
2585 $this->assertNotEquals( $username, $user->getName() );
2586 $this->assertEquals( 0, $session->getUser()->getId() );
2587 $this->assertSame( [
2588 [ LogLevel::DEBUG, 'Could not acquire account creation lock' ],
2589 ], $logger->getBuffer() );
2590 $logger->clearBuffer();
2591
2592 // Test pre-authentication provider fail
2593 $session->clear();
2594 $user = \User::newFromName( $username );
2595 $this->hook( 'LocalUserCreated', $this->never() );
2596 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2597 $this->unhook( 'LocalUserCreated' );
2598 $this->assertEquals( \Status::newFatal( 'fail-in-pre' ), $ret );
2599 $this->assertEquals( 0, $user->getId() );
2600 $this->assertNotEquals( $username, $user->getName() );
2601 $this->assertEquals( 0, $session->getUser()->getId() );
2602 $this->assertSame( [
2603 [ LogLevel::DEBUG, 'Provider denied creation of {username}: {reason}' ],
2604 ], $logger->getBuffer() );
2605 $logger->clearBuffer();
2606 $this->assertEquals(
2607 StatusValue::newFatal( 'fail-in-pre' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2608 );
2609
2610 $session->clear();
2611 $user = \User::newFromName( $username );
2612 $this->hook( 'LocalUserCreated', $this->never() );
2613 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2614 $this->unhook( 'LocalUserCreated' );
2615 $this->assertEquals( \Status::newFatal( 'fail-in-primary' ), $ret );
2616 $this->assertEquals( 0, $user->getId() );
2617 $this->assertNotEquals( $username, $user->getName() );
2618 $this->assertEquals( 0, $session->getUser()->getId() );
2619 $this->assertSame( [
2620 [ LogLevel::DEBUG, 'Provider denied creation of {username}: {reason}' ],
2621 ], $logger->getBuffer() );
2622 $logger->clearBuffer();
2623 $this->assertEquals(
2624 StatusValue::newFatal( 'fail-in-primary' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2625 );
2626
2627 $session->clear();
2628 $user = \User::newFromName( $username );
2629 $this->hook( 'LocalUserCreated', $this->never() );
2630 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2631 $this->unhook( 'LocalUserCreated' );
2632 $this->assertEquals( \Status::newFatal( 'fail-in-secondary' ), $ret );
2633 $this->assertEquals( 0, $user->getId() );
2634 $this->assertNotEquals( $username, $user->getName() );
2635 $this->assertEquals( 0, $session->getUser()->getId() );
2636 $this->assertSame( [
2637 [ LogLevel::DEBUG, 'Provider denied creation of {username}: {reason}' ],
2638 ], $logger->getBuffer() );
2639 $logger->clearBuffer();
2640 $this->assertEquals(
2641 StatusValue::newFatal( 'fail-in-secondary' ), $session->get( 'AuthManager::AutoCreateBlacklist' )
2642 );
2643
2644 // Test backoff
2645 $cache = \ObjectCache::getLocalClusterInstance();
2646 $backoffKey = wfMemcKey( 'AuthManager', 'autocreate-failed', md5( $username ) );
2647 $cache->set( $backoffKey, true );
2648 $session->clear();
2649 $user = \User::newFromName( $username );
2650 $this->hook( 'LocalUserCreated', $this->never() );
2651 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2652 $this->unhook( 'LocalUserCreated' );
2653 $this->assertEquals( \Status::newFatal( 'authmanager-autocreate-exception' ), $ret );
2654 $this->assertEquals( 0, $user->getId() );
2655 $this->assertNotEquals( $username, $user->getName() );
2656 $this->assertEquals( 0, $session->getUser()->getId() );
2657 $this->assertSame( [
2658 [ LogLevel::DEBUG, '{username} denied by prior creation attempt failures' ],
2659 ], $logger->getBuffer() );
2660 $logger->clearBuffer();
2661 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2662 $cache->delete( $backoffKey );
2663
2664 // Test addToDatabase fails
2665 $session->clear();
2666 $user = $this->getMockBuilder( 'User' )
2667 ->setMethods( [ 'addToDatabase' ] )->getMock();
2668 $user->expects( $this->once() )->method( 'addToDatabase' )
2669 ->will( $this->returnValue( \Status::newFatal( 'because' ) ) );
2670 $user->setName( $username );
2671 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2672 $this->assertEquals( \Status::newFatal( 'because' ), $ret );
2673 $this->assertEquals( 0, $user->getId() );
2674 $this->assertNotEquals( $username, $user->getName() );
2675 $this->assertEquals( 0, $session->getUser()->getId() );
2676 $this->assertSame( [
2677 [ LogLevel::INFO, 'creating new user ({username}) - from: {from}' ],
2678 [ LogLevel::ERROR, '{username} failed with message {msg}' ],
2679 ], $logger->getBuffer() );
2680 $logger->clearBuffer();
2681 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2682
2683 // Test addToDatabase throws an exception
2684 $cache = \ObjectCache::getLocalClusterInstance();
2685 $backoffKey = wfMemcKey( 'AuthManager', 'autocreate-failed', md5( $username ) );
2686 $this->assertFalse( $cache->get( $backoffKey ), 'sanity check' );
2687 $session->clear();
2688 $user = $this->getMockBuilder( 'User' )
2689 ->setMethods( [ 'addToDatabase' ] )->getMock();
2690 $user->expects( $this->once() )->method( 'addToDatabase' )
2691 ->will( $this->throwException( new \Exception( 'Excepted' ) ) );
2692 $user->setName( $username );
2693 try {
2694 $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2695 $this->fail( 'Expected exception not thrown' );
2696 } catch ( \Exception $ex ) {
2697 $this->assertSame( 'Excepted', $ex->getMessage() );
2698 }
2699 $this->assertEquals( 0, $user->getId() );
2700 $this->assertEquals( 0, $session->getUser()->getId() );
2701 $this->assertSame( [
2702 [ LogLevel::INFO, 'creating new user ({username}) - from: {from}' ],
2703 [ LogLevel::ERROR, '{username} failed with exception {exception}' ],
2704 ], $logger->getBuffer() );
2705 $logger->clearBuffer();
2706 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2707 $this->assertNotEquals( false, $cache->get( $backoffKey ) );
2708 $cache->delete( $backoffKey );
2709
2710 // Test addToDatabase fails because the user already exists.
2711 $session->clear();
2712 $user = $this->getMockBuilder( 'User' )
2713 ->setMethods( [ 'addToDatabase' ] )->getMock();
2714 $user->expects( $this->once() )->method( 'addToDatabase' )
2715 ->will( $this->returnCallback( function () use ( $username, &$user ) {
2716 $oldUser = \User::newFromName( $username );
2717 $status = $oldUser->addToDatabase();
2718 $this->assertTrue( $status->isOK(), 'sanity check' );
2719 $user->setId( $oldUser->getId() );
2720 return \Status::newFatal( 'userexists' );
2721 } ) );
2722 $user->setName( $username );
2723 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2724 $expect = \Status::newGood();
2725 $expect->warning( 'userexists' );
2726 $this->assertEquals( $expect, $ret );
2727 $this->assertNotEquals( 0, $user->getId() );
2728 $this->assertEquals( $username, $user->getName() );
2729 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2730 $this->assertSame( [
2731 [ LogLevel::INFO, 'creating new user ({username}) - from: {from}' ],
2732 [ LogLevel::INFO, '{username} already exists locally (race)' ],
2733 ], $logger->getBuffer() );
2734 $logger->clearBuffer();
2735 $this->assertSame( null, $session->get( 'AuthManager::AutoCreateBlacklist' ) );
2736
2737 // Success!
2738 $session->clear();
2739 $username = self::usernameForCreation();
2740 $user = \User::newFromName( $username );
2741 $this->hook( 'AuthPluginAutoCreate', $this->once() )
2742 ->with( $callback );
2743 $this->hideDeprecated( 'AuthPluginAutoCreate hook (used in ' .
2744 get_class( $wgHooks['AuthPluginAutoCreate'][0] ) . '::onAuthPluginAutoCreate)' );
2745 $this->hook( 'LocalUserCreated', $this->once() )
2746 ->with( $callback, $this->equalTo( true ) );
2747 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, true );
2748 $this->unhook( 'LocalUserCreated' );
2749 $this->unhook( 'AuthPluginAutoCreate' );
2750 $this->assertEquals( \Status::newGood(), $ret );
2751 $this->assertNotEquals( 0, $user->getId() );
2752 $this->assertEquals( $username, $user->getName() );
2753 $this->assertEquals( $user->getId(), $session->getUser()->getId() );
2754 $this->assertSame( [
2755 [ LogLevel::INFO, 'creating new user ({username}) - from: {from}' ],
2756 ], $logger->getBuffer() );
2757 $logger->clearBuffer();
2758
2759 $dbw = wfGetDB( DB_MASTER );
2760 $maxLogId = $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] );
2761 $session->clear();
2762 $username = self::usernameForCreation();
2763 $user = \User::newFromName( $username );
2764 $this->hook( 'LocalUserCreated', $this->once() )
2765 ->with( $callback, $this->equalTo( true ) );
2766 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, false );
2767 $this->unhook( 'LocalUserCreated' );
2768 $this->assertEquals( \Status::newGood(), $ret );
2769 $this->assertNotEquals( 0, $user->getId() );
2770 $this->assertEquals( $username, $user->getName() );
2771 $this->assertEquals( 0, $session->getUser()->getId() );
2772 $this->assertSame( [
2773 [ LogLevel::INFO, 'creating new user ({username}) - from: {from}' ],
2774 ], $logger->getBuffer() );
2775 $logger->clearBuffer();
2776 $this->assertSame(
2777 $maxLogId,
2778 $dbw->selectField( 'logging', 'MAX(log_id)', [ 'log_type' => 'newusers' ] )
2779 );
2780
2781 $this->config->set( 'NewUserLog', true );
2782 $session->clear();
2783 $username = self::usernameForCreation();
2784 $user = \User::newFromName( $username );
2785 $ret = $this->manager->autoCreateUser( $user, AuthManager::AUTOCREATE_SOURCE_SESSION, false );
2786 $this->assertEquals( \Status::newGood(), $ret );
2787 $logger->clearBuffer();
2788
2789 $data = \DatabaseLogEntry::getSelectQueryData();
2790 $rows = iterator_to_array( $dbw->select(
2791 $data['tables'],
2792 $data['fields'],
2793 [
2794 'log_id > ' . (int)$maxLogId,
2795 'log_type' => 'newusers'
2796 ] + $data['conds'],
2797 __METHOD__,
2798 $data['options'],
2799 $data['join_conds']
2800 ) );
2801 $this->assertCount( 1, $rows );
2802 $entry = \DatabaseLogEntry::newFromRow( reset( $rows ) );
2803
2804 $this->assertSame( 'autocreate', $entry->getSubtype() );
2805 $this->assertSame( $user->getId(), $entry->getPerformer()->getId() );
2806 $this->assertSame( $user->getName(), $entry->getPerformer()->getName() );
2807 $this->assertSame( $user->getUserPage()->getFullText(), $entry->getTarget()->getFullText() );
2808 $this->assertSame( [ '4::userid' => $user->getId() ], $entry->getParameters() );
2809
2810 $workaroundPHPUnitBug = true;
2811 }
2812
2813 /**
2814 * @dataProvider provideGetAuthenticationRequests
2815 * @param string $action
2816 * @param array $expect
2817 * @param array $state
2818 */
2819 public function testGetAuthenticationRequests( $action, $expect, $state = [] ) {
2820 $makeReq = function ( $key ) use ( $action ) {
2821 $req = $this->createMock( AuthenticationRequest::class );
2822 $req->expects( $this->any() )->method( 'getUniqueId' )
2823 ->will( $this->returnValue( $key ) );
2824 $req->action = $action === AuthManager::ACTION_UNLINK ? AuthManager::ACTION_REMOVE : $action;
2825 $req->key = $key;
2826 return $req;
2827 };
2828 $cmpReqs = function ( $a, $b ) {
2829 $ret = strcmp( get_class( $a ), get_class( $b ) );
2830 if ( !$ret ) {
2831 $ret = strcmp( $a->key, $b->key );
2832 }
2833 return $ret;
2834 };
2835
2836 $good = StatusValue::newGood();
2837
2838 $mocks = [];
2839 foreach ( [ 'pre', 'primary', 'secondary' ] as $key ) {
2840 $class = ucfirst( $key ) . 'AuthenticationProvider';
2841 $mocks[$key] = $this->getMockForAbstractClass(
2842 "MediaWiki\\Auth\\$class", [], "Mock$class"
2843 );
2844 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
2845 ->will( $this->returnValue( $key ) );
2846 $mocks[$key]->expects( $this->any() )->method( 'getAuthenticationRequests' )
2847 ->will( $this->returnCallback( function ( $action ) use ( $key, $makeReq ) {
2848 return [ $makeReq( "$key-$action" ), $makeReq( 'generic' ) ];
2849 } ) );
2850 $mocks[$key]->expects( $this->any() )->method( 'providerAllowsAuthenticationDataChange' )
2851 ->will( $this->returnValue( $good ) );
2852 }
2853
2854 $primaries = [];
2855 foreach ( [
2856 PrimaryAuthenticationProvider::TYPE_NONE,
2857 PrimaryAuthenticationProvider::TYPE_CREATE,
2858 PrimaryAuthenticationProvider::TYPE_LINK
2859 ] as $type ) {
2860 $class = 'PrimaryAuthenticationProvider';
2861 $mocks["primary-$type"] = $this->getMockForAbstractClass(
2862 "MediaWiki\\Auth\\$class", [], "Mock$class"
2863 );
2864 $mocks["primary-$type"]->expects( $this->any() )->method( 'getUniqueId' )
2865 ->will( $this->returnValue( "primary-$type" ) );
2866 $mocks["primary-$type"]->expects( $this->any() )->method( 'accountCreationType' )
2867 ->will( $this->returnValue( $type ) );
2868 $mocks["primary-$type"]->expects( $this->any() )->method( 'getAuthenticationRequests' )
2869 ->will( $this->returnCallback( function ( $action ) use ( $type, $makeReq ) {
2870 return [ $makeReq( "primary-$type-$action" ), $makeReq( 'generic' ) ];
2871 } ) );
2872 $mocks["primary-$type"]->expects( $this->any() )
2873 ->method( 'providerAllowsAuthenticationDataChange' )
2874 ->will( $this->returnValue( $good ) );
2875 $this->primaryauthMocks[] = $mocks["primary-$type"];
2876 }
2877
2878 $mocks['primary2'] = $this->getMockForAbstractClass(
2879 PrimaryAuthenticationProvider::class, [], "MockPrimaryAuthenticationProvider"
2880 );
2881 $mocks['primary2']->expects( $this->any() )->method( 'getUniqueId' )
2882 ->will( $this->returnValue( 'primary2' ) );
2883 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
2884 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
2885 $mocks['primary2']->expects( $this->any() )->method( 'getAuthenticationRequests' )
2886 ->will( $this->returnValue( [] ) );
2887 $mocks['primary2']->expects( $this->any() )
2888 ->method( 'providerAllowsAuthenticationDataChange' )
2889 ->will( $this->returnCallback( function ( $req ) use ( $good ) {
2890 return $req->key === 'generic' ? StatusValue::newFatal( 'no' ) : $good;
2891 } ) );
2892 $this->primaryauthMocks[] = $mocks['primary2'];
2893
2894 $this->preauthMocks = [ $mocks['pre'] ];
2895 $this->secondaryauthMocks = [ $mocks['secondary'] ];
2896 $this->initializeManager( true );
2897
2898 if ( $state ) {
2899 if ( isset( $state['continueRequests'] ) ) {
2900 $state['continueRequests'] = array_map( $makeReq, $state['continueRequests'] );
2901 }
2902 if ( $action === AuthManager::ACTION_LOGIN_CONTINUE ) {
2903 $this->request->getSession()->setSecret( 'AuthManager::authnState', $state );
2904 } elseif ( $action === AuthManager::ACTION_CREATE_CONTINUE ) {
2905 $this->request->getSession()->setSecret( 'AuthManager::accountCreationState', $state );
2906 } elseif ( $action === AuthManager::ACTION_LINK_CONTINUE ) {
2907 $this->request->getSession()->setSecret( 'AuthManager::accountLinkState', $state );
2908 }
2909 }
2910
2911 $expectReqs = array_map( $makeReq, $expect );
2912 if ( $action === AuthManager::ACTION_LOGIN ) {
2913 $req = new RememberMeAuthenticationRequest;
2914 $req->action = $action;
2915 $req->required = AuthenticationRequest::REQUIRED;
2916 $expectReqs[] = $req;
2917 } elseif ( $action === AuthManager::ACTION_CREATE ) {
2918 $req = new UsernameAuthenticationRequest;
2919 $req->action = $action;
2920 $expectReqs[] = $req;
2921 $req = new UserDataAuthenticationRequest;
2922 $req->action = $action;
2923 $req->required = AuthenticationRequest::REQUIRED;
2924 $expectReqs[] = $req;
2925 }
2926 usort( $expectReqs, $cmpReqs );
2927
2928 $actual = $this->manager->getAuthenticationRequests( $action );
2929 foreach ( $actual as $req ) {
2930 // Don't test this here.
2931 $req->required = AuthenticationRequest::REQUIRED;
2932 }
2933 usort( $actual, $cmpReqs );
2934
2935 $this->assertEquals( $expectReqs, $actual );
2936
2937 // Test CreationReasonAuthenticationRequest gets returned
2938 if ( $action === AuthManager::ACTION_CREATE ) {
2939 $req = new CreationReasonAuthenticationRequest;
2940 $req->action = $action;
2941 $req->required = AuthenticationRequest::REQUIRED;
2942 $expectReqs[] = $req;
2943 usort( $expectReqs, $cmpReqs );
2944
2945 $actual = $this->manager->getAuthenticationRequests( $action, \User::newFromName( 'UTSysop' ) );
2946 foreach ( $actual as $req ) {
2947 // Don't test this here.
2948 $req->required = AuthenticationRequest::REQUIRED;
2949 }
2950 usort( $actual, $cmpReqs );
2951
2952 $this->assertEquals( $expectReqs, $actual );
2953 }
2954 }
2955
2956 public static function provideGetAuthenticationRequests() {
2957 return [
2958 [
2959 AuthManager::ACTION_LOGIN,
2960 [ 'pre-login', 'primary-none-login', 'primary-create-login',
2961 'primary-link-login', 'secondary-login', 'generic' ],
2962 ],
2963 [
2964 AuthManager::ACTION_CREATE,
2965 [ 'pre-create', 'primary-none-create', 'primary-create-create',
2966 'primary-link-create', 'secondary-create', 'generic' ],
2967 ],
2968 [
2969 AuthManager::ACTION_LINK,
2970 [ 'primary-link-link', 'generic' ],
2971 ],
2972 [
2973 AuthManager::ACTION_CHANGE,
2974 [ 'primary-none-change', 'primary-create-change', 'primary-link-change',
2975 'secondary-change' ],
2976 ],
2977 [
2978 AuthManager::ACTION_REMOVE,
2979 [ 'primary-none-remove', 'primary-create-remove', 'primary-link-remove',
2980 'secondary-remove' ],
2981 ],
2982 [
2983 AuthManager::ACTION_UNLINK,
2984 [ 'primary-link-remove' ],
2985 ],
2986 [
2987 AuthManager::ACTION_LOGIN_CONTINUE,
2988 [],
2989 ],
2990 [
2991 AuthManager::ACTION_LOGIN_CONTINUE,
2992 $reqs = [ 'continue-login', 'foo', 'bar' ],
2993 [
2994 'continueRequests' => $reqs,
2995 ],
2996 ],
2997 [
2998 AuthManager::ACTION_CREATE_CONTINUE,
2999 [],
3000 ],
3001 [
3002 AuthManager::ACTION_CREATE_CONTINUE,
3003 $reqs = [ 'continue-create', 'foo', 'bar' ],
3004 [
3005 'continueRequests' => $reqs,
3006 ],
3007 ],
3008 [
3009 AuthManager::ACTION_LINK_CONTINUE,
3010 [],
3011 ],
3012 [
3013 AuthManager::ACTION_LINK_CONTINUE,
3014 $reqs = [ 'continue-link', 'foo', 'bar' ],
3015 [
3016 'continueRequests' => $reqs,
3017 ],
3018 ],
3019 ];
3020 }
3021
3022 public function testGetAuthenticationRequestsRequired() {
3023 $makeReq = function ( $key, $required ) {
3024 $req = $this->createMock( AuthenticationRequest::class );
3025 $req->expects( $this->any() )->method( 'getUniqueId' )
3026 ->will( $this->returnValue( $key ) );
3027 $req->action = AuthManager::ACTION_LOGIN;
3028 $req->key = $key;
3029 $req->required = $required;
3030 return $req;
3031 };
3032 $cmpReqs = function ( $a, $b ) {
3033 $ret = strcmp( get_class( $a ), get_class( $b ) );
3034 if ( !$ret ) {
3035 $ret = strcmp( $a->key, $b->key );
3036 }
3037 return $ret;
3038 };
3039
3040 $good = StatusValue::newGood();
3041
3042 $primary1 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3043 $primary1->expects( $this->any() )->method( 'getUniqueId' )
3044 ->will( $this->returnValue( 'primary1' ) );
3045 $primary1->expects( $this->any() )->method( 'accountCreationType' )
3046 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
3047 $primary1->expects( $this->any() )->method( 'getAuthenticationRequests' )
3048 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3049 return [
3050 $makeReq( "primary-shared", AuthenticationRequest::REQUIRED ),
3051 $makeReq( "required", AuthenticationRequest::REQUIRED ),
3052 $makeReq( "optional", AuthenticationRequest::OPTIONAL ),
3053 $makeReq( "foo", AuthenticationRequest::REQUIRED ),
3054 $makeReq( "bar", AuthenticationRequest::REQUIRED ),
3055 $makeReq( "baz", AuthenticationRequest::OPTIONAL ),
3056 ];
3057 } ) );
3058
3059 $primary2 = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3060 $primary2->expects( $this->any() )->method( 'getUniqueId' )
3061 ->will( $this->returnValue( 'primary2' ) );
3062 $primary2->expects( $this->any() )->method( 'accountCreationType' )
3063 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
3064 $primary2->expects( $this->any() )->method( 'getAuthenticationRequests' )
3065 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3066 return [
3067 $makeReq( "primary-shared", AuthenticationRequest::REQUIRED ),
3068 $makeReq( "required2", AuthenticationRequest::REQUIRED ),
3069 $makeReq( "optional2", AuthenticationRequest::OPTIONAL ),
3070 ];
3071 } ) );
3072
3073 $secondary = $this->getMockForAbstractClass( SecondaryAuthenticationProvider::class );
3074 $secondary->expects( $this->any() )->method( 'getUniqueId' )
3075 ->will( $this->returnValue( 'secondary' ) );
3076 $secondary->expects( $this->any() )->method( 'getAuthenticationRequests' )
3077 ->will( $this->returnCallback( function ( $action ) use ( $makeReq ) {
3078 return [
3079 $makeReq( "foo", AuthenticationRequest::OPTIONAL ),
3080 $makeReq( "bar", AuthenticationRequest::REQUIRED ),
3081 $makeReq( "baz", AuthenticationRequest::REQUIRED ),
3082 ];
3083 } ) );
3084
3085 $rememberReq = new RememberMeAuthenticationRequest;
3086 $rememberReq->action = AuthManager::ACTION_LOGIN;
3087
3088 $this->primaryauthMocks = [ $primary1, $primary2 ];
3089 $this->secondaryauthMocks = [ $secondary ];
3090 $this->initializeManager( true );
3091
3092 $actual = $this->manager->getAuthenticationRequests( AuthManager::ACTION_LOGIN );
3093 $expected = [
3094 $rememberReq,
3095 $makeReq( "primary-shared", AuthenticationRequest::PRIMARY_REQUIRED ),
3096 $makeReq( "required", AuthenticationRequest::PRIMARY_REQUIRED ),
3097 $makeReq( "required2", AuthenticationRequest::PRIMARY_REQUIRED ),
3098 $makeReq( "optional", AuthenticationRequest::OPTIONAL ),
3099 $makeReq( "optional2", AuthenticationRequest::OPTIONAL ),
3100 $makeReq( "foo", AuthenticationRequest::PRIMARY_REQUIRED ),
3101 $makeReq( "bar", AuthenticationRequest::REQUIRED ),
3102 $makeReq( "baz", AuthenticationRequest::REQUIRED ),
3103 ];
3104 usort( $actual, $cmpReqs );
3105 usort( $expected, $cmpReqs );
3106 $this->assertEquals( $expected, $actual );
3107
3108 $this->primaryauthMocks = [ $primary1 ];
3109 $this->secondaryauthMocks = [ $secondary ];
3110 $this->initializeManager( true );
3111
3112 $actual = $this->manager->getAuthenticationRequests( AuthManager::ACTION_LOGIN );
3113 $expected = [
3114 $rememberReq,
3115 $makeReq( "primary-shared", AuthenticationRequest::PRIMARY_REQUIRED ),
3116 $makeReq( "required", AuthenticationRequest::PRIMARY_REQUIRED ),
3117 $makeReq( "optional", AuthenticationRequest::OPTIONAL ),
3118 $makeReq( "foo", AuthenticationRequest::PRIMARY_REQUIRED ),
3119 $makeReq( "bar", AuthenticationRequest::REQUIRED ),
3120 $makeReq( "baz", AuthenticationRequest::REQUIRED ),
3121 ];
3122 usort( $actual, $cmpReqs );
3123 usort( $expected, $cmpReqs );
3124 $this->assertEquals( $expected, $actual );
3125 }
3126
3127 public function testAllowsPropertyChange() {
3128 $mocks = [];
3129 foreach ( [ 'primary', 'secondary' ] as $key ) {
3130 $class = ucfirst( $key ) . 'AuthenticationProvider';
3131 $mocks[$key] = $this->getMockForAbstractClass(
3132 "MediaWiki\\Auth\\$class", [], "Mock$class"
3133 );
3134 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
3135 ->will( $this->returnValue( $key ) );
3136 $mocks[$key]->expects( $this->any() )->method( 'providerAllowsPropertyChange' )
3137 ->will( $this->returnCallback( function ( $prop ) use ( $key ) {
3138 return $prop !== $key;
3139 } ) );
3140 }
3141
3142 $this->primaryauthMocks = [ $mocks['primary'] ];
3143 $this->secondaryauthMocks = [ $mocks['secondary'] ];
3144 $this->initializeManager( true );
3145
3146 $this->assertTrue( $this->manager->allowsPropertyChange( 'foo' ) );
3147 $this->assertFalse( $this->manager->allowsPropertyChange( 'primary' ) );
3148 $this->assertFalse( $this->manager->allowsPropertyChange( 'secondary' ) );
3149 }
3150
3151 public function testAutoCreateOnLogin() {
3152 $username = self::usernameForCreation();
3153
3154 $req = $this->createMock( AuthenticationRequest::class );
3155
3156 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3157 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'primary' ) );
3158 $mock->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
3159 ->will( $this->returnValue( AuthenticationResponse::newPass( $username ) ) );
3160 $mock->expects( $this->any() )->method( 'accountCreationType' )
3161 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
3162 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
3163 $mock->expects( $this->any() )->method( 'testUserForCreation' )
3164 ->will( $this->returnValue( StatusValue::newGood() ) );
3165
3166 $mock2 = $this->getMockForAbstractClass( SecondaryAuthenticationProvider::class );
3167 $mock2->expects( $this->any() )->method( 'getUniqueId' )
3168 ->will( $this->returnValue( 'secondary' ) );
3169 $mock2->expects( $this->any() )->method( 'beginSecondaryAuthentication' )->will(
3170 $this->returnValue(
3171 AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) )
3172 )
3173 );
3174 $mock2->expects( $this->any() )->method( 'continueSecondaryAuthentication' )
3175 ->will( $this->returnValue( AuthenticationResponse::newAbstain() ) );
3176 $mock2->expects( $this->any() )->method( 'testUserForCreation' )
3177 ->will( $this->returnValue( StatusValue::newGood() ) );
3178
3179 $this->primaryauthMocks = [ $mock ];
3180 $this->secondaryauthMocks = [ $mock2 ];
3181 $this->initializeManager( true );
3182 $this->manager->setLogger( new \Psr\Log\NullLogger() );
3183 $session = $this->request->getSession();
3184 $session->clear();
3185
3186 $this->assertSame( 0, \User::newFromName( $username )->getId(),
3187 'sanity check' );
3188
3189 $callback = $this->callback( function ( $user ) use ( $username ) {
3190 return $user->getName() === $username;
3191 } );
3192
3193 $this->hook( 'UserLoggedIn', $this->never() );
3194 $this->hook( 'LocalUserCreated', $this->once() )->with( $callback, $this->equalTo( true ) );
3195 $ret = $this->manager->beginAuthentication( [], 'http://localhost/' );
3196 $this->unhook( 'LocalUserCreated' );
3197 $this->unhook( 'UserLoggedIn' );
3198 $this->assertSame( AuthenticationResponse::UI, $ret->status );
3199
3200 $id = (int)\User::newFromName( $username )->getId();
3201 $this->assertNotSame( 0, \User::newFromName( $username )->getId() );
3202 $this->assertSame( 0, $session->getUser()->getId() );
3203
3204 $this->hook( 'UserLoggedIn', $this->once() )->with( $callback );
3205 $this->hook( 'LocalUserCreated', $this->never() );
3206 $ret = $this->manager->continueAuthentication( [] );
3207 $this->unhook( 'LocalUserCreated' );
3208 $this->unhook( 'UserLoggedIn' );
3209 $this->assertSame( AuthenticationResponse::PASS, $ret->status );
3210 $this->assertSame( $username, $ret->username );
3211 $this->assertSame( $id, $session->getUser()->getId() );
3212 }
3213
3214 public function testAutoCreateFailOnLogin() {
3215 $username = self::usernameForCreation();
3216
3217 $mock = $this->getMockForAbstractClass(
3218 PrimaryAuthenticationProvider::class, [], "MockPrimaryAuthenticationProvider" );
3219 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'primary' ) );
3220 $mock->expects( $this->any() )->method( 'beginPrimaryAuthentication' )
3221 ->will( $this->returnValue( AuthenticationResponse::newPass( $username ) ) );
3222 $mock->expects( $this->any() )->method( 'accountCreationType' )
3223 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
3224 $mock->expects( $this->any() )->method( 'testUserExists' )->will( $this->returnValue( true ) );
3225 $mock->expects( $this->any() )->method( 'testUserForCreation' )
3226 ->will( $this->returnValue( StatusValue::newFatal( 'fail-from-primary' ) ) );
3227
3228 $this->primaryauthMocks = [ $mock ];
3229 $this->initializeManager( true );
3230 $this->manager->setLogger( new \Psr\Log\NullLogger() );
3231 $session = $this->request->getSession();
3232 $session->clear();
3233
3234 $this->assertSame( 0, $session->getUser()->getId(),
3235 'sanity check' );
3236 $this->assertSame( 0, \User::newFromName( $username )->getId(),
3237 'sanity check' );
3238
3239 $this->hook( 'UserLoggedIn', $this->never() );
3240 $this->hook( 'LocalUserCreated', $this->never() );
3241 $ret = $this->manager->beginAuthentication( [], 'http://localhost/' );
3242 $this->unhook( 'LocalUserCreated' );
3243 $this->unhook( 'UserLoggedIn' );
3244 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
3245 $this->assertSame( 'authmanager-authn-autocreate-failed', $ret->message->getKey() );
3246
3247 $this->assertSame( 0, \User::newFromName( $username )->getId() );
3248 $this->assertSame( 0, $session->getUser()->getId() );
3249 }
3250
3251 public function testAuthenticationSessionData() {
3252 $this->initializeManager( true );
3253
3254 $this->assertNull( $this->manager->getAuthenticationSessionData( 'foo' ) );
3255 $this->manager->setAuthenticationSessionData( 'foo', 'foo!' );
3256 $this->manager->setAuthenticationSessionData( 'bar', 'bar!' );
3257 $this->assertSame( 'foo!', $this->manager->getAuthenticationSessionData( 'foo' ) );
3258 $this->assertSame( 'bar!', $this->manager->getAuthenticationSessionData( 'bar' ) );
3259 $this->manager->removeAuthenticationSessionData( 'foo' );
3260 $this->assertNull( $this->manager->getAuthenticationSessionData( 'foo' ) );
3261 $this->assertSame( 'bar!', $this->manager->getAuthenticationSessionData( 'bar' ) );
3262 $this->manager->removeAuthenticationSessionData( 'bar' );
3263 $this->assertNull( $this->manager->getAuthenticationSessionData( 'bar' ) );
3264
3265 $this->manager->setAuthenticationSessionData( 'foo', 'foo!' );
3266 $this->manager->setAuthenticationSessionData( 'bar', 'bar!' );
3267 $this->manager->removeAuthenticationSessionData( null );
3268 $this->assertNull( $this->manager->getAuthenticationSessionData( 'foo' ) );
3269 $this->assertNull( $this->manager->getAuthenticationSessionData( 'bar' ) );
3270 }
3271
3272 public function testCanLinkAccounts() {
3273 $types = [
3274 PrimaryAuthenticationProvider::TYPE_CREATE => true,
3275 PrimaryAuthenticationProvider::TYPE_LINK => true,
3276 PrimaryAuthenticationProvider::TYPE_NONE => false,
3277 ];
3278
3279 foreach ( $types as $type => $can ) {
3280 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3281 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( $type ) );
3282 $mock->expects( $this->any() )->method( 'accountCreationType' )
3283 ->will( $this->returnValue( $type ) );
3284 $this->primaryauthMocks = [ $mock ];
3285 $this->initializeManager( true );
3286 $this->assertSame( $can, $this->manager->canCreateAccounts(), $type );
3287 }
3288 }
3289
3290 public function testBeginAccountLink() {
3291 $user = \User::newFromName( 'UTSysop' );
3292 $this->initializeManager();
3293
3294 $this->request->getSession()->setSecret( 'AuthManager::accountLinkState', 'test' );
3295 try {
3296 $this->manager->beginAccountLink( $user, [], 'http://localhost/' );
3297 $this->fail( 'Expected exception not thrown' );
3298 } catch ( \LogicException $ex ) {
3299 $this->assertEquals( 'Account linking is not possible', $ex->getMessage() );
3300 }
3301 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3302
3303 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3304 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
3305 $mock->expects( $this->any() )->method( 'accountCreationType' )
3306 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
3307 $this->primaryauthMocks = [ $mock ];
3308 $this->initializeManager( true );
3309
3310 $ret = $this->manager->beginAccountLink( new \User, [], 'http://localhost/' );
3311 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
3312 $this->assertSame( 'noname', $ret->message->getKey() );
3313
3314 $ret = $this->manager->beginAccountLink(
3315 \User::newFromName( 'UTDoesNotExist' ), [], 'http://localhost/'
3316 );
3317 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
3318 $this->assertSame( 'authmanager-userdoesnotexist', $ret->message->getKey() );
3319 }
3320
3321 public function testContinueAccountLink() {
3322 $user = \User::newFromName( 'UTSysop' );
3323 $this->initializeManager();
3324
3325 $session = [
3326 'userid' => $user->getId(),
3327 'username' => $user->getName(),
3328 'primary' => 'X',
3329 ];
3330
3331 try {
3332 $this->manager->continueAccountLink( [] );
3333 $this->fail( 'Expected exception not thrown' );
3334 } catch ( \LogicException $ex ) {
3335 $this->assertEquals( 'Account linking is not possible', $ex->getMessage() );
3336 }
3337
3338 $mock = $this->getMockForAbstractClass( PrimaryAuthenticationProvider::class );
3339 $mock->expects( $this->any() )->method( 'getUniqueId' )->will( $this->returnValue( 'X' ) );
3340 $mock->expects( $this->any() )->method( 'accountCreationType' )
3341 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
3342 $mock->expects( $this->any() )->method( 'beginPrimaryAccountLink' )->will(
3343 $this->returnValue( AuthenticationResponse::newFail( $this->message( 'fail' ) ) )
3344 );
3345 $this->primaryauthMocks = [ $mock ];
3346 $this->initializeManager( true );
3347
3348 $this->request->getSession()->setSecret( 'AuthManager::accountLinkState', null );
3349 $ret = $this->manager->continueAccountLink( [] );
3350 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
3351 $this->assertSame( 'authmanager-link-not-in-progress', $ret->message->getKey() );
3352
3353 $this->request->getSession()->setSecret( 'AuthManager::accountLinkState',
3354 [ 'username' => $user->getName() . '<>' ] + $session );
3355 $ret = $this->manager->continueAccountLink( [] );
3356 $this->assertSame( AuthenticationResponse::FAIL, $ret->status );
3357 $this->assertSame( 'noname', $ret->message->getKey() );
3358 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3359
3360 $id = $user->getId();
3361 $this->request->getSession()->setSecret( 'AuthManager::accountLinkState',
3362 [ 'userid' => $id + 1 ] + $session );
3363 try {
3364 $ret = $this->manager->continueAccountLink( [] );
3365 $this->fail( 'Expected exception not thrown' );
3366 } catch ( \UnexpectedValueException $ex ) {
3367 $this->assertEquals(
3368 "User \"{$user->getName()}\" is valid, but ID $id != " . ( $id + 1 ) . '!',
3369 $ex->getMessage()
3370 );
3371 }
3372 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ) );
3373 }
3374
3375 /**
3376 * @dataProvider provideAccountLink
3377 * @param StatusValue $preTest
3378 * @param array $primaryResponses
3379 * @param array $managerResponses
3380 */
3381 public function testAccountLink(
3382 StatusValue $preTest, array $primaryResponses, array $managerResponses
3383 ) {
3384 $user = \User::newFromName( 'UTSysop' );
3385
3386 $this->initializeManager();
3387
3388 // Set up lots of mocks...
3389 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
3390 $req->primary = $primaryResponses;
3391 $mocks = [];
3392
3393 foreach ( [ 'pre', 'primary' ] as $key ) {
3394 $class = ucfirst( $key ) . 'AuthenticationProvider';
3395 $mocks[$key] = $this->getMockForAbstractClass(
3396 "MediaWiki\\Auth\\$class", [], "Mock$class"
3397 );
3398 $mocks[$key]->expects( $this->any() )->method( 'getUniqueId' )
3399 ->will( $this->returnValue( $key ) );
3400
3401 for ( $i = 2; $i <= 3; $i++ ) {
3402 $mocks[$key . $i] = $this->getMockForAbstractClass(
3403 "MediaWiki\\Auth\\$class", [], "Mock$class"
3404 );
3405 $mocks[$key . $i]->expects( $this->any() )->method( 'getUniqueId' )
3406 ->will( $this->returnValue( $key . $i ) );
3407 }
3408 }
3409
3410 $mocks['pre']->expects( $this->any() )->method( 'testForAccountLink' )
3411 ->will( $this->returnCallback(
3412 function ( $u )
3413 use ( $user, $preTest )
3414 {
3415 $this->assertSame( $user->getId(), $u->getId() );
3416 $this->assertSame( $user->getName(), $u->getName() );
3417 return $preTest;
3418 }
3419 ) );
3420
3421 $mocks['pre2']->expects( $this->atMost( 1 ) )->method( 'testForAccountLink' )
3422 ->will( $this->returnValue( StatusValue::newGood() ) );
3423
3424 $mocks['primary']->expects( $this->any() )->method( 'accountCreationType' )
3425 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
3426 $ct = count( $req->primary );
3427 $callback = $this->returnCallback( function ( $u, $reqs ) use ( $user, $req ) {
3428 $this->assertSame( $user->getId(), $u->getId() );
3429 $this->assertSame( $user->getName(), $u->getName() );
3430 $foundReq = false;
3431 foreach ( $reqs as $r ) {
3432 $this->assertSame( $user->getName(), $r->username );
3433 $foundReq = $foundReq || get_class( $r ) === get_class( $req );
3434 }
3435 $this->assertTrue( $foundReq, '$reqs contains $req' );
3436 return array_shift( $req->primary );
3437 } );
3438 $mocks['primary']->expects( $this->exactly( min( 1, $ct ) ) )
3439 ->method( 'beginPrimaryAccountLink' )
3440 ->will( $callback );
3441 $mocks['primary']->expects( $this->exactly( max( 0, $ct - 1 ) ) )
3442 ->method( 'continuePrimaryAccountLink' )
3443 ->will( $callback );
3444
3445 $abstain = AuthenticationResponse::newAbstain();
3446 $mocks['primary2']->expects( $this->any() )->method( 'accountCreationType' )
3447 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_LINK ) );
3448 $mocks['primary2']->expects( $this->atMost( 1 ) )->method( 'beginPrimaryAccountLink' )
3449 ->will( $this->returnValue( $abstain ) );
3450 $mocks['primary2']->expects( $this->never() )->method( 'continuePrimaryAccountLink' );
3451 $mocks['primary3']->expects( $this->any() )->method( 'accountCreationType' )
3452 ->will( $this->returnValue( PrimaryAuthenticationProvider::TYPE_CREATE ) );
3453 $mocks['primary3']->expects( $this->never() )->method( 'beginPrimaryAccountLink' );
3454 $mocks['primary3']->expects( $this->never() )->method( 'continuePrimaryAccountLink' );
3455
3456 $this->preauthMocks = [ $mocks['pre'], $mocks['pre2'] ];
3457 $this->primaryauthMocks = [ $mocks['primary3'], $mocks['primary2'], $mocks['primary'] ];
3458 $this->logger = new \TestLogger( true, function ( $message, $level ) {
3459 return $level === LogLevel::DEBUG ? null : $message;
3460 } );
3461 $this->initializeManager( true );
3462
3463 $constraint = \PHPUnit_Framework_Assert::logicalOr(
3464 $this->equalTo( AuthenticationResponse::PASS ),
3465 $this->equalTo( AuthenticationResponse::FAIL )
3466 );
3467 $providers = array_merge( $this->preauthMocks, $this->primaryauthMocks );
3468 foreach ( $providers as $p ) {
3469 $p->postCalled = false;
3470 $p->expects( $this->atMost( 1 ) )->method( 'postAccountLink' )
3471 ->willReturnCallback( function ( $user, $response ) use ( $constraint, $p ) {
3472 $this->assertInstanceOf( 'User', $user );
3473 $this->assertSame( 'UTSysop', $user->getName() );
3474 $this->assertInstanceOf( AuthenticationResponse::class, $response );
3475 $this->assertThat( $response->status, $constraint );
3476 $p->postCalled = $response->status;
3477 } );
3478 }
3479
3480 $first = true;
3481 $created = false;
3482 $expectLog = [];
3483 foreach ( $managerResponses as $i => $response ) {
3484 if ( $response instanceof AuthenticationResponse &&
3485 $response->status === AuthenticationResponse::PASS
3486 ) {
3487 $expectLog[] = [ LogLevel::INFO, 'Account linked to {user} by primary' ];
3488 }
3489
3490 $ex = null;
3491 try {
3492 if ( $first ) {
3493 $ret = $this->manager->beginAccountLink( $user, [ $req ], 'http://localhost/' );
3494 } else {
3495 $ret = $this->manager->continueAccountLink( [ $req ] );
3496 }
3497 if ( $response instanceof \Exception ) {
3498 $this->fail( 'Expected exception not thrown', "Response $i" );
3499 }
3500 } catch ( \Exception $ex ) {
3501 if ( !$response instanceof \Exception ) {
3502 throw $ex;
3503 }
3504 $this->assertEquals( $response->getMessage(), $ex->getMessage(), "Response $i, exception" );
3505 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3506 "Response $i, exception, session state" );
3507 return;
3508 }
3509
3510 $this->assertSame( 'http://localhost/', $req->returnToUrl );
3511
3512 $ret->message = $this->message( $ret->message );
3513 $this->assertEquals( $response, $ret, "Response $i, response" );
3514 if ( $response->status === AuthenticationResponse::PASS ||
3515 $response->status === AuthenticationResponse::FAIL
3516 ) {
3517 $this->assertNull( $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3518 "Response $i, session state" );
3519 foreach ( $providers as $p ) {
3520 $this->assertSame( $response->status, $p->postCalled,
3521 "Response $i, post-auth callback called" );
3522 }
3523 } else {
3524 $this->assertNotNull(
3525 $this->request->getSession()->getSecret( 'AuthManager::accountLinkState' ),
3526 "Response $i, session state"
3527 );
3528 foreach ( $ret->neededRequests as $neededReq ) {
3529 $this->assertEquals( AuthManager::ACTION_LINK, $neededReq->action,
3530 "Response $i, neededRequest action" );
3531 }
3532 $this->assertEquals(
3533 $ret->neededRequests,
3534 $this->manager->getAuthenticationRequests( AuthManager::ACTION_LINK_CONTINUE ),
3535 "Response $i, continuation check"
3536 );
3537 foreach ( $providers as $p ) {
3538 $this->assertFalse( $p->postCalled, "Response $i, post-auth callback not called" );
3539 }
3540 }
3541
3542 $first = false;
3543 }
3544
3545 $this->assertSame( $expectLog, $this->logger->getBuffer() );
3546 }
3547
3548 public function provideAccountLink() {
3549 $req = $this->getMockForAbstractClass( AuthenticationRequest::class );
3550 $good = StatusValue::newGood();
3551
3552 return [
3553 'Pre-link test fail in pre' => [
3554 StatusValue::newFatal( 'fail-from-pre' ),
3555 [],
3556 [
3557 AuthenticationResponse::newFail( $this->message( 'fail-from-pre' ) ),
3558 ]
3559 ],
3560 'Failure in primary' => [
3561 $good,
3562 $tmp = [
3563 AuthenticationResponse::newFail( $this->message( 'fail-from-primary' ) ),
3564 ],
3565 $tmp
3566 ],
3567 'All primary abstain' => [
3568 $good,
3569 [
3570 AuthenticationResponse::newAbstain(),
3571 ],
3572 [
3573 AuthenticationResponse::newFail( $this->message( 'authmanager-link-no-primary' ) )
3574 ]
3575 ],
3576 'Primary UI, then redirect, then fail' => [
3577 $good,
3578 $tmp = [
3579 AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
3580 AuthenticationResponse::newRedirect( [ $req ], '/foo.html', [ 'foo' => 'bar' ] ),
3581 AuthenticationResponse::newFail( $this->message( 'fail-in-primary-continue' ) ),
3582 ],
3583 $tmp
3584 ],
3585 'Primary redirect, then abstain' => [
3586 $good,
3587 [
3588 $tmp = AuthenticationResponse::newRedirect(
3589 [ $req ], '/foo.html', [ 'foo' => 'bar' ]
3590 ),
3591 AuthenticationResponse::newAbstain(),
3592 ],
3593 [
3594 $tmp,
3595 new \DomainException(
3596 'MockPrimaryAuthenticationProvider::continuePrimaryAccountLink() returned ABSTAIN'
3597 )
3598 ]
3599 ],
3600 'Primary UI, then pass' => [
3601 $good,
3602 [
3603 $tmp1 = AuthenticationResponse::newUI( [ $req ], $this->message( '...' ) ),
3604 AuthenticationResponse::newPass(),
3605 ],
3606 [
3607 $tmp1,
3608 AuthenticationResponse::newPass( '' ),
3609 ]
3610 ],
3611 'Primary pass' => [
3612 $good,
3613 [
3614 AuthenticationResponse::newPass( '' ),
3615 ],
3616 [
3617 AuthenticationResponse::newPass( '' ),
3618 ]
3619 ],
3620 ];
3621 }
3622 }
Wiklou, le Wiki du Wiklou