tests/phpunit/includes/FauxRequestTest.php

   1 <?php
   2
   3 use MediaWiki\Session\SessionManager;
   4
   5 class FauxRequestTest extends PHPUnit\Framework\TestCase {
   6
   7         use MediaWikiCoversValidator;
   8         use PHPUnit4And6Compat;
   9
  10         public function setUp() {
  11                 parent::setUp();
  12                 $this->orgWgServer = $GLOBALS['wgServer'];
  13         }
  14
  15         public function tearDown() {
  16                 $GLOBALS['wgServer'] = $this->orgWgServer;
  17                 parent::tearDown();
  18         }
  19
  20         /**
  21          * @covers FauxRequest::__construct
  22          */
  23         public function testConstructInvalidData() {
  24                 $this->setExpectedException( MWException::class, 'bogus data' );
  25                 $req = new FauxRequest( 'x' );
  26         }
  27
  28         /**
  29          * @covers FauxRequest::__construct
  30          */
  31         public function testConstructInvalidSession() {
  32                 $this->setExpectedException( MWException::class, 'bogus session' );
  33                 $req = new FauxRequest( [], false, 'x' );
  34         }
  35
  36         /**
  37          * @covers FauxRequest::__construct
  38          */
  39         public function testConstructWithSession() {
  40                 $session = SessionManager::singleton()->getEmptySession( new FauxRequest( [] ) );
  41                 $this->assertInstanceOf(
  42                         FauxRequest::class,
  43                         new FauxRequest( [], false, $session )
  44                 );
  45         }
  46
  47         /**
  48          * @covers FauxRequest::getText
  49          */
  50         public function testGetText() {
  51                 $req = new FauxRequest( [ 'x' => 'Value' ] );
  52                 $this->assertEquals( 'Value', $req->getText( 'x' ) );
  53                 $this->assertSame( '', $req->getText( 'z' ) );
  54         }
  55
  56         /**
  57          * Integration test for parent method
  58          * @covers FauxRequest::getVal
  59          */
  60         public function testGetVal() {
  61                 $req = new FauxRequest( [ 'crlf' => "A\r\nb" ] );
  62                 $this->assertSame( "A\r\nb", $req->getVal( 'crlf' ), 'CRLF' );
  63         }
  64
  65         /**
  66          * Integration test for parent method
  67          * @covers FauxRequest::getRawVal
  68          */
  69         public function testGetRawVal() {
  70                 $req = new FauxRequest( [
  71                         'x' => 'Value',
  72                         'y' => [ 'a' ],
  73                         'crlf' => "A\r\nb"
  74                 ] );
  75                 $this->assertSame( 'Value', $req->getRawVal( 'x' ) );
  76                 $this->assertSame( null, $req->getRawVal( 'z' ), 'Not found' );
  77                 $this->assertSame( null, $req->getRawVal( 'y' ), 'Array is ignored' );
  78                 $this->assertSame( "A\r\nb", $req->getRawVal( 'crlf' ), 'CRLF' );
  79         }
  80
  81         /**
  82          * @covers FauxRequest::getValues
  83          */
  84         public function testGetValues() {
  85                 $values = [ 'x' => 'Value', 'y' => '' ];
  86                 $req = new FauxRequest( $values );
  87                 $this->assertEquals( $values, $req->getValues() );
  88         }
  89
  90         /**
  91          * @covers FauxRequest::getQueryValues
  92          */
  93         public function testGetQueryValues() {
  94                 $values = [ 'x' => 'Value', 'y' => '' ];
  95
  96                 $req = new FauxRequest( $values );
  97                 $this->assertEquals( $values, $req->getQueryValues() );
  98                 $req = new FauxRequest( $values, /*wasPosted*/ true );
  99                 $this->assertEquals( [], $req->getQueryValues() );
 100         }
 101
 102         /**
 103          * @covers FauxRequest::getMethod
 104          */
 105         public function testGetMethod() {
 106                 $req = new FauxRequest( [] );
 107                 $this->assertEquals( 'GET', $req->getMethod() );
 108                 $req = new FauxRequest( [], /*wasPosted*/ true );
 109                 $this->assertEquals( 'POST', $req->getMethod() );
 110         }
 111
 112         /**
 113          * @covers FauxRequest::wasPosted
 114          */
 115         public function testWasPosted() {
 116                 $req = new FauxRequest( [] );
 117                 $this->assertFalse( $req->wasPosted() );
 118                 $req = new FauxRequest( [], /*wasPosted*/ true );
 119                 $this->assertTrue( $req->wasPosted() );
 120         }
 121
 122         /**
 123          * @covers FauxRequest::getCookie
 124          * @covers FauxRequest::setCookie
 125          * @covers FauxRequest::setCookies
 126          */
 127         public function testCookies() {
 128                 $req = new FauxRequest();
 129                 $this->assertSame( null, $req->getCookie( 'z', '' ) );
 130
 131                 $req->setCookie( 'x', 'Value', '' );
 132                 $this->assertEquals( 'Value', $req->getCookie( 'x', '' ) );
 133
 134                 $req->setCookies( [ 'x' => 'One', 'y' => 'Two' ], '' );
 135                 $this->assertEquals( 'One', $req->getCookie( 'x', '' ) );
 136                 $this->assertEquals( 'Two', $req->getCookie( 'y', '' ) );
 137         }
 138
 139         /**
 140          * @covers FauxRequest::getCookie
 141          * @covers FauxRequest::setCookie
 142          * @covers FauxRequest::setCookies
 143          */
 144         public function testCookiesDefaultPrefix() {
 145                 global $wgCookiePrefix;
 146                 $oldPrefix = $wgCookiePrefix;
 147                 $wgCookiePrefix = '_';
 148
 149                 $req = new FauxRequest();
 150                 $this->assertSame( null, $req->getCookie( 'z' ) );
 151
 152                 $req->setCookie( 'x', 'Value' );
 153                 $this->assertEquals( 'Value', $req->getCookie( 'x' ) );
 154
 155                 $wgCookiePrefix = $oldPrefix;
 156         }
 157
 158         /**
 159          * @covers FauxRequest::getRequestURL
 160          */
 161         public function testGetRequestURL_disallowed() {
 162                 $req = new FauxRequest();
 163                 $this->setExpectedException( MWException::class );
 164                 $req->getRequestURL();
 165         }
 166
 167         /**
 168          * @covers FauxRequest::setRequestURL
 169          * @covers FauxRequest::getRequestURL
 170          */
 171         public function testSetRequestURL() {
 172                 $req = new FauxRequest();
 173                 $req->setRequestURL( 'https://example.org' );
 174                 $this->assertEquals( 'https://example.org', $req->getRequestURL() );
 175         }
 176
 177         /**
 178          * @covers FauxRequest::getFullRequestURL
 179          */
 180         public function testGetFullRequestURL_disallowed() {
 181                 $GLOBALS['wgServer'] = '//wiki.test';
 182                 $req = new FauxRequest();
 183
 184                 $this->setExpectedException( MWException::class );
 185                 $req->getFullRequestURL();
 186         }
 187
 188         /**
 189          * @covers FauxRequest::getFullRequestURL
 190          */
 191         public function testGetFullRequestURL_http() {
 192                 $GLOBALS['wgServer'] = '//wiki.test';
 193                 $req = new FauxRequest();
 194                 $req->setRequestURL( '/path' );
 195
 196                 $this->assertSame(
 197                         'http://wiki.test/path',
 198                         $req->getFullRequestURL()
 199                 );
 200         }
 201
 202         /**
 203          * @covers FauxRequest::getFullRequestURL
 204          */
 205         public function testGetFullRequestURL_https() {
 206                 $GLOBALS['wgServer'] = '//wiki.test';
 207                 $req = new FauxRequest( [], false, null, 'https' );
 208                 $req->setRequestURL( '/path' );
 209
 210                 $this->assertSame(
 211                         'https://wiki.test/path',
 212                         $req->getFullRequestURL()
 213                 );
 214         }
 215
 216         /**
 217          * @covers FauxRequest::__construct
 218          * @covers FauxRequest::getProtocol
 219          */
 220         public function testProtocol() {
 221                 $req = new FauxRequest();
 222                 $this->assertEquals( 'http', $req->getProtocol() );
 223                 $req = new FauxRequest( [], false, null, 'http' );
 224                 $this->assertEquals( 'http', $req->getProtocol() );
 225                 $req = new FauxRequest( [], false, null, 'https' );
 226                 $this->assertEquals( 'https', $req->getProtocol() );
 227         }
 228
 229         /**
 230          * @covers FauxRequest::setHeader
 231          * @covers FauxRequest::setHeaders
 232          * @covers FauxRequest::getHeader
 233          */
 234         public function testGetSetHeader() {
 235                 $value = 'text/plain, text/html';
 236
 237                 $request = new FauxRequest();
 238                 $request->setHeader( 'Accept', $value );
 239
 240                 $this->assertEquals( $request->getHeader( 'Nonexistent' ), false );
 241                 $this->assertEquals( $request->getHeader( 'Accept' ), $value );
 242                 $this->assertEquals( $request->getHeader( 'ACCEPT' ), $value );
 243                 $this->assertEquals( $request->getHeader( 'accept' ), $value );
 244                 $this->assertEquals(
 245                         $request->getHeader( 'Accept', WebRequest::GETHEADER_LIST ),
 246                         [ 'text/plain', 'text/html' ]
 247                 );
 248         }
 249
 250         /**
 251          * @covers FauxRequest::initHeaders
 252          */
 253         public function testGetAllHeaders() {
 254                 $_SERVER['HTTP_TEST'] = 'Example';
 255
 256                 $request = new FauxRequest();
 257
 258                 $this->assertEquals(
 259                         [],
 260                         $request->getAllHeaders()
 261                 );
 262
 263                 $this->assertEquals(
 264                         false,
 265                         $request->getHeader( 'test' )
 266                 );
 267         }
 268
 269         /**
 270          * @covers FauxRequest::__construct
 271          * @covers FauxRequest::getSessionArray
 272          */
 273         public function testSessionData() {
 274                 $values = [ 'x' => 'Value', 'y' => '' ];
 275
 276                 $req = new FauxRequest( [], false, /*session*/ $values );
 277                 $this->assertEquals( $values, $req->getSessionArray() );
 278
 279                 $req = new FauxRequest();
 280                 $this->assertSame( null, $req->getSessionArray() );
 281         }
 282
 283         /**
 284          * @covers FauxRequest::getRawQueryString
 285          * @covers FauxRequest::getRawPostString
 286          * @covers FauxRequest::getRawInput
 287          */
 288         public function testDummies() {
 289                 $req = new FauxRequest();
 290                 $this->assertSame( '', $req->getRawQueryString() );
 291                 $this->assertSame( '', $req->getRawPostString() );
 292                 $this->assertSame( '', $req->getRawInput() );
 293         }
 294 }