tests/phpunit/includes/block/CompositeBlockTest.php

   1 <?php
   2
   3 use MediaWiki\Block\BlockRestrictionStore;
   4 use MediaWiki\Block\CompositeBlock;
   5 use MediaWiki\Block\Restriction\PageRestriction;
   6 use MediaWiki\Block\Restriction\NamespaceRestriction;
   7 use MediaWiki\Block\SystemBlock;
   8 use MediaWiki\MediaWikiServices;
   9
  10 /**
  11  * @group Database
  12  * @group Blocking
  13  * @coversDefaultClass \MediaWiki\Block\CompositeBlock
  14  */
  15 class CompositeBlockTest extends MediaWikiLangTestCase {
  16         private function getPartialBlocks() {
  17                 $sysopId = $this->getTestSysop()->getUser()->getId();
  18
  19                 $userBlock = new Block( [
  20                         'address' => $this->getTestUser()->getUser(),
  21                         'by' => $sysopId,
  22                         'sitewide' => false,
  23                 ] );
  24                 $ipBlock = new Block( [
  25                         'address' => '127.0.0.1',
  26                         'by' => $sysopId,
  27                         'sitewide' => false,
  28                 ] );
  29
  30                 $userBlock->insert();
  31                 $ipBlock->insert();
  32
  33                 return [
  34                         'user' => $userBlock,
  35                         'ip' => $ipBlock,
  36                 ];
  37         }
  38
  39         private function deleteBlocks( $blocks ) {
  40                 foreach ( $blocks as $block ) {
  41                         $block->delete();
  42                 }
  43         }
  44
  45         /**
  46          * @covers ::__construct
  47          * @dataProvider provideTestStrictestParametersApplied
  48          */
  49         public function testStrictestParametersApplied( $blocks, $expected ) {
  50                 $this->setMwGlobals( [
  51                         'wgBlockDisablesLogin' => false,
  52                         'wgBlockAllowsUTEdit' => true,
  53                 ] );
  54
  55                 $block = new CompositeBlock( [
  56                         'originalBlocks' => $blocks,
  57                 ] );
  58
  59                 $this->assertSame( $expected[ 'hideName' ], $block->getHideName() );
  60                 $this->assertSame( $expected[ 'sitewide' ], $block->isSitewide() );
  61                 $this->assertSame( $expected[ 'blockEmail' ], $block->isEmailBlocked() );
  62                 $this->assertSame( $expected[ 'allowUsertalk' ], $block->isUsertalkEditAllowed() );
  63         }
  64
  65         public static function provideTestStrictestParametersApplied() {
  66                 return [
  67                         'Sitewide block and partial block' => [
  68                                 [
  69                                         new Block( [
  70                                                 'sitewide' => false,
  71                                                 'blockEmail' => true,
  72                                                 'allowUsertalk' => true,
  73                                         ] ),
  74                                         new Block( [
  75                                                 'sitewide' => true,
  76                                                 'blockEmail' => false,
  77                                                 'allowUsertalk' => false,
  78                                         ] ),
  79                                 ],
  80                                 [
  81                                         'hideName' => false,
  82                                         'sitewide' => true,
  83                                         'blockEmail' => true,
  84                                         'allowUsertalk' => false,
  85                                 ],
  86                         ],
  87                         'Partial block and system block' => [
  88                                 [
  89                                         new Block( [
  90                                                 'sitewide' => false,
  91                                                 'blockEmail' => true,
  92                                                 'allowUsertalk' => false,
  93                                         ] ),
  94                                         new SystemBlock( [
  95                                                 'systemBlock' => 'proxy',
  96                                         ] ),
  97                                 ],
  98                                 [
  99                                         'hideName' => false,
 100                                         'sitewide' => true,
 101                                         'blockEmail' => true,
 102                                         'allowUsertalk' => false,
 103                                 ],
 104                         ],
 105                         'System block and user name hiding block' => [
 106                                 [
 107                                         new Block( [
 108                                                 'hideName' => true,
 109                                                 'sitewide' => true,
 110                                                 'blockEmail' => true,
 111                                                 'allowUsertalk' => false,
 112                                         ] ),
 113                                         new SystemBlock( [
 114                                                 'systemBlock' => 'proxy',
 115                                         ] ),
 116                                 ],
 117                                 [
 118                                         'hideName' => true,
 119                                         'sitewide' => true,
 120                                         'blockEmail' => true,
 121                                         'allowUsertalk' => false,
 122                                 ],
 123                         ],
 124                         'Two lenient partial blocks' => [
 125                                 [
 126                                         new Block( [
 127                                                 'sitewide' => false,
 128                                                 'blockEmail' => false,
 129                                                 'allowUsertalk' => true,
 130                                         ] ),
 131                                         new Block( [
 132                                                 'sitewide' => false,
 133                                                 'blockEmail' => false,
 134                                                 'allowUsertalk' => true,
 135                                         ] ),
 136                                 ],
 137                                 [
 138                                         'hideName' => false,
 139                                         'sitewide' => false,
 140                                         'blockEmail' => false,
 141                                         'allowUsertalk' => true,
 142                                 ],
 143                         ],
 144                 ];
 145         }
 146
 147         /**
 148          * @covers ::appliesToTitle
 149          */
 150         public function testBlockAppliesToTitle() {
 151                 $this->setMwGlobals( [
 152                         'wgBlockDisablesLogin' => false,
 153                 ] );
 154
 155                 $blocks = $this->getPartialBlocks();
 156
 157                 $block = new CompositeBlock( [
 158                         'originalBlocks' => $blocks,
 159                 ] );
 160
 161                 $pageFoo = $this->getExistingTestPage( 'Foo' );
 162                 $pageBar = $this->getExistingTestPage( 'User:Bar' );
 163
 164                 $this->getBlockRestrictionStore()->insert( [
 165                         new PageRestriction( $blocks[ 'user' ]->getId(), $pageFoo->getId() ),
 166                         new NamespaceRestriction( $blocks[ 'ip' ]->getId(), NS_USER ),
 167                 ] );
 168
 169                 $this->assertTrue( $block->appliesToTitle( $pageFoo->getTitle() ) );
 170                 $this->assertTrue( $block->appliesToTitle( $pageBar->getTitle() ) );
 171
 172                 $this->deleteBlocks( $blocks );
 173         }
 174
 175         /**
 176          * @covers ::appliesToUsertalk
 177          * @covers ::appliesToPage
 178          * @covers ::appliesToNamespace
 179          */
 180         public function testBlockAppliesToUsertalk() {
 181                 $this->setMwGlobals( [
 182                         'wgBlockAllowsUTEdit' => true,
 183                         'wgBlockDisablesLogin' => false,
 184                 ] );
 185
 186                 $blocks = $this->getPartialBlocks();
 187
 188                 $block = new CompositeBlock( [
 189                         'originalBlocks' => $blocks,
 190                 ] );
 191
 192                 $title = $blocks[ 'user' ]->getTarget()->getTalkPage();
 193                 $page = $this->getExistingTestPage( 'User talk:' . $title->getText() );
 194
 195                 $this->getBlockRestrictionStore()->insert( [
 196                         new PageRestriction( $blocks[ 'user' ]->getId(), $page->getId() ),
 197                         new NamespaceRestriction( $blocks[ 'ip' ]->getId(), NS_USER ),
 198                 ] );
 199
 200                 $this->assertTrue( $block->appliesToUsertalk( $blocks[ 'user' ]->getTarget()->getTalkPage() ) );
 201
 202                 $this->deleteBlocks( $blocks );
 203         }
 204
 205         /**
 206          * @covers ::appliesToRight
 207          * @dataProvider provideTestBlockAppliesToRight
 208          */
 209         public function testBlockAppliesToRight( $blocks, $right, $expected ) {
 210                 $this->setMwGlobals( [
 211                         'wgBlockDisablesLogin' => false,
 212                 ] );
 213
 214                 $block = new CompositeBlock( [
 215                         'originalBlocks' => $blocks,
 216                 ] );
 217
 218                 $this->assertSame( $block->appliesToRight( $right ), $expected );
 219         }
 220
 221         public static function provideTestBlockAppliesToRight() {
 222                 return [
 223                         'Read is not blocked' => [
 224                                 [
 225                                         new Block(),
 226                                         new Block(),
 227                                 ],
 228                                 'read',
 229                                 false,
 230                         ],
 231                         'Email is blocked if blocked by any blocks' => [
 232                                 [
 233                                         new Block( [
 234                                                 'blockEmail' => true,
 235                                         ] ),
 236                                         new Block( [
 237                                                 'blockEmail' => false,
 238                                         ] ),
 239                                 ],
 240                                 'sendemail',
 241                                 true,
 242                         ],
 243                 ];
 244         }
 245
 246         /**
 247          * Get an instance of BlockRestrictionStore
 248          *
 249          * @return BlockRestrictionStore
 250          */
 251         protected function getBlockRestrictionStore() : BlockRestrictionStore {
 252                 return MediaWikiServices::getInstance()->getBlockRestrictionStore();
 253         }
 254 }