Merge "Fix wrong @return type hints in Language::tsTo… methods"

[lhc/web/wiklou.git] / tests / phpunit / includes / session / SessionManagerTest.php

diff --git a/tests/phpunit/includes/session/SessionManagerTest.php b/tests/phpunit/includes/session/SessionManagerTest.php
index fe2c3b7..6218f0a 100644 (file)
--- a/tests/phpunit/includes/session/SessionManagerTest.php
+++ b/tests/phpunit/includes/session/SessionManagerTest.php
@@ -48,7 +48,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                $reset = TestUtils::setSessionManagerSingleton( null );
 
                $singleton = SessionManager::singleton();
-               $this->assertInstanceOf( 'MediaWiki\\Session\\SessionManager', $singleton );
+               $this->assertInstanceOf( SessionManager::class, $singleton );
                $this->assertSame( $singleton, SessionManager::singleton() );
        }
 
@@ -58,7 +58,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                if ( !PHPSessionHandler::isInstalled() ) {
                        PHPSessionHandler::install( SessionManager::singleton() );
                }
-               $rProp = new \ReflectionProperty( 'MediaWiki\\Session\\PHPSessionHandler', 'instance' );
+               $rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
                $rProp->setAccessible( true );
                $handler = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
                $oldEnable = $handler->enable;
