Merge "Title: Title::getSubpage should not lose the interwiki prefix"

[lhc/web/wiklou.git] / tests / phpunit / includes / block / BlockManagerTest.php

diff --git a/tests/phpunit/includes/block/BlockManagerTest.php b/tests/phpunit/includes/block/BlockManagerTest.php
index aec25c1..fe3bb88 100644 (file)
--- a/tests/phpunit/includes/block/BlockManagerTest.php
+++ b/tests/phpunit/includes/block/BlockManagerTest.php
@@ -2,6 +2,9 @@
 
 use MediaWiki\Block\BlockManager;
 use MediaWiki\Block\DatabaseBlock;
+use MediaWiki\Block\SystemBlock;
+use MediaWiki\Config\ServiceOptions;
+use MediaWiki\MediaWikiServices;
 
 /**
  * @group Blocking
@@ -29,22 +32,35 @@ class BlockManagerTest extends MediaWikiTestCase {
                        'wgEnableDnsBlacklist' => true,
                        'wgProxyList' => [],
                        'wgProxyWhitelist' => [],
+                       'wgSecretKey' => false,
                        'wgSoftBlockRanges' => [],
                ];
        }
 
        private function getBlockManager( $overrideConfig ) {
-               $blockManagerConfig = array_merge( $this->blockManagerConfig, $overrideConfig );
                return new BlockManager(
-                       $this->user,
-                       $this->user->getRequest(),
-                       ...array_values( $blockManagerConfig )
+                       ...$this->getBlockManagerConstructorArgs( $overrideConfig )
                );
        }
 
+       private function getBlockManagerConstructorArgs( $overrideConfig ) {
+               $blockManagerConfig = array_merge( $this->blockManagerConfig, $overrideConfig );
+               $this->setMwGlobals( $blockManagerConfig );
+               $this->overrideMwServices();
+               return [
+                       new ServiceOptions(
+                               BlockManager::$constructorOptions,
+                               MediaWikiServices::getInstance()->getMainConfig()
+                       ),
+                       $this->user,
+                       $this->user->getRequest()
+               ];
+       }
+
        /**
         * @dataProvider provideGetBlockFromCookieValue
         * @covers ::getBlockFromCookieValue
+        * @covers ::shouldApplyCookieBlock
         */
        public function testGetBlockFromCookieValue( $options, $expected ) {
                $blockManager = $this->getBlockManager( [
@@ -176,18 +192,14 @@ class BlockManagerTest extends MediaWikiTestCase {
         * @covers ::inDnsBlacklist
         */
        public function testIsDnsBlacklisted( $options, $expected ) {
-               $blockManagerConfig = array_merge( $this->blockManagerConfig, [
+               $blockManagerConfig = [
                        'wgEnableDnsBlacklist' => true,
                        'wgDnsBlacklistUrls' => $options['blacklist'],
                        'wgProxyWhitelist' => $options['whitelist'],
-               ] );
+               ];
 
                $blockManager = $this->getMockBuilder( BlockManager::class )
-                       ->setConstructorArgs(
-                               array_merge( [
-                                       $this->user,
-                                       $this->user->getRequest(),
-                               ], $blockManagerConfig ) )
+                       ->setConstructorArgs( $this->getBlockManagerConstructorArgs( $blockManagerConfig ) )
                        ->setMethods( [ 'checkHost' ] )
                        ->getMock();
 
@@ -287,4 +299,96 @@ class BlockManagerTest extends MediaWikiTestCase {
                        ],
                ];
        }
+
+       /**
+        * @covers ::getUniqueBlocks
+        */
+       public function testGetUniqueBlocks() {
+               $blockId = 100;
+
+               $class = new ReflectionClass( BlockManager::class );
+               $method = $class->getMethod( 'getUniqueBlocks' );
+               $method->setAccessible( true );
+
+               $blockManager = $this->getBlockManager( [] );
+
+               $block = $this->getMockBuilder( DatabaseBlock::class )
+                       ->setMethods( [ 'getId' ] )
+                       ->getMock();
+               $block->expects( $this->any() )
+                       ->method( 'getId' )
+                       ->willReturn( $blockId );
+
+               $autoblock = $this->getMockBuilder( DatabaseBlock::class )
+                       ->setMethods( [ 'getParentBlockId', 'getType' ] )
+                       ->getMock();
+               $autoblock->expects( $this->any() )
+                       ->method( 'getParentBlockId' )
+                       ->willReturn( $blockId );
+               $autoblock->expects( $this->any() )
+                       ->method( 'getType' )
+                       ->willReturn( DatabaseBlock::TYPE_AUTO );
+
+               $blocks = [ $block, $block, $autoblock, new SystemBlock() ];
+
+               $this->assertSame( 2, count( $method->invoke( $blockManager, $blocks ) ) );
+       }
+
+       /**
+        * @covers ::trackBlockWithCookie
+        * @dataProvider provideTrackBlockWithCookie
+        * @param bool $expectCookieSet
+        * @param bool $hasCookie
+        * @param bool $isBlocked
+        */
+       public function testTrackBlockWithCookie( $expectCookieSet, $hasCookie, $isBlocked ) {
+               $blockID = 123;
+               $this->setMwGlobals( 'wgCookiePrefix', '' );
+
+               $request = new FauxRequest();
+               if ( $hasCookie ) {
+                       $request->setCookie( 'BlockID', 'the value does not matter' );
+               }
+
+               if ( $isBlocked ) {
+                       $block = $this->getMockBuilder( DatabaseBlock::class )
+                               ->setMethods( [ 'getType', 'getId' ] )
+                               ->getMock();
+                       $block->method( 'getType' )
+                               ->willReturn( DatabaseBlock::TYPE_IP );
+                       $block->method( 'getId' )
+                               ->willReturn( $blockID );
+               } else {
+                       $block = null;
+               }
+
+               $user = $this->getMockBuilder( User::class )
+                       ->setMethods( [ 'getBlock', 'getRequest' ] )
+                       ->getMock();
+               $user->method( 'getBlock' )
+                       ->willReturn( $block );
+               $user->method( 'getRequest' )
+                       ->willReturn( $request );
+               /** @var User $user */
+
+               // Although the block cookie is set via DeferredUpdates, in command line mode updates are
+               // processed immediately
+               $blockManager = $this->getBlockManager( [] );
+               $blockManager->trackBlockWithCookie( $user );
+
+               /** @var FauxResponse $response */
+               $response = $request->response();
+               $this->assertCount( $expectCookieSet ? 1 : 0, $response->getCookies() );
+               $this->assertEquals( $expectCookieSet ? $blockID : null, $response->getCookie( 'BlockID' ) );
+       }
+
+       public function provideTrackBlockWithCookie() {
+               return [
+                       // $expectCookieSet, $hasCookie, $isBlocked
+                       [ false, false, false ],
+                       [ false, true, false ],
+                       [ true, false, true ],
+                       [ false, true, true ],
+               ];
+       }
 }