3 namespace MediaWiki\Session
;
13 * @covers MediaWiki\Session\SessionManager
15 class SessionManagerTest
extends MediaWikiTestCase
{
17 protected $config, $logger, $store;
19 protected function getManager() {
20 \ObjectCache
::$instances['testSessionStore'] = new TestBagOStuff();
21 $this->config
= new \
HashConfig( [
22 'LanguageCode' => 'en',
23 'SessionCacheType' => 'testSessionStore',
24 'ObjectCacheSessionExpiry' => 100,
25 'SessionProviders' => [
26 [ 'class' => 'DummySessionProvider' ],
29 $this->logger
= new \
TestLogger( false, function ( $m ) {
30 return substr( $m, 0, 15 ) === 'SessionBackend ' ?
null : $m;
32 $this->store
= new TestBagOStuff();
34 return new SessionManager( [
35 'config' => $this->config
,
36 'logger' => $this->logger
,
37 'store' => $this->store
,
41 protected function objectCacheDef( $object ) {
42 return [ 'factory' => function () use ( $object ) {
47 public function testSingleton() {
48 $reset = TestUtils
::setSessionManagerSingleton( null );
50 $singleton = SessionManager
::singleton();
51 $this->assertInstanceOf( SessionManager
::class, $singleton );
52 $this->assertSame( $singleton, SessionManager
::singleton() );
55 public function testGetGlobalSession() {
56 $context = \RequestContext
::getMain();
58 if ( !PHPSessionHandler
::isInstalled() ) {
59 PHPSessionHandler
::install( SessionManager
::singleton() );
61 $rProp = new \
ReflectionProperty( PHPSessionHandler
::class, 'instance' );
62 $rProp->setAccessible( true );
63 $handler = \TestingAccessWrapper
::newFromObject( $rProp->getValue() );
64 $oldEnable = $handler->enable
;
65 $reset[] = new \
ScopedCallback( function () use ( $handler, $oldEnable ) {
66 if ( $handler->enable
) {
67 session_write_close();
69 $handler->enable
= $oldEnable;
71 $reset[] = TestUtils
::setSessionManagerSingleton( $this->getManager() );
73 $handler->enable
= true;
74 $request = new \
FauxRequest();
75 $context->setRequest( $request );
76 $id = $request->getSession()->getId();
79 $session = SessionManager
::getGlobalSession();
80 $this->assertSame( $id, $session->getId() );
82 session_id( 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' );
83 $session = SessionManager
::getGlobalSession();
84 $this->assertSame( 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', $session->getId() );
85 $this->assertSame( 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', $request->getSession()->getId() );
87 session_write_close();
88 $handler->enable
= false;
89 $request = new \
FauxRequest();
90 $context->setRequest( $request );
91 $id = $request->getSession()->getId();
94 $session = SessionManager
::getGlobalSession();
95 $this->assertSame( $id, $session->getId() );
97 session_id( 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' );
98 $session = SessionManager
::getGlobalSession();
99 $this->assertSame( $id, $session->getId() );
100 $this->assertSame( $id, $request->getSession()->getId() );
103 public function testConstructor() {
104 $manager = \TestingAccessWrapper
::newFromObject( $this->getManager() );
105 $this->assertSame( $this->config
, $manager->config
);
106 $this->assertSame( $this->logger
, $manager->logger
);
107 $this->assertSame( $this->store
, $manager->store
);
109 $manager = \TestingAccessWrapper
::newFromObject( new SessionManager() );
110 $this->assertSame( \RequestContext
::getMain()->getConfig(), $manager->config
);
112 $manager = \TestingAccessWrapper
::newFromObject( new SessionManager( [
113 'config' => $this->config
,
115 $this->assertSame( \ObjectCache
::$instances['testSessionStore'], $manager->store
);
118 'config' => '$options[\'config\'] must be an instance of Config',
119 'logger' => '$options[\'logger\'] must be an instance of LoggerInterface',
120 'store' => '$options[\'store\'] must be an instance of BagOStuff',
121 ] as $key => $error ) {
123 new SessionManager( [ $key => new \stdClass
] );
124 $this->fail( 'Expected exception not thrown' );
125 } catch ( \InvalidArgumentException
$ex ) {
126 $this->assertSame( $error, $ex->getMessage() );
131 public function testGetSessionForRequest() {
132 $manager = $this->getManager();
133 $request = new \
FauxRequest();
134 $request->unpersist1
= false;
135 $request->unpersist2
= false;
139 $idEmpty = 'empty-session-------------------';
141 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
143 [ 'provideSessionInfo', 'newSessionInfo', '__toString', 'describe', 'unpersistSession' ]
146 $provider1 = $providerBuilder->getMock();
147 $provider1->expects( $this->any() )->method( 'provideSessionInfo' )
148 ->with( $this->identicalTo( $request ) )
149 ->will( $this->returnCallback( function ( $request ) {
150 return $request->info1
;
152 $provider1->expects( $this->any() )->method( 'newSessionInfo' )
153 ->will( $this->returnCallback( function () use ( $idEmpty, $provider1 ) {
154 return new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
155 'provider' => $provider1,
161 $provider1->expects( $this->any() )->method( '__toString' )
162 ->will( $this->returnValue( 'Provider1' ) );
163 $provider1->expects( $this->any() )->method( 'describe' )
164 ->will( $this->returnValue( '#1 sessions' ) );
165 $provider1->expects( $this->any() )->method( 'unpersistSession' )
166 ->will( $this->returnCallback( function ( $request ) {
167 $request->unpersist1
= true;
170 $provider2 = $providerBuilder->getMock();
171 $provider2->expects( $this->any() )->method( 'provideSessionInfo' )
172 ->with( $this->identicalTo( $request ) )
173 ->will( $this->returnCallback( function ( $request ) {
174 return $request->info2
;
176 $provider2->expects( $this->any() )->method( '__toString' )
177 ->will( $this->returnValue( 'Provider2' ) );
178 $provider2->expects( $this->any() )->method( 'describe' )
179 ->will( $this->returnValue( '#2 sessions' ) );
180 $provider2->expects( $this->any() )->method( 'unpersistSession' )
181 ->will( $this->returnCallback( function ( $request ) {
182 $request->unpersist2
= true;
185 $this->config
->set( 'SessionProviders', [
186 $this->objectCacheDef( $provider1 ),
187 $this->objectCacheDef( $provider2 ),
190 // No provider returns info
191 $request->info1
= null;
192 $request->info2
= null;
193 $session = $manager->getSessionForRequest( $request );
194 $this->assertInstanceOf( Session
::class, $session );
195 $this->assertSame( $idEmpty, $session->getId() );
196 $this->assertFalse( $request->unpersist1
);
197 $this->assertFalse( $request->unpersist2
);
199 // Both providers return info, picks best one
200 $request->info1
= new SessionInfo( SessionInfo
::MIN_PRIORITY +
1, [
201 'provider' => $provider1,
202 'id' => ( $id1 = $manager->generateSessionId() ),
206 $request->info2
= new SessionInfo( SessionInfo
::MIN_PRIORITY +
2, [
207 'provider' => $provider2,
208 'id' => ( $id2 = $manager->generateSessionId() ),
212 $session = $manager->getSessionForRequest( $request );
213 $this->assertInstanceOf( Session
::class, $session );
214 $this->assertSame( $id2, $session->getId() );
215 $this->assertFalse( $request->unpersist1
);
216 $this->assertFalse( $request->unpersist2
);
218 $request->info1
= new SessionInfo( SessionInfo
::MIN_PRIORITY +
2, [
219 'provider' => $provider1,
220 'id' => ( $id1 = $manager->generateSessionId() ),
224 $request->info2
= new SessionInfo( SessionInfo
::MIN_PRIORITY +
1, [
225 'provider' => $provider2,
226 'id' => ( $id2 = $manager->generateSessionId() ),
230 $session = $manager->getSessionForRequest( $request );
231 $this->assertInstanceOf( Session
::class, $session );
232 $this->assertSame( $id1, $session->getId() );
233 $this->assertFalse( $request->unpersist1
);
234 $this->assertFalse( $request->unpersist2
);
237 $request->info1
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
238 'provider' => $provider1,
239 'id' => ( $id1 = $manager->generateSessionId() ),
241 'userInfo' => UserInfo
::newAnonymous(),
244 $request->info2
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
245 'provider' => $provider2,
246 'id' => ( $id2 = $manager->generateSessionId() ),
248 'userInfo' => UserInfo
::newAnonymous(),
252 $manager->getSessionForRequest( $request );
253 $this->fail( 'Expcected exception not thrown' );
254 } catch ( \OverflowException
$ex ) {
255 $this->assertStringStartsWith(
256 'Multiple sessions for this request tied for top priority: ',
259 $this->assertCount( 2, $ex->sessionInfos
);
260 $this->assertContains( $request->info1
, $ex->sessionInfos
);
261 $this->assertContains( $request->info2
, $ex->sessionInfos
);
263 $this->assertFalse( $request->unpersist1
);
264 $this->assertFalse( $request->unpersist2
);
267 $request->info1
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
268 'provider' => $provider2,
269 'id' => ( $id1 = $manager->generateSessionId() ),
273 $request->info2
= null;
275 $manager->getSessionForRequest( $request );
276 $this->fail( 'Expcected exception not thrown' );
277 } catch ( \UnexpectedValueException
$ex ) {
279 'Provider1 returned session info for a different provider: ' . $request->info1
,
283 $this->assertFalse( $request->unpersist1
);
284 $this->assertFalse( $request->unpersist2
);
286 // Unusable session info
287 $this->logger
->setCollect( true );
288 $request->info1
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
289 'provider' => $provider1,
290 'id' => ( $id1 = $manager->generateSessionId() ),
292 'userInfo' => UserInfo
::newFromName( 'UTSysop', false ),
295 $request->info2
= new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
296 'provider' => $provider2,
297 'id' => ( $id2 = $manager->generateSessionId() ),
301 $session = $manager->getSessionForRequest( $request );
302 $this->assertInstanceOf( Session
::class, $session );
303 $this->assertSame( $id2, $session->getId() );
304 $this->logger
->setCollect( false );
305 $this->assertTrue( $request->unpersist1
);
306 $this->assertFalse( $request->unpersist2
);
307 $request->unpersist1
= false;
309 $this->logger
->setCollect( true );
310 $request->info1
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
311 'provider' => $provider1,
312 'id' => ( $id1 = $manager->generateSessionId() ),
316 $request->info2
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
317 'provider' => $provider2,
318 'id' => ( $id2 = $manager->generateSessionId() ),
320 'userInfo' => UserInfo
::newFromName( 'UTSysop', false ),
323 $session = $manager->getSessionForRequest( $request );
324 $this->assertInstanceOf( Session
::class, $session );
325 $this->assertSame( $id1, $session->getId() );
326 $this->logger
->setCollect( false );
327 $this->assertFalse( $request->unpersist1
);
328 $this->assertTrue( $request->unpersist2
);
329 $request->unpersist2
= false;
331 // Unpersisted session ID
332 $request->info1
= new SessionInfo( SessionInfo
::MAX_PRIORITY
, [
333 'provider' => $provider1,
334 'id' => ( $id1 = $manager->generateSessionId() ),
335 'persisted' => false,
336 'userInfo' => UserInfo
::newFromName( 'UTSysop', true ),
339 $request->info2
= null;
340 $session = $manager->getSessionForRequest( $request );
341 $this->assertInstanceOf( Session
::class, $session );
342 $this->assertSame( $id1, $session->getId() );
343 $this->assertTrue( $request->unpersist1
); // The saving of the session does it
344 $this->assertFalse( $request->unpersist2
);
346 $this->assertTrue( $session->isPersistent(), 'sanity check' );
349 public function testGetSessionById() {
350 $manager = $this->getManager();
352 $manager->getSessionById( 'bad' );
353 $this->fail( 'Expected exception not thrown' );
354 } catch ( \InvalidArgumentException
$ex ) {
355 $this->assertSame( 'Invalid session ID', $ex->getMessage() );
358 // Unknown session ID
359 $id = $manager->generateSessionId();
360 $session = $manager->getSessionById( $id, true );
361 $this->assertInstanceOf( Session
::class, $session );
362 $this->assertSame( $id, $session->getId() );
364 $id = $manager->generateSessionId();
365 $this->assertNull( $manager->getSessionById( $id, false ) );
367 // Known but unloadable session ID
368 $this->logger
->setCollect( true );
369 $id = $manager->generateSessionId();
370 $this->store
->setSession( $id, [ 'metadata' => [
371 'userId' => User
::idFromName( 'UTSysop' ),
372 'userToken' => 'bad',
375 $this->assertNull( $manager->getSessionById( $id, true ) );
376 $this->assertNull( $manager->getSessionById( $id, false ) );
377 $this->logger
->setCollect( false );
380 $this->store
->setSession( $id, [] );
381 $session = $manager->getSessionById( $id, false );
382 $this->assertInstanceOf( Session
::class, $session );
383 $this->assertSame( $id, $session->getId() );
385 // Store isn't checked if the session is already loaded
386 $this->store
->setSession( $id, [ 'metadata' => [
387 'userId' => User
::idFromName( 'UTSysop' ),
388 'userToken' => 'bad',
390 $session2 = $manager->getSessionById( $id, false );
391 $this->assertInstanceOf( Session
::class, $session2 );
392 $this->assertSame( $id, $session2->getId() );
393 unset( $session, $session2 );
394 $this->logger
->setCollect( true );
395 $this->assertNull( $manager->getSessionById( $id, true ) );
396 $this->logger
->setCollect( false );
398 // Failure to create an empty session
399 $manager = $this->getManager();
400 $provider = $this->getMockBuilder( 'DummySessionProvider' )
401 ->setMethods( [ 'provideSessionInfo', 'newSessionInfo', '__toString' ] )
403 $provider->expects( $this->any() )->method( 'provideSessionInfo' )
404 ->will( $this->returnValue( null ) );
405 $provider->expects( $this->any() )->method( 'newSessionInfo' )
406 ->will( $this->returnValue( null ) );
407 $provider->expects( $this->any() )->method( '__toString' )
408 ->will( $this->returnValue( 'MockProvider' ) );
409 $this->config
->set( 'SessionProviders', [
410 $this->objectCacheDef( $provider ),
412 $this->logger
->setCollect( true );
413 $this->assertNull( $manager->getSessionById( $id, true ) );
414 $this->logger
->setCollect( false );
416 [ LogLevel
::ERROR
, 'Failed to create empty session: {exception}' ]
417 ], $this->logger
->getBuffer() );
420 public function testGetEmptySession() {
421 $manager = $this->getManager();
422 $pmanager = \TestingAccessWrapper
::newFromObject( $manager );
423 $request = new \
FauxRequest();
425 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
426 ->setMethods( [ 'provideSessionInfo', 'newSessionInfo', '__toString' ] );
432 $provider1 = $providerBuilder->getMock();
433 $provider1->expects( $this->any() )->method( 'provideSessionInfo' )
434 ->will( $this->returnValue( null ) );
435 $provider1->expects( $this->any() )->method( 'newSessionInfo' )
436 ->with( $this->callback( function ( $id ) use ( &$expectId ) {
437 return $id === $expectId;
439 ->will( $this->returnCallback( function () use ( &$info1 ) {
442 $provider1->expects( $this->any() )->method( '__toString' )
443 ->will( $this->returnValue( 'MockProvider1' ) );
445 $provider2 = $providerBuilder->getMock();
446 $provider2->expects( $this->any() )->method( 'provideSessionInfo' )
447 ->will( $this->returnValue( null ) );
448 $provider2->expects( $this->any() )->method( 'newSessionInfo' )
449 ->with( $this->callback( function ( $id ) use ( &$expectId ) {
450 return $id === $expectId;
452 ->will( $this->returnCallback( function () use ( &$info2 ) {
455 $provider1->expects( $this->any() )->method( '__toString' )
456 ->will( $this->returnValue( 'MockProvider2' ) );
458 $this->config
->set( 'SessionProviders', [
459 $this->objectCacheDef( $provider1 ),
460 $this->objectCacheDef( $provider2 ),
468 $manager->getEmptySession();
469 $this->fail( 'Expected exception not thrown' );
470 } catch ( \UnexpectedValueException
$ex ) {
472 'No provider could provide an empty session!',
479 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
480 'provider' => $provider1,
481 'id' => 'empty---------------------------',
486 $session = $manager->getEmptySession();
487 $this->assertInstanceOf( Session
::class, $session );
488 $this->assertSame( 'empty---------------------------', $session->getId() );
491 $expectId = 'expected------------------------';
492 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
493 'provider' => $provider1,
499 $session = $pmanager->getEmptySessionInternal( null, $expectId );
500 $this->assertInstanceOf( Session
::class, $session );
501 $this->assertSame( $expectId, $session->getId() );
504 $expectId = 'expected-----------------------2';
505 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
506 'provider' => $provider1,
507 'id' => "un$expectId",
513 $pmanager->getEmptySessionInternal( null, $expectId );
514 $this->fail( 'Expected exception not thrown' );
515 } catch ( \UnexpectedValueException
$ex ) {
517 'MockProvider1 returned empty session info with a wrong id: ' .
518 "un$expectId != $expectId",
524 $expectId = 'expected-----------------------2';
525 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
526 'provider' => $provider1,
532 $pmanager->getEmptySessionInternal( null, $expectId );
533 $this->fail( 'Expected exception not thrown' );
534 } catch ( \UnexpectedValueException
$ex ) {
536 'MockProvider1 returned empty session info with id flagged unsafe',
543 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
544 'provider' => $provider2,
545 'id' => 'empty---------------------------',
551 $manager->getEmptySession();
552 $this->fail( 'Expected exception not thrown' );
553 } catch ( \UnexpectedValueException
$ex ) {
555 'MockProvider1 returned an empty session info for a different provider: ' . $info1,
560 // Highest priority wins
562 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY +
1, [
563 'provider' => $provider1,
564 'id' => 'empty1--------------------------',
568 $info2 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
569 'provider' => $provider2,
570 'id' => 'empty2--------------------------',
574 $session = $manager->getEmptySession();
575 $this->assertInstanceOf( Session
::class, $session );
576 $this->assertSame( 'empty1--------------------------', $session->getId() );
579 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY +
1, [
580 'provider' => $provider1,
581 'id' => 'empty1--------------------------',
585 $info2 = new SessionInfo( SessionInfo
::MIN_PRIORITY +
2, [
586 'provider' => $provider2,
587 'id' => 'empty2--------------------------',
591 $session = $manager->getEmptySession();
592 $this->assertInstanceOf( Session
::class, $session );
593 $this->assertSame( 'empty2--------------------------', $session->getId() );
595 // Tied priorities throw an exception
597 $info1 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
598 'provider' => $provider1,
599 'id' => 'empty1--------------------------',
601 'userInfo' => UserInfo
::newAnonymous(),
604 $info2 = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
605 'provider' => $provider2,
606 'id' => 'empty2--------------------------',
608 'userInfo' => UserInfo
::newAnonymous(),
612 $manager->getEmptySession();
613 $this->fail( 'Expected exception not thrown' );
614 } catch ( \UnexpectedValueException
$ex ) {
615 $this->assertStringStartsWith(
616 'Multiple empty sessions tied for top priority: ',
623 $pmanager->getEmptySessionInternal( null, 'bad' );
624 $this->fail( 'Expected exception not thrown' );
625 } catch ( \InvalidArgumentException
$ex ) {
626 $this->assertSame( 'Invalid session ID', $ex->getMessage() );
629 // Session already exists
630 $expectId = 'expected-----------------------3';
631 $this->store
->setSessionMeta( $expectId, [
632 'provider' => 'MockProvider2',
638 $pmanager->getEmptySessionInternal( null, $expectId );
639 $this->fail( 'Expected exception not thrown' );
640 } catch ( \InvalidArgumentException
$ex ) {
641 $this->assertSame( 'Session ID already exists', $ex->getMessage() );
645 public function testInvalidateSessionsForUser() {
646 $user = User
::newFromName( 'UTSysop' );
647 $manager = $this->getManager();
649 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
650 ->setMethods( [ 'invalidateSessionsForUser', '__toString' ] );
652 $provider1 = $providerBuilder->getMock();
653 $provider1->expects( $this->once() )->method( 'invalidateSessionsForUser' )
654 ->with( $this->identicalTo( $user ) );
655 $provider1->expects( $this->any() )->method( '__toString' )
656 ->will( $this->returnValue( 'MockProvider1' ) );
658 $provider2 = $providerBuilder->getMock();
659 $provider2->expects( $this->once() )->method( 'invalidateSessionsForUser' )
660 ->with( $this->identicalTo( $user ) );
661 $provider2->expects( $this->any() )->method( '__toString' )
662 ->will( $this->returnValue( 'MockProvider2' ) );
664 $this->config
->set( 'SessionProviders', [
665 $this->objectCacheDef( $provider1 ),
666 $this->objectCacheDef( $provider2 ),
669 $oldToken = $user->getToken( true );
670 $manager->invalidateSessionsForUser( $user );
671 $this->assertNotEquals( $oldToken, $user->getToken() );
674 public function testGetVaryHeaders() {
675 $manager = $this->getManager();
677 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
678 ->setMethods( [ 'getVaryHeaders', '__toString' ] );
680 $provider1 = $providerBuilder->getMock();
681 $provider1->expects( $this->once() )->method( 'getVaryHeaders' )
682 ->will( $this->returnValue( [
684 'Bar' => [ 'X', 'Bar1' ],
687 $provider1->expects( $this->any() )->method( '__toString' )
688 ->will( $this->returnValue( 'MockProvider1' ) );
690 $provider2 = $providerBuilder->getMock();
691 $provider2->expects( $this->once() )->method( 'getVaryHeaders' )
692 ->will( $this->returnValue( [
694 'Bar' => [ 'X', 'Bar2' ],
695 'Quux' => [ 'Quux' ],
697 $provider2->expects( $this->any() )->method( '__toString' )
698 ->will( $this->returnValue( 'MockProvider2' ) );
700 $this->config
->set( 'SessionProviders', [
701 $this->objectCacheDef( $provider1 ),
702 $this->objectCacheDef( $provider2 ),
707 'Bar' => [ 'X', 'Bar1', 3 => 'Bar2' ],
708 'Quux' => [ 'Quux' ],
712 $this->assertEquals( $expect, $manager->getVaryHeaders() );
714 // Again, to ensure it's cached
715 $this->assertEquals( $expect, $manager->getVaryHeaders() );
718 public function testGetVaryCookies() {
719 $manager = $this->getManager();
721 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
722 ->setMethods( [ 'getVaryCookies', '__toString' ] );
724 $provider1 = $providerBuilder->getMock();
725 $provider1->expects( $this->once() )->method( 'getVaryCookies' )
726 ->will( $this->returnValue( [ 'Foo', 'Bar' ] ) );
727 $provider1->expects( $this->any() )->method( '__toString' )
728 ->will( $this->returnValue( 'MockProvider1' ) );
730 $provider2 = $providerBuilder->getMock();
731 $provider2->expects( $this->once() )->method( 'getVaryCookies' )
732 ->will( $this->returnValue( [ 'Foo', 'Baz' ] ) );
733 $provider2->expects( $this->any() )->method( '__toString' )
734 ->will( $this->returnValue( 'MockProvider2' ) );
736 $this->config
->set( 'SessionProviders', [
737 $this->objectCacheDef( $provider1 ),
738 $this->objectCacheDef( $provider2 ),
741 $expect = [ 'Foo', 'Bar', 'Baz' ];
743 $this->assertEquals( $expect, $manager->getVaryCookies() );
745 // Again, to ensure it's cached
746 $this->assertEquals( $expect, $manager->getVaryCookies() );
749 public function testGetProviders() {
750 $realManager = $this->getManager();
751 $manager = \TestingAccessWrapper
::newFromObject( $realManager );
753 $this->config
->set( 'SessionProviders', [
754 [ 'class' => 'DummySessionProvider' ],
756 $providers = $manager->getProviders();
757 $this->assertArrayHasKey( 'DummySessionProvider', $providers );
758 $provider = \TestingAccessWrapper
::newFromObject( $providers['DummySessionProvider'] );
759 $this->assertSame( $manager->logger
, $provider->logger
);
760 $this->assertSame( $manager->config
, $provider->config
);
761 $this->assertSame( $realManager, $provider->getManager() );
763 $this->config
->set( 'SessionProviders', [
764 [ 'class' => 'DummySessionProvider' ],
765 [ 'class' => 'DummySessionProvider' ],
767 $manager->sessionProviders
= null;
769 $manager->getProviders();
770 $this->fail( 'Expected exception not thrown' );
771 } catch ( \UnexpectedValueException
$ex ) {
773 'Duplicate provider name "DummySessionProvider"',
779 public function testShutdown() {
780 $manager = \TestingAccessWrapper
::newFromObject( $this->getManager() );
781 $manager->setLogger( new \Psr\Log\
NullLogger() );
783 $mock = $this->getMock( 'stdClass', [ 'shutdown' ] );
784 $mock->expects( $this->once() )->method( 'shutdown' );
786 $manager->allSessionBackends
= [ $mock ];
787 $manager->shutdown();
790 public function testGetSessionFromInfo() {
791 $manager = \TestingAccessWrapper
::newFromObject( $this->getManager() );
792 $request = new \
FauxRequest();
794 $id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
796 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
797 'provider' => $manager->getProvider( 'DummySessionProvider' ),
800 'userInfo' => UserInfo
::newFromName( 'UTSysop', true ),
803 \TestingAccessWrapper
::newFromObject( $info )->idIsSafe
= true;
804 $session1 = \TestingAccessWrapper
::newFromObject(
805 $manager->getSessionFromInfo( $info, $request )
807 $session2 = \TestingAccessWrapper
::newFromObject(
808 $manager->getSessionFromInfo( $info, $request )
811 $this->assertSame( $session1->backend
, $session2->backend
);
812 $this->assertNotEquals( $session1->index
, $session2->index
);
813 $this->assertSame( $session1->getSessionId(), $session2->getSessionId() );
814 $this->assertSame( $id, $session1->getId() );
816 \TestingAccessWrapper
::newFromObject( $info )->idIsSafe
= false;
817 $session3 = $manager->getSessionFromInfo( $info, $request );
818 $this->assertNotSame( $id, $session3->getId() );
821 public function testBackendRegistration() {
822 $manager = $this->getManager();
824 $session = $manager->getSessionForRequest( new \FauxRequest
);
825 $backend = \TestingAccessWrapper
::newFromObject( $session )->backend
;
826 $sessionId = $session->getSessionId();
827 $id = (string)$sessionId;
829 $this->assertSame( $sessionId, $manager->getSessionById( $id, true )->getSessionId() );
831 $manager->changeBackendId( $backend );
832 $this->assertSame( $sessionId, $session->getSessionId() );
833 $this->assertNotEquals( $id, (string)$sessionId );
834 $id = (string)$sessionId;
836 $this->assertSame( $sessionId, $manager->getSessionById( $id, true )->getSessionId() );
838 // Destruction of the session here causes the backend to be deregistered
842 $manager->changeBackendId( $backend );
843 $this->fail( 'Expected exception not thrown' );
844 } catch ( \InvalidArgumentException
$ex ) {
846 'Backend was not registered with this SessionManager', $ex->getMessage()
851 $manager->deregisterSessionBackend( $backend );
852 $this->fail( 'Expected exception not thrown' );
853 } catch ( \InvalidArgumentException
$ex ) {
855 'Backend was not registered with this SessionManager', $ex->getMessage()
859 $session = $manager->getSessionById( $id, true );
860 $this->assertSame( $sessionId, $session->getSessionId() );
863 public function testGenerateSessionId() {
864 $manager = $this->getManager();
866 $id = $manager->generateSessionId();
867 $this->assertTrue( SessionManager
::validateSessionId( $id ), "Generated ID: $id" );
870 public function testAutoCreateUser() {
871 global $wgGroupPermissions, $wgDisableAuthManager;
873 if ( !$wgDisableAuthManager ) {
874 $this->markTestSkipped( 'AuthManager is not disabled' );
877 \ObjectCache
::$instances[__METHOD__
] = new TestBagOStuff();
878 $this->setMwGlobals( [ 'wgMainCacheType' => __METHOD__
] );
879 $this->setMwGlobals( [
880 'wgAuth' => new AuthPlugin
,
883 $this->stashMwGlobals( [ 'wgGroupPermissions' ] );
884 $wgGroupPermissions['*']['createaccount'] = true;
885 $wgGroupPermissions['*']['autocreateaccount'] = false;
887 // Replace the global singleton with one configured for testing
888 $manager = $this->getManager();
889 $reset = TestUtils
::setSessionManagerSingleton( $manager );
891 $logger = new \
TestLogger( true, function ( $m ) {
892 if ( substr( $m, 0, 15 ) === 'SessionBackend ' ) {
896 $m = str_replace( 'MediaWiki\Session\SessionManager::autoCreateUser: ', '', $m );
899 $manager->setLogger( $logger );
901 $session = SessionManager
::getGlobalSession();
903 // Can't create an already-existing user
904 $user = User
::newFromName( 'UTSysop' );
905 $id = $user->getId();
906 $this->assertFalse( $manager->autoCreateUser( $user ) );
907 $this->assertSame( $id, $user->getId() );
908 $this->assertSame( 'UTSysop', $user->getName() );
909 $this->assertSame( [], $logger->getBuffer() );
910 $logger->clearBuffer();
912 // Sanity check that creation works at all
913 $user = User
::newFromName( 'UTSessionAutoCreate1' );
914 $this->assertSame( 0, $user->getId(), 'sanity check' );
915 $this->assertTrue( $manager->autoCreateUser( $user ) );
916 $this->assertNotEquals( 0, $user->getId() );
917 $this->assertSame( 'UTSessionAutoCreate1', $user->getName() );
919 $user->getId(), User
::idFromName( 'UTSessionAutoCreate1', User
::READ_LATEST
)
922 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {url}' ],
923 ], $logger->getBuffer() );
924 $logger->clearBuffer();
926 // Check lack of permissions
927 $wgGroupPermissions['*']['createaccount'] = false;
928 $wgGroupPermissions['*']['autocreateaccount'] = false;
929 $user = User
::newFromName( 'UTDoesNotExist' );
930 $this->assertFalse( $manager->autoCreateUser( $user ) );
931 $this->assertSame( 0, $user->getId() );
932 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
933 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
938 'user is blocked from this wiki, blacklisting',
940 ], $logger->getBuffer() );
941 $logger->clearBuffer();
943 // Check other permission
944 $wgGroupPermissions['*']['createaccount'] = false;
945 $wgGroupPermissions['*']['autocreateaccount'] = true;
946 $user = User
::newFromName( 'UTSessionAutoCreate2' );
947 $this->assertSame( 0, $user->getId(), 'sanity check' );
948 $this->assertTrue( $manager->autoCreateUser( $user ) );
949 $this->assertNotEquals( 0, $user->getId() );
950 $this->assertSame( 'UTSessionAutoCreate2', $user->getName() );
952 $user->getId(), User
::idFromName( 'UTSessionAutoCreate2', User
::READ_LATEST
)
955 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {url}' ],
956 ], $logger->getBuffer() );
957 $logger->clearBuffer();
959 // Test account-creation block
961 $block = new \
Block( [
962 'address' => $anon->getName(),
964 'reason' => __METHOD__
,
965 'expiry' => time() +
100500,
966 'createAccount' => true,
969 $this->assertInstanceOf( 'Block', $anon->isBlockedFromCreateAccount(), 'sanity check' );
970 $reset2 = new \
ScopedCallback( [ $block, 'delete' ] );
971 $user = User
::newFromName( 'UTDoesNotExist' );
972 $this->assertFalse( $manager->autoCreateUser( $user ) );
973 $this->assertSame( 0, $user->getId() );
974 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
975 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
976 \ScopedCallback
::consume( $reset2 );
979 [ LogLevel
::DEBUG
, 'user is blocked from this wiki, blacklisting' ],
980 ], $logger->getBuffer() );
981 $logger->clearBuffer();
983 // Sanity check that creation still works
984 $user = User
::newFromName( 'UTSessionAutoCreate3' );
985 $this->assertSame( 0, $user->getId(), 'sanity check' );
986 $this->assertTrue( $manager->autoCreateUser( $user ) );
987 $this->assertNotEquals( 0, $user->getId() );
988 $this->assertSame( 'UTSessionAutoCreate3', $user->getName() );
990 $user->getId(), User
::idFromName( 'UTSessionAutoCreate3', User
::READ_LATEST
)
993 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {url}' ],
994 ], $logger->getBuffer() );
995 $logger->clearBuffer();
997 // Test prevention by AuthPlugin
999 $oldWgAuth = $wgAuth;
1000 $mockWgAuth = $this->getMock( 'AuthPlugin', [ 'autoCreate' ] );
1001 $mockWgAuth->expects( $this->once() )->method( 'autoCreate' )
1002 ->will( $this->returnValue( false ) );
1003 $this->setMwGlobals( [
1004 'wgAuth' => $mockWgAuth,
1006 $user = User
::newFromName( 'UTDoesNotExist' );
1007 $this->assertFalse( $manager->autoCreateUser( $user ) );
1008 $this->assertSame( 0, $user->getId() );
1009 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1010 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1011 $this->setMwGlobals( [
1012 'wgAuth' => $oldWgAuth,
1015 $this->assertSame( [
1016 [ LogLevel
::DEBUG
, 'denied by AuthPlugin' ],
1017 ], $logger->getBuffer() );
1018 $logger->clearBuffer();
1020 // Test prevention by wfReadOnly()
1021 $this->setMwGlobals( [
1022 'wgReadOnly' => 'Because',
1024 $user = User
::newFromName( 'UTDoesNotExist' );
1025 $this->assertFalse( $manager->autoCreateUser( $user ) );
1026 $this->assertSame( 0, $user->getId() );
1027 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1028 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1029 $this->setMwGlobals( [
1030 'wgReadOnly' => false,
1033 $this->assertSame( [
1034 [ LogLevel
::DEBUG
, 'denied by wfReadOnly()' ],
1035 ], $logger->getBuffer() );
1036 $logger->clearBuffer();
1038 // Test prevention by a previous session
1039 $session->set( 'MWSession::AutoCreateBlacklist', 'test' );
1040 $user = User
::newFromName( 'UTDoesNotExist' );
1041 $this->assertFalse( $manager->autoCreateUser( $user ) );
1042 $this->assertSame( 0, $user->getId() );
1043 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1044 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1046 $this->assertSame( [
1047 [ LogLevel
::DEBUG
, 'blacklisted in session (test)' ],
1048 ], $logger->getBuffer() );
1049 $logger->clearBuffer();
1051 // Test uncreatable name
1052 $user = User
::newFromName( 'UTDoesNotExist@' );
1053 $this->assertFalse( $manager->autoCreateUser( $user ) );
1054 $this->assertSame( 0, $user->getId() );
1055 $this->assertNotSame( 'UTDoesNotExist@', $user->getName() );
1056 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1058 $this->assertSame( [
1059 [ LogLevel
::DEBUG
, 'Invalid username, blacklisting' ],
1060 ], $logger->getBuffer() );
1061 $logger->clearBuffer();
1063 // Test AbortAutoAccount hook
1064 $mock = $this->getMock( __CLASS__
, [ 'onAbortAutoAccount' ] );
1065 $mock->expects( $this->once() )->method( 'onAbortAutoAccount' )
1066 ->will( $this->returnCallback( function ( User
$user, &$msg ) {
1070 $this->mergeMwGlobalArrayValue( 'wgHooks', [ 'AbortAutoAccount' => [ $mock ] ] );
1071 $user = User
::newFromName( 'UTDoesNotExist' );
1072 $this->assertFalse( $manager->autoCreateUser( $user ) );
1073 $this->assertSame( 0, $user->getId() );
1074 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1075 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1076 $this->mergeMwGlobalArrayValue( 'wgHooks', [ 'AbortAutoAccount' => [] ] );
1078 $this->assertSame( [
1079 [ LogLevel
::DEBUG
, 'denied by hook: No way!' ],
1080 ], $logger->getBuffer() );
1081 $logger->clearBuffer();
1083 // Test AbortAutoAccount hook screwing up the name
1084 $mock = $this->getMock( 'stdClass', [ 'onAbortAutoAccount' ] );
1085 $mock->expects( $this->once() )->method( 'onAbortAutoAccount' )
1086 ->will( $this->returnCallback( function ( User
$user ) {
1087 $user->setName( 'UTDoesNotExistEither' );
1089 $this->mergeMwGlobalArrayValue( 'wgHooks', [ 'AbortAutoAccount' => [ $mock ] ] );
1091 $user = User
::newFromName( 'UTDoesNotExist' );
1092 $manager->autoCreateUser( $user );
1093 $this->fail( 'Expected exception not thrown' );
1094 } catch ( \UnexpectedValueException
$ex ) {
1096 'AbortAutoAccount hook tried to change the user name',
1100 $this->assertSame( 0, $user->getId() );
1101 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1102 $this->assertNotSame( 'UTDoesNotExistEither', $user->getName() );
1103 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1104 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExistEither', User
::READ_LATEST
) );
1105 $this->mergeMwGlobalArrayValue( 'wgHooks', [ 'AbortAutoAccount' => [] ] );
1107 $this->assertSame( [], $logger->getBuffer() );
1108 $logger->clearBuffer();
1110 // Test for "exception backoff"
1111 $user = User
::newFromName( 'UTDoesNotExist' );
1112 $cache = \ObjectCache
::getLocalClusterInstance();
1113 $backoffKey = wfMemcKey( 'MWSession', 'autocreate-failed', md5( $user->getName() ) );
1114 $cache->set( $backoffKey, 1, 60 * 10 );
1115 $this->assertFalse( $manager->autoCreateUser( $user ) );
1116 $this->assertSame( 0, $user->getId() );
1117 $this->assertNotSame( 'UTDoesNotExist', $user->getName() );
1118 $this->assertEquals( 0, User
::idFromName( 'UTDoesNotExist', User
::READ_LATEST
) );
1119 $cache->delete( $backoffKey );
1121 $this->assertSame( [
1122 [ LogLevel
::DEBUG
, 'denied by prior creation attempt failures' ],
1123 ], $logger->getBuffer() );
1124 $logger->clearBuffer();
1126 // Sanity check that creation still works, and test completion hook
1127 $cb = $this->callback( function ( User
$user ) {
1128 $this->assertNotEquals( 0, $user->getId() );
1129 $this->assertSame( 'UTSessionAutoCreate4', $user->getName() );
1130 $this->assertEquals(
1131 $user->getId(), User
::idFromName( 'UTSessionAutoCreate4', User
::READ_LATEST
)
1135 $mock = $this->getMock( 'stdClass',
1136 [ 'onAuthPluginAutoCreate', 'onLocalUserCreated' ] );
1137 $mock->expects( $this->once() )->method( 'onAuthPluginAutoCreate' )
1139 $mock->expects( $this->once() )->method( 'onLocalUserCreated' )
1140 ->with( $cb, $this->identicalTo( true ) );
1141 $this->mergeMwGlobalArrayValue( 'wgHooks', [
1142 'AuthPluginAutoCreate' => [ $mock ],
1143 'LocalUserCreated' => [ $mock ],
1145 $user = User
::newFromName( 'UTSessionAutoCreate4' );
1146 $this->assertSame( 0, $user->getId(), 'sanity check' );
1147 $this->assertTrue( $manager->autoCreateUser( $user ) );
1148 $this->assertNotEquals( 0, $user->getId() );
1149 $this->assertSame( 'UTSessionAutoCreate4', $user->getName() );
1150 $this->assertEquals(
1152 User
::idFromName( 'UTSessionAutoCreate4', User
::READ_LATEST
)
1154 $this->mergeMwGlobalArrayValue( 'wgHooks', [
1155 'AuthPluginAutoCreate' => [],
1156 'LocalUserCreated' => [],
1158 $this->assertSame( [
1159 [ LogLevel
::INFO
, 'creating new user ({username}) - from: {url}' ],
1160 ], $logger->getBuffer() );
1161 $logger->clearBuffer();
1164 public function onAbortAutoAccount( User
$user, &$msg ) {
1167 public function testPreventSessionsForUser() {
1168 $manager = $this->getManager();
1170 $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
1171 ->setMethods( [ 'preventSessionsForUser', '__toString' ] );
1173 $provider1 = $providerBuilder->getMock();
1174 $provider1->expects( $this->once() )->method( 'preventSessionsForUser' )
1175 ->with( $this->equalTo( 'UTSysop' ) );
1176 $provider1->expects( $this->any() )->method( '__toString' )
1177 ->will( $this->returnValue( 'MockProvider1' ) );
1179 $this->config
->set( 'SessionProviders', [
1180 $this->objectCacheDef( $provider1 ),
1183 $this->assertFalse( $manager->isUserSessionPrevented( 'UTSysop' ) );
1184 $manager->preventSessionsForUser( 'UTSysop' );
1185 $this->assertTrue( $manager->isUserSessionPrevented( 'UTSysop' ) );
1188 public function testLoadSessionInfoFromStore() {
1189 $manager = $this->getManager();
1190 $logger = new \
TestLogger( true );
1191 $manager->setLogger( $logger );
1192 $request = new \
FauxRequest();
1194 // TestingAccessWrapper can't handle methods with reference arguments, sigh.
1195 $rClass = new \
ReflectionClass( $manager );
1196 $rMethod = $rClass->getMethod( 'loadSessionInfoFromStore' );
1197 $rMethod->setAccessible( true );
1198 $loadSessionInfoFromStore = function ( &$info ) use ( $rMethod, $manager, $request ) {
1199 return $rMethod->invokeArgs( $manager, [ &$info, $request ] );
1202 $userInfo = UserInfo
::newFromName( 'UTSysop', true );
1203 $unverifiedUserInfo = UserInfo
::newFromName( 'UTSysop', false );
1205 $id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
1207 'userId' => $userInfo->getId(),
1208 'userName' => $userInfo->getName(),
1209 'userToken' => $userInfo->getToken( true ),
1210 'provider' => 'Mock',
1213 $builder = $this->getMockBuilder( SessionProvider
::class )
1214 ->setMethods( [ '__toString', 'mergeMetadata', 'refreshSessionInfo' ] );
1216 $provider = $builder->getMockForAbstractClass();
1217 $provider->setManager( $manager );
1218 $provider->expects( $this->any() )->method( 'persistsSessionId' )
1219 ->will( $this->returnValue( true ) );
1220 $provider->expects( $this->any() )->method( 'canChangeUser' )
1221 ->will( $this->returnValue( true ) );
1222 $provider->expects( $this->any() )->method( 'refreshSessionInfo' )
1223 ->will( $this->returnValue( true ) );
1224 $provider->expects( $this->any() )->method( '__toString' )
1225 ->will( $this->returnValue( 'Mock' ) );
1226 $provider->expects( $this->any() )->method( 'mergeMetadata' )
1227 ->will( $this->returnCallback( function ( $a, $b ) {
1228 if ( $b === [ 'Throw' ] ) {
1229 throw new MetadataMergeException( 'no merge!' );
1231 return [ 'Merged' ];
1234 $provider2 = $builder->getMockForAbstractClass();
1235 $provider2->setManager( $manager );
1236 $provider2->expects( $this->any() )->method( 'persistsSessionId' )
1237 ->will( $this->returnValue( false ) );
1238 $provider2->expects( $this->any() )->method( 'canChangeUser' )
1239 ->will( $this->returnValue( false ) );
1240 $provider2->expects( $this->any() )->method( '__toString' )
1241 ->will( $this->returnValue( 'Mock2' ) );
1242 $provider2->expects( $this->any() )->method( 'refreshSessionInfo' )
1243 ->will( $this->returnCallback( function ( $info, $request, &$metadata ) {
1244 $metadata['changed'] = true;
1248 $provider3 = $builder->getMockForAbstractClass();
1249 $provider3->setManager( $manager );
1250 $provider3->expects( $this->any() )->method( 'persistsSessionId' )
1251 ->will( $this->returnValue( true ) );
1252 $provider3->expects( $this->any() )->method( 'canChangeUser' )
1253 ->will( $this->returnValue( true ) );
1254 $provider3->expects( $this->once() )->method( 'refreshSessionInfo' )
1255 ->will( $this->returnValue( false ) );
1256 $provider3->expects( $this->any() )->method( '__toString' )
1257 ->will( $this->returnValue( 'Mock3' ) );
1259 \TestingAccessWrapper
::newFromObject( $manager )->sessionProviders
= [
1260 (string)$provider => $provider,
1261 (string)$provider2 => $provider2,
1262 (string)$provider3 => $provider3,
1265 // No metadata, basic usage
1266 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1267 'provider' => $provider,
1269 'userInfo' => $userInfo
1271 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1272 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1273 $this->assertFalse( $info->isIdSafe() );
1274 $this->assertSame( [], $logger->getBuffer() );
1276 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1277 'provider' => $provider,
1278 'userInfo' => $userInfo
1280 $this->assertTrue( $info->isIdSafe(), 'sanity check' );
1281 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1282 $this->assertTrue( $info->isIdSafe() );
1283 $this->assertSame( [], $logger->getBuffer() );
1285 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1286 'provider' => $provider2,
1288 'userInfo' => $userInfo
1290 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1291 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1292 $this->assertTrue( $info->isIdSafe() );
1293 $this->assertSame( [], $logger->getBuffer() );
1295 // Unverified user, no metadata
1296 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1297 'provider' => $provider,
1299 'userInfo' => $unverifiedUserInfo
1301 $this->assertSame( $unverifiedUserInfo, $info->getUserInfo() );
1302 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1303 $this->assertSame( [
1306 'Session "{session}": Unverified user provided and no metadata to auth it',
1308 ], $logger->getBuffer() );
1309 $logger->clearBuffer();
1311 // No metadata, missing data
1312 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1314 'userInfo' => $userInfo
1316 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1317 $this->assertSame( [
1318 [ LogLevel
::WARNING
, 'Session "{session}": Null provider and no metadata' ],
1319 ], $logger->getBuffer() );
1320 $logger->clearBuffer();
1322 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1323 'provider' => $provider,
1326 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1327 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1328 $this->assertInstanceOf( UserInfo
::class, $info->getUserInfo() );
1329 $this->assertTrue( $info->getUserInfo()->isVerified() );
1330 $this->assertTrue( $info->getUserInfo()->isAnon() );
1331 $this->assertFalse( $info->isIdSafe() );
1332 $this->assertSame( [], $logger->getBuffer() );
1334 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1335 'provider' => $provider2,
1338 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1339 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1340 $this->assertSame( [
1341 [ LogLevel
::INFO
, 'Session "{session}": No user provided and provider cannot set user' ]
1342 ], $logger->getBuffer() );
1343 $logger->clearBuffer();
1345 // Incomplete/bad metadata
1346 $this->store
->setRawSession( $id, true );
1347 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1348 $this->assertSame( [
1349 [ LogLevel
::WARNING
, 'Session "{session}": Bad data' ],
1350 ], $logger->getBuffer() );
1351 $logger->clearBuffer();
1353 $this->store
->setRawSession( $id, [ 'data' => [] ] );
1354 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1355 $this->assertSame( [
1356 [ LogLevel
::WARNING
, 'Session "{session}": Bad data structure' ],
1357 ], $logger->getBuffer() );
1358 $logger->clearBuffer();
1360 $this->store
->deleteSession( $id );
1361 $this->store
->setRawSession( $id, [ 'metadata' => $metadata ] );
1362 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1363 $this->assertSame( [
1364 [ LogLevel
::WARNING
, 'Session "{session}": Bad data structure' ],
1365 ], $logger->getBuffer() );
1366 $logger->clearBuffer();
1368 $this->store
->setRawSession( $id, [ 'metadata' => $metadata, 'data' => true ] );
1369 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1370 $this->assertSame( [
1371 [ LogLevel
::WARNING
, 'Session "{session}": Bad data structure' ],
1372 ], $logger->getBuffer() );
1373 $logger->clearBuffer();
1375 $this->store
->setRawSession( $id, [ 'metadata' => true, 'data' => [] ] );
1376 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1377 $this->assertSame( [
1378 [ LogLevel
::WARNING
, 'Session "{session}": Bad data structure' ],
1379 ], $logger->getBuffer() );
1380 $logger->clearBuffer();
1382 foreach ( $metadata as $key => $dummy ) {
1384 unset( $tmp[$key] );
1385 $this->store
->setRawSession( $id, [ 'metadata' => $tmp, 'data' => [] ] );
1386 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1387 $this->assertSame( [
1388 [ LogLevel
::WARNING
, 'Session "{session}": Bad metadata' ],
1389 ], $logger->getBuffer() );
1390 $logger->clearBuffer();
1393 // Basic usage with metadata
1394 $this->store
->setRawSession( $id, [ 'metadata' => $metadata, 'data' => [] ] );
1395 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1396 'provider' => $provider,
1398 'userInfo' => $userInfo
1400 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1401 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1402 $this->assertTrue( $info->isIdSafe() );
1403 $this->assertSame( [], $logger->getBuffer() );
1405 // Mismatched provider
1406 $this->store
->setSessionMeta( $id, [ 'provider' => 'Bad' ] +
$metadata );
1407 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1408 'provider' => $provider,
1410 'userInfo' => $userInfo
1412 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1413 $this->assertSame( [
1414 [ LogLevel
::WARNING
, 'Session "{session}": Wrong provider Bad !== Mock' ],
1415 ], $logger->getBuffer() );
1416 $logger->clearBuffer();
1419 $this->store
->setSessionMeta( $id, [ 'provider' => 'Bad' ] +
$metadata );
1420 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1422 'userInfo' => $userInfo
1424 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1425 $this->assertSame( [
1426 [ LogLevel
::WARNING
, 'Session "{session}": Unknown provider Bad' ],
1427 ], $logger->getBuffer() );
1428 $logger->clearBuffer();
1431 $this->store
->setSessionMeta( $id, $metadata );
1432 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1434 'userInfo' => $userInfo
1436 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1437 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1438 $this->assertTrue( $info->isIdSafe() );
1439 $this->assertSame( [], $logger->getBuffer() );
1441 // Bad user metadata
1442 $this->store
->setSessionMeta( $id, [ 'userId' => -1, 'userToken' => null ] +
$metadata );
1443 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1444 'provider' => $provider,
1447 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1448 $this->assertSame( [
1449 [ LogLevel
::ERROR
, 'Session "{session}": {exception}' ],
1450 ], $logger->getBuffer() );
1451 $logger->clearBuffer();
1453 $this->store
->setSessionMeta(
1454 $id, [ 'userId' => 0, 'userName' => '<X>', 'userToken' => null ] +
$metadata
1456 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1457 'provider' => $provider,
1460 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1461 $this->assertSame( [
1462 [ LogLevel
::ERROR
, 'Session "{session}": {exception}', ],
1463 ], $logger->getBuffer() );
1464 $logger->clearBuffer();
1466 // Mismatched user by ID
1467 $this->store
->setSessionMeta(
1468 $id, [ 'userId' => $userInfo->getId() +
1, 'userToken' => null ] +
$metadata
1470 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1471 'provider' => $provider,
1473 'userInfo' => $userInfo
1475 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1476 $this->assertSame( [
1477 [ LogLevel
::WARNING
, 'Session "{session}": User ID mismatch, {uid_a} !== {uid_b}' ],
1478 ], $logger->getBuffer() );
1479 $logger->clearBuffer();
1481 // Mismatched user by name
1482 $this->store
->setSessionMeta(
1483 $id, [ 'userId' => 0, 'userName' => 'X', 'userToken' => null ] +
$metadata
1485 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1486 'provider' => $provider,
1488 'userInfo' => $userInfo
1490 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1491 $this->assertSame( [
1492 [ LogLevel
::WARNING
, 'Session "{session}": User name mismatch, {uname_a} !== {uname_b}' ],
1493 ], $logger->getBuffer() );
1494 $logger->clearBuffer();
1496 // ID matches, name doesn't
1497 $this->store
->setSessionMeta(
1498 $id, [ 'userId' => $userInfo->getId(), 'userName' => 'X', 'userToken' => null ] +
$metadata
1500 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1501 'provider' => $provider,
1503 'userInfo' => $userInfo
1505 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1506 $this->assertSame( [
1509 'Session "{session}": User ID matched but name didn\'t (rename?), {uname_a} !== {uname_b}'
1511 ], $logger->getBuffer() );
1512 $logger->clearBuffer();
1514 // Mismatched anon user
1515 $this->store
->setSessionMeta(
1516 $id, [ 'userId' => 0, 'userName' => null, 'userToken' => null ] +
$metadata
1518 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1519 'provider' => $provider,
1521 'userInfo' => $userInfo
1523 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1524 $this->assertSame( [
1527 'Session "{session}": Metadata has an anonymous user, ' .
1528 'but a non-anon user was provided',
1530 ], $logger->getBuffer() );
1531 $logger->clearBuffer();
1533 // Lookup user by ID
1534 $this->store
->setSessionMeta( $id, [ 'userToken' => null ] +
$metadata );
1535 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1536 'provider' => $provider,
1539 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1540 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1541 $this->assertSame( $userInfo->getId(), $info->getUserInfo()->getId() );
1542 $this->assertTrue( $info->isIdSafe() );
1543 $this->assertSame( [], $logger->getBuffer() );
1545 // Lookup user by name
1546 $this->store
->setSessionMeta(
1547 $id, [ 'userId' => 0, 'userName' => 'UTSysop', 'userToken' => null ] +
$metadata
1549 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1550 'provider' => $provider,
1553 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1554 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1555 $this->assertSame( $userInfo->getId(), $info->getUserInfo()->getId() );
1556 $this->assertTrue( $info->isIdSafe() );
1557 $this->assertSame( [], $logger->getBuffer() );
1559 // Lookup anonymous user
1560 $this->store
->setSessionMeta(
1561 $id, [ 'userId' => 0, 'userName' => null, 'userToken' => null ] +
$metadata
1563 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1564 'provider' => $provider,
1567 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1568 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1569 $this->assertTrue( $info->getUserInfo()->isAnon() );
1570 $this->assertTrue( $info->isIdSafe() );
1571 $this->assertSame( [], $logger->getBuffer() );
1573 // Unverified user with metadata
1574 $this->store
->setSessionMeta( $id, $metadata );
1575 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1576 'provider' => $provider,
1578 'userInfo' => $unverifiedUserInfo
1580 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1581 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1582 $this->assertTrue( $info->getUserInfo()->isVerified() );
1583 $this->assertSame( $unverifiedUserInfo->getId(), $info->getUserInfo()->getId() );
1584 $this->assertSame( $unverifiedUserInfo->getName(), $info->getUserInfo()->getName() );
1585 $this->assertTrue( $info->isIdSafe() );
1586 $this->assertSame( [], $logger->getBuffer() );
1588 // Unverified user with metadata
1589 $this->store
->setSessionMeta( $id, $metadata );
1590 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1591 'provider' => $provider,
1593 'userInfo' => $unverifiedUserInfo
1595 $this->assertFalse( $info->isIdSafe(), 'sanity check' );
1596 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1597 $this->assertTrue( $info->getUserInfo()->isVerified() );
1598 $this->assertSame( $unverifiedUserInfo->getId(), $info->getUserInfo()->getId() );
1599 $this->assertSame( $unverifiedUserInfo->getName(), $info->getUserInfo()->getName() );
1600 $this->assertTrue( $info->isIdSafe() );
1601 $this->assertSame( [], $logger->getBuffer() );
1604 $this->store
->setSessionMeta( $id, [ 'userToken' => 'Bad' ] +
$metadata );
1605 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1606 'provider' => $provider,
1608 'userInfo' => $userInfo
1610 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1611 $this->assertSame( [
1612 [ LogLevel
::WARNING
, 'Session "{session}": User token mismatch' ],
1613 ], $logger->getBuffer() );
1614 $logger->clearBuffer();
1616 // Provider metadata
1617 $this->store
->setSessionMeta( $id, [ 'provider' => 'Mock2' ] +
$metadata );
1618 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1619 'provider' => $provider2,
1621 'userInfo' => $userInfo,
1622 'metadata' => [ 'Info' ],
1624 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1625 $this->assertSame( [ 'Info', 'changed' => true ], $info->getProviderMetadata() );
1626 $this->assertSame( [], $logger->getBuffer() );
1628 $this->store
->setSessionMeta( $id, [ 'providerMetadata' => [ 'Saved' ] ] +
$metadata );
1629 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1630 'provider' => $provider,
1632 'userInfo' => $userInfo,
1634 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1635 $this->assertSame( [ 'Saved' ], $info->getProviderMetadata() );
1636 $this->assertSame( [], $logger->getBuffer() );
1638 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1639 'provider' => $provider,
1641 'userInfo' => $userInfo,
1642 'metadata' => [ 'Info' ],
1644 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1645 $this->assertSame( [ 'Merged' ], $info->getProviderMetadata() );
1646 $this->assertSame( [], $logger->getBuffer() );
1648 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1649 'provider' => $provider,
1651 'userInfo' => $userInfo,
1652 'metadata' => [ 'Throw' ],
1654 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1655 $this->assertSame( [
1658 'Session "{session}": Metadata merge failed: {exception}',
1660 ], $logger->getBuffer() );
1661 $logger->clearBuffer();
1663 // Remember from session
1664 $this->store
->setSessionMeta( $id, $metadata );
1665 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1666 'provider' => $provider,
1669 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1670 $this->assertFalse( $info->wasRemembered() );
1671 $this->assertSame( [], $logger->getBuffer() );
1673 $this->store
->setSessionMeta( $id, [ 'remember' => true ] +
$metadata );
1674 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1675 'provider' => $provider,
1678 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1679 $this->assertTrue( $info->wasRemembered() );
1680 $this->assertSame( [], $logger->getBuffer() );
1682 $this->store
->setSessionMeta( $id, [ 'remember' => false ] +
$metadata );
1683 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1684 'provider' => $provider,
1686 'userInfo' => $userInfo
1688 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1689 $this->assertTrue( $info->wasRemembered() );
1690 $this->assertSame( [], $logger->getBuffer() );
1692 // forceHTTPS from session
1693 $this->store
->setSessionMeta( $id, $metadata );
1694 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1695 'provider' => $provider,
1697 'userInfo' => $userInfo
1699 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1700 $this->assertFalse( $info->forceHTTPS() );
1701 $this->assertSame( [], $logger->getBuffer() );
1703 $this->store
->setSessionMeta( $id, [ 'forceHTTPS' => true ] +
$metadata );
1704 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1705 'provider' => $provider,
1707 'userInfo' => $userInfo
1709 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1710 $this->assertTrue( $info->forceHTTPS() );
1711 $this->assertSame( [], $logger->getBuffer() );
1713 $this->store
->setSessionMeta( $id, [ 'forceHTTPS' => false ] +
$metadata );
1714 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1715 'provider' => $provider,
1717 'userInfo' => $userInfo,
1718 'forceHTTPS' => true
1720 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1721 $this->assertTrue( $info->forceHTTPS() );
1722 $this->assertSame( [], $logger->getBuffer() );
1724 // "Persist" flag from session
1725 $this->store
->setSessionMeta( $id, $metadata );
1726 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1727 'provider' => $provider,
1729 'userInfo' => $userInfo
1731 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1732 $this->assertFalse( $info->wasPersisted() );
1733 $this->assertSame( [], $logger->getBuffer() );
1735 $this->store
->setSessionMeta( $id, [ 'persisted' => true ] +
$metadata );
1736 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1737 'provider' => $provider,
1739 'userInfo' => $userInfo
1741 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1742 $this->assertTrue( $info->wasPersisted() );
1743 $this->assertSame( [], $logger->getBuffer() );
1745 $this->store
->setSessionMeta( $id, [ 'persisted' => false ] +
$metadata );
1746 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1747 'provider' => $provider,
1749 'userInfo' => $userInfo,
1752 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1753 $this->assertTrue( $info->wasPersisted() );
1754 $this->assertSame( [], $logger->getBuffer() );
1756 // Provider refreshSessionInfo() returning false
1757 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1758 'provider' => $provider3,
1760 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1761 $this->assertSame( [], $logger->getBuffer() );
1765 $data = [ 'foo' => 1 ];
1766 $this->store
->setSession( $id, [ 'metadata' => $metadata, 'data' => $data ] );
1767 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1768 'provider' => $provider,
1770 'userInfo' => $userInfo
1772 $this->mergeMwGlobalArrayValue( 'wgHooks', [
1773 'SessionCheckInfo' => [ function ( &$reason, $i, $r, $m, $d ) use (
1774 $info, $metadata, $data, $request, &$called
1776 $this->assertSame( $info->getId(), $i->getId() );
1777 $this->assertSame( $info->getProvider(), $i->getProvider() );
1778 $this->assertSame( $info->getUserInfo(), $i->getUserInfo() );
1779 $this->assertSame( $request, $r );
1780 $this->assertEquals( $metadata, $m );
1781 $this->assertEquals( $data, $d );
1786 $this->assertFalse( $loadSessionInfoFromStore( $info ) );
1787 $this->assertTrue( $called );
1788 $this->assertSame( [
1789 [ LogLevel
::WARNING
, 'Session "{session}": Hook aborted' ],
1790 ], $logger->getBuffer() );
1791 $logger->clearBuffer();
1792 $this->mergeMwGlobalArrayValue( 'wgHooks', [ 'SessionCheckInfo' => [] ] );
1794 // forceUse deletes bad backend data
1795 $this->store
->setSessionMeta( $id, [ 'userToken' => 'Bad' ] +
$metadata );
1796 $info = new SessionInfo( SessionInfo
::MIN_PRIORITY
, [
1797 'provider' => $provider,
1799 'userInfo' => $userInfo,
1802 $this->assertTrue( $loadSessionInfoFromStore( $info ) );
1803 $this->assertFalse( $this->store
->getSession( $id ) );
1804 $this->assertSame( [
1805 [ LogLevel
::WARNING
, 'Session "{session}": User token mismatch' ],
1806 ], $logger->getBuffer() );
1807 $logger->clearBuffer();