@@ -131,6 +131,8 @@ class SessionManagerTest extends MediaWikiTestCase {
        public function testGetSessionForRequest() {
                $manager = $this->getManager();
                $request = new \FauxRequest();
+               $request->unpersist1 = false;
+               $request->unpersist2 = false;
 
                $id1 = '';
                $id2 = '';
@@ -138,7 +140,7 @@ class SessionManagerTest extends MediaWikiTestCase {
 
                $providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
                        ->setMethods(
-                               [ 'provideSessionInfo', 'newSessionInfo', '__toString', 'describe' ]
+                               [ 'provideSessionInfo', 'newSessionInfo', '__toString', 'describe', 'unpersistSession' ]
                        );
 
                $provider1 = $providerBuilder->getMock();
@@ -160,6 +162,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                        ->will( $this->returnValue( 'Provider1' ) );
                $provider1->expects( $this->any() )->method( 'describe' )
                        ->will( $this->returnValue( '#1 sessions' ) );
+               $provider1->expects( $this->any() )->method( 'unpersistSession' )
+                       ->will( $this->returnCallback( function ( $request ) {
+                               $request->unpersist1 = true;
+                       } ) );
 
                $provider2 = $providerBuilder->getMock();
                $provider2->expects( $this->any() )->method( 'provideSessionInfo' )
@@ -171,6 +177,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                        ->will( $this->returnValue( 'Provider2' ) );
                $provider2->expects( $this->any() )->method( 'describe' )
                        ->will( $this->returnValue( '#2 sessions' ) );
+               $provider2->expects( $this->any() )->method( 'unpersistSession' )
+                       ->will( $this->returnCallback( function ( $request ) {
+                               $request->unpersist2 = true;
+                       } ) );
 
                $this->config->set( 'SessionProviders', [
                        $this->objectCacheDef( $provider1 ),
@@ -181,8 +191,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                $request->info1 = null;
                $request->info2 = null;
                $session = $manager->getSessionForRequest( $request );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $idEmpty, $session->getId() );
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
 
                // Both providers return info, picks best one
                $request->info1 = new SessionInfo( SessionInfo::MIN_PRIORITY + 1, [
@@ -198,8 +210,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'idIsSafe' => true,
                ] );
                $session = $manager->getSessionForRequest( $request );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id2, $session->getId() );
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
 
                $request->info1 = new SessionInfo( SessionInfo::MIN_PRIORITY + 2, [
                        'provider' => $provider1,
@@ -214,8 +228,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'idIsSafe' => true,
                ] );
                $session = $manager->getSessionForRequest( $request );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id1, $session->getId() );
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
 
                // Tied priorities
                $request->info1 = new SessionInfo( SessionInfo::MAX_PRIORITY, [
@@ -235,7 +251,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                try {
                        $manager->getSessionForRequest( $request );
                        $this->fail( 'Expcected exception not thrown' );
-               } catch ( \OverFlowException $ex ) {
+               } catch ( \OverflowException $ex ) {
                        $this->assertStringStartsWith(
                                'Multiple sessions for this request tied for top priority: ',
                                $ex->getMessage()
@@ -244,6 +260,8 @@ class SessionManagerTest extends MediaWikiTestCase {
                        $this->assertContains( $request->info1, $ex->sessionInfos );
                        $this->assertContains( $request->info2, $ex->sessionInfos );
                }
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
 
                // Bad provider
                $request->info1 = new SessionInfo( SessionInfo::MAX_PRIORITY, [
@@ -262,6 +280,8 @@ class SessionManagerTest extends MediaWikiTestCase {
                                $ex->getMessage()
                        );
                }
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
 
                // Unusable session info
                $this->logger->setCollect( true );
@@ -279,9 +299,34 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'idIsSafe' => true,
                ] );
                $session = $manager->getSessionForRequest( $request );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id2, $session->getId() );
                $this->logger->setCollect( false );
+               $this->assertTrue( $request->unpersist1 );
+               $this->assertFalse( $request->unpersist2 );
+               $request->unpersist1 = false;
+
+               $this->logger->setCollect( true );
+               $request->info1 = new SessionInfo( SessionInfo::MAX_PRIORITY, [
+                       'provider' => $provider1,
+                       'id' => ( $id1 = $manager->generateSessionId() ),
+                       'persisted' => true,
+                       'idIsSafe' => true,
+               ] );
+               $request->info2 = new SessionInfo( SessionInfo::MAX_PRIORITY, [
+                       'provider' => $provider2,
+                       'id' => ( $id2 = $manager->generateSessionId() ),
+                       'persisted' => true,
+                       'userInfo' => UserInfo::newFromName( 'UTSysop', false ),
+                       'idIsSafe' => true,
+               ] );
+               $session = $manager->getSessionForRequest( $request );
+               $this->assertInstanceOf( Session::class, $session );
+               $this->assertSame( $id1, $session->getId() );
+               $this->logger->setCollect( false );
+               $this->assertFalse( $request->unpersist1 );
+               $this->assertTrue( $request->unpersist2 );
+               $request->unpersist2 = false;
 
                // Unpersisted session ID
                $request->info1 = new SessionInfo( SessionInfo::MAX_PRIORITY, [
@@ -293,8 +338,10 @@ class SessionManagerTest extends MediaWikiTestCase {
                ] );
                $request->info2 = null;
                $session = $manager->getSessionForRequest( $request );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id1, $session->getId() );
+               $this->assertTrue( $request->unpersist1 ); // The saving of the session does it
+               $this->assertFalse( $request->unpersist2 );
                $session->persist();
                $this->assertTrue( $session->isPersistent(), 'sanity check' );
        }
@@ -311,7 +358,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                // Unknown session ID
                $id = $manager->generateSessionId();
                $session = $manager->getSessionById( $id, true );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id, $session->getId() );
 
                $id = $manager->generateSessionId();
@@ -332,8 +379,42 @@ class SessionManagerTest extends MediaWikiTestCase {
                // Known session ID
                $this->store->setSession( $id, [] );
                $session = $manager->getSessionById( $id, false );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $id, $session->getId() );
+
+               // Store isn't checked if the session is already loaded
+               $this->store->setSession( $id, [ 'metadata' => [
+                       'userId' => User::idFromName( 'UTSysop' ),
+                       'userToken' => 'bad',
+               ] ] );
+               $session2 = $manager->getSessionById( $id, false );
+               $this->assertInstanceOf( Session::class, $session2 );
+               $this->assertSame( $id, $session2->getId() );
+               unset( $session, $session2 );
+               $this->logger->setCollect( true );
+               $this->assertNull( $manager->getSessionById( $id, true ) );
+               $this->logger->setCollect( false );
+
+               // Failure to create an empty session
+               $manager = $this->getManager();
+               $provider = $this->getMockBuilder( 'DummySessionProvider' )
+                       ->setMethods( [ 'provideSessionInfo', 'newSessionInfo', '__toString' ] )
+                       ->getMock();
+               $provider->expects( $this->any() )->method( 'provideSessionInfo' )
+                       ->will( $this->returnValue( null ) );
+               $provider->expects( $this->any() )->method( 'newSessionInfo' )
+                       ->will( $this->returnValue( null ) );
+               $provider->expects( $this->any() )->method( '__toString' )
+                       ->will( $this->returnValue( 'MockProvider' ) );
+               $this->config->set( 'SessionProviders', [
+                       $this->objectCacheDef( $provider ),
+               ] );
+               $this->logger->setCollect( true );
+               $this->assertNull( $manager->getSessionById( $id, true ) );
+               $this->logger->setCollect( false );
+               $this->assertSame( [
+                       [ LogLevel::ERROR, 'Failed to create empty session: {exception}' ]
+               ], $this->logger->getBuffer() );
        }
 
        public function testGetEmptySession() {
@@ -403,7 +484,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                ] );
                $info2 = null;
                $session = $manager->getEmptySession();
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( 'empty---------------------------', $session->getId() );
 
                // Info, explicitly
@@ -416,7 +497,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                ] );
                $info2 = null;
                $session = $pmanager->getEmptySessionInternal( null, $expectId );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( $expectId, $session->getId() );
 
                // Wrong ID
@@ -491,7 +572,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'idIsSafe' => true,
                ] );
                $session = $manager->getEmptySession();
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( 'empty1--------------------------', $session->getId() );
 
                $expectId = null;
@@ -508,7 +589,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'idIsSafe' => true,
                ] );
                $session = $manager->getEmptySession();
-               $this->assertInstanceOf( 'MediaWiki\\Session\\Session', $session );
+               $this->assertInstanceOf( Session::class, $session );
                $this->assertSame( 'empty2--------------------------', $session->getId() );
 
                // Tied priorities throw an exception
@@ -762,7 +843,7 @@ class SessionManagerTest extends MediaWikiTestCase {
 
                \ObjectCache::$instances[__METHOD__] = new TestBagOStuff();
                $this->setMwGlobals( [ 'wgMainCacheType' => __METHOD__ ] );
-               $this->setMWGlobals( [
+               $this->setMwGlobals( [
                        'wgAuth' => new AuthPlugin,
                ] );
 
@@ -1096,7 +1177,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                        'provider' => 'Mock',
                ];
 
-               $builder = $this->getMockBuilder( 'MediaWiki\\Session\\SessionProvider' )
+               $builder = $this->getMockBuilder( SessionProvider::class )
                        ->setMethods( [ '__toString', 'mergeMetadata', 'refreshSessionInfo' ] );
 
                $provider = $builder->getMockForAbstractClass();
@@ -1211,7 +1292,7 @@ class SessionManagerTest extends MediaWikiTestCase {
                ] );
                $this->assertFalse( $info->isIdSafe(), 'sanity check' );
                $this->assertTrue( $loadSessionInfoFromStore( $info ) );
-               $this->assertInstanceOf( 'MediaWiki\\Session\\UserInfo', $info->getUserInfo() );
+               $this->assertInstanceOf( UserInfo::class, $info->getUserInfo() );
                $this->assertTrue( $info->getUserInfo()->isVerified() );
                $this->assertTrue( $info->getUserInfo()->isAnon() );
                $this->assertFalse( $info->isIdSafe() );