maintenance/tests/phpunit/includes/UploadFromUrlTest.php

   1 <?php
   2
   3 require_once dirname( __FILE__ ) . '/api/ApiSetup.php';
   4
   5 /**
   6  * @group Broken
   7  */
   8 class UploadFromUrlTest extends ApiTestSetup {
   9
  10         public function setUp() {
  11                 global $wgEnableUploads, $wgAllowCopyUploads, $wgAllowAsyncCopyUploads;
  12                 parent::setUp();
  13
  14                 $wgEnableUploads = true;
  15                 $wgAllowCopyUploads = true;
  16                 $wgAllowAsyncCopyUploads = true;
  17                 wfSetupSession();
  18
  19                 ini_set( 'log_errors', 1 );
  20                 ini_set( 'error_reporting', 1 );
  21                 ini_set( 'display_errors', 1 );
  22
  23                 if ( wfLocalFile( 'UploadFromUrlTest.png' )->exists() ) {
  24                         $this->deleteFile( 'UploadFromUrlTest.png' );
  25                 }
  26         }
  27
  28         protected function doApiRequest( $params, $unused = null ) {
  29                 $sessionId = session_id();
  30                 session_write_close();
  31
  32                 $req = new FauxRequest( $params, true, $_SESSION );
  33                 $module = new ApiMain( $req, true );
  34                 $module->execute();
  35
  36                 wfSetupSession( $sessionId );
  37                 return array( $module->getResultData(), $req );
  38         }
  39
  40         /**
  41          * Ensure that the job queue is empty before continuing
  42          */
  43         public function testClearQueue() {
  44                 while ( $job = Job::pop() ) { }
  45                 $this->assertFalse( $job );
  46         }
  47
  48         /**
  49          * @todo Document why we test login, since the $wgUser hack used doesn't
  50          * require login
  51          */
  52         public function testLogin() {
  53                 $data = $this->doApiRequest( array(
  54                         'action' => 'login',
  55                         'lgname' => self::$userName,
  56                         'lgpassword' => self::$passWord ) );
  57                 $this->assertArrayHasKey( "login", $data[0] );
  58                 $this->assertArrayHasKey( "result", $data[0]['login'] );
  59                 $this->assertEquals( "NeedToken", $data[0]['login']['result'] );
  60                 $token = $data[0]['login']['token'];
  61
  62                 $data = $this->doApiRequest( array(
  63                         'action' => 'login',
  64                         "lgtoken" => $token,
  65                         "lgname" => self::$userName,
  66                         "lgpassword" => self::$passWord ) );
  67
  68                 $this->assertArrayHasKey( "login", $data[0] );
  69                 $this->assertArrayHasKey( "result", $data[0]['login'] );
  70                 $this->assertEquals( "Success", $data[0]['login']['result'] );
  71                 $this->assertArrayHasKey( 'lgtoken', $data[0]['login'] );
  72
  73                 return $data;
  74         }
  75
  76         /**
  77          * @depends testLogin
  78          * @depends testClearQueue
  79          */
  80         public function testSetupUrlDownload( $data ) {
  81                 $token = self::$user->editToken();
  82                 $exception = false;
  83
  84                 try {
  85                         $this->doApiRequest( array(
  86                                 'action' => 'upload',
  87                         ) );
  88                 } catch ( UsageException $e ) {
  89                         $exception = true;
  90                         $this->assertEquals( "The token parameter must be set", $e->getMessage() );
  91                 }
  92                 $this->assertTrue( $exception, "Got exception" );
  93
  94                 $exception = false;
  95                 try {
  96                         $this->doApiRequest( array(
  97                                 'action' => 'upload',
  98                                 'token' => $token,
  99                         ), $data );
 100                 } catch ( UsageException $e ) {
 101                         $exception = true;
 102                         $this->assertEquals( "One of the parameters sessionkey, file, url, statuskey is required",
 103                                 $e->getMessage() );
 104                 }
 105                 $this->assertTrue( $exception, "Got exception" );
 106
 107                 $exception = false;
 108                 try {
 109                         $this->doApiRequest( array(
 110                                 'action' => 'upload',
 111                                 'url' => 'http://www.example.com/test.png',
 112                                 'token' => $token,
 113                         ), $data );
 114                 } catch ( UsageException $e ) {
 115                         $exception = true;
 116                         $this->assertEquals( "The filename parameter must be set", $e->getMessage() );
 117                 }
 118                 $this->assertTrue( $exception, "Got exception" );
 119
 120                 self::$user->removeGroup( 'sysop' );
 121                 $exception = false;
 122                 try {
 123                         $this->doApiRequest( array(
 124                                 'action' => 'upload',
 125                                 'url' => 'http://www.example.com/test.png',
 126                                 'filename' => 'UploadFromUrlTest.png',
 127                                 'token' => $token,
 128                         ), $data );
 129                 } catch ( UsageException $e ) {
 130                         $exception = true;
 131                         $this->assertEquals( "Permission denied", $e->getMessage() );
 132                 }
 133                 $this->assertTrue( $exception, "Got exception" );
 134
 135                 self::$user->addGroup( 'sysop' );
 136                 $exception = false;
 137                 $data = $this->doApiRequest( array(
 138                         'action' => 'upload',
 139                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 140                         'asyncdownload' => 1,
 141                         'filename' => 'UploadFromUrlTest.png',
 142                         'token' => $token,
 143                 ), $data );
 144
 145                 $this->assertEquals( $data[0]['upload']['result'], 'Queued', 'Queued upload' );
 146
 147                 $job = Job::pop();
 148                 $this->assertThat( $job, $this->isInstanceOf( 'UploadFromUrlJob' ), 'Queued upload inserted' );
 149         }
 150
 151         /**
 152          * @depends testLogin
 153          * @depends testClearQueue
 154          */
 155         public function testAsyncUpload( $data ) {
 156                 $token = self::$user->editToken();
 157
 158                 self::$user->addGroup( 'users' );
 159
 160                 $data = $this->doAsyncUpload( $token, true );
 161                 $this->assertEquals( $data[0]['upload']['result'], 'Success' );
 162                 $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
 163                 $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );
 164
 165                 $this->deleteFile( 'UploadFromUrlTest.png' );
 166
 167                 return $data;
 168         }
 169
 170         /**
 171          * @depends testLogin
 172          * @depends testClearQueue
 173          */
 174         public function testAsyncUploadWarning( $data ) {
 175                 $token = self::$user->editToken();
 176
 177                 self::$user->addGroup( 'users' );
 178
 179
 180                 $data = $this->doAsyncUpload( $token );
 181
 182                 $this->assertEquals( $data[0]['upload']['result'], 'Warning' );
 183                 $this->assertTrue( isset( $data[0]['upload']['sessionkey'] ) );
 184
 185                 $data = $this->doApiRequest( array(
 186                         'action' => 'upload',
 187                         'sessionkey' => $data[0]['upload']['sessionkey'],
 188                         'filename' => 'UploadFromUrlTest.png',
 189                         'ignorewarnings' => 1,
 190                         'token' => $token,
 191                 ) );
 192                 $this->assertEquals( $data[0]['upload']['result'], 'Success' );
 193                 $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
 194                 $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );
 195
 196                 $this->deleteFile( 'UploadFromUrlTest.png' );
 197
 198                 return $data;
 199         }
 200
 201         /**
 202          * @depends testLogin
 203          * @depends testClearQueue
 204          */
 205         public function testSyncDownload( $data ) {
 206                 $token = self::$user->editToken();
 207
 208                 $job = Job::pop();
 209                 $this->assertFalse( $job, 'Starting with an empty jobqueue' );
 210
 211                 self::$user->addGroup( 'users' );
 212                 $data = $this->doApiRequest( array(
 213                         'action' => 'upload',
 214                         'filename' => 'UploadFromUrlTest.png',
 215                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 216                         'ignorewarnings' => true,
 217                         'token' => $token,
 218                 ), $data );
 219
 220                 $job = Job::pop();
 221                 $this->assertFalse( $job );
 222
 223                 $this->assertEquals( 'Success', $data[0]['upload']['result'] );
 224                 $this->deleteFile( 'UploadFromUrlTest.png' );
 225
 226                 return $data;
 227         }
 228
 229         public function testLeaveMessage() {
 230                 $token = self::$user->editToken();
 231
 232                 $talk = self::$user->getTalkPage();
 233                 if ( $talk->exists() ) {
 234                         $a = new Article( $talk );
 235                         $a->doDeleteArticle( '' );
 236                 }
 237
 238                 $this->assertFalse( (bool)$talk->getArticleId( Title::GAID_FOR_UPDATE ), 'User talk does not exist' );
 239
 240                 $data = $this->doApiRequest( array(
 241                         'action' => 'upload',
 242                         'filename' => 'UploadFromUrlTest.png',
 243                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 244                         'asyncdownload' => 1,
 245                         'token' => $token,
 246                         'leavemessage' => 1,
 247                         'ignorewarnings' => 1,
 248                 ) );
 249
 250                 $job = Job::pop();
 251                 $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );
 252                 $job->run();
 253
 254                 $this->assertTrue( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );
 255                 $this->assertTrue( (bool)$talk->getArticleId( Title::GAID_FOR_UPDATE ), 'User talk exists' );
 256
 257                 $this->deleteFile( 'UploadFromUrlTest.png' );
 258
 259                 $talkRev = Revision::newFromTitle( $talk );
 260                 $talkSize = $talkRev->getSize();
 261
 262                 $exception = false;
 263                 try {
 264                         $data = $this->doApiRequest( array(
 265                                 'action' => 'upload',
 266                                 'filename' => 'UploadFromUrlTest.png',
 267                                 'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 268                                 'asyncdownload' => 1,
 269                                 'token' => $token,
 270                                 'leavemessage' => 1,
 271                         ) );
 272                 } catch ( UsageException $e ) {
 273                         $exception = true;
 274                         $this->assertEquals( 'Using leavemessage without ignorewarnings is not supported', $e->getMessage() );
 275                 }
 276                 $this->assertTrue( $exception );
 277
 278                 $job = Job::pop();
 279                 $this->assertFalse( $job );
 280
 281                 return;
 282
 283                 /**
 284                 // Broken until using leavemessage with ignorewarnings is supported
 285                 $job->run();
 286
 287                 $this->assertFalse( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );
 288
 289                 $talkRev = Revision::newFromTitle( $talk );
 290                 $this->assertTrue( $talkRev->getSize() > $talkSize, 'New message left' );
 291                 */
 292         }
 293
 294         /**
 295          * Helper function to perform an async upload, execute the job and fetch
 296          * the status
 297          *
 298          * @return array The result of action=upload&statuskey=key
 299          */
 300         private function doAsyncUpload( $token, $ignoreWarnings = false, $leaveMessage = false ) {
 301                 $params = array(
 302                         'action' => 'upload',
 303                         'filename' => 'UploadFromUrlTest.png',
 304                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 305                         'asyncdownload' => 1,
 306                         'token' => $token,
 307                 );
 308                 if ( $ignoreWarnings ) {
 309                         $params['ignorewarnings'] = 1;
 310                 }
 311                 if ( $leaveMessage ) {
 312                         $params['leavemessage'] = 1;
 313                 }
 314
 315                 $data = $this->doApiRequest( $params );
 316                 $this->assertEquals( $data[0]['upload']['result'], 'Queued' );
 317                 $this->assertTrue( isset( $data[0]['upload']['statuskey'] ) );
 318                 $statusKey = $data[0]['upload']['statuskey'];
 319
 320                 $job = Job::pop();
 321                 $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );
 322
 323                 $status = $job->run();
 324                 $this->assertTrue( $status );
 325
 326                 $data = $this->doApiRequest( array(
 327                         'action' => 'upload',
 328                         'statuskey' => $statusKey,
 329                         'token' => $token,
 330                 ) );
 331
 332                 return $data;
 333         }
 334
 335
 336         /**
 337          *
 338          */
 339         protected function deleteFile( $name ) {
 340                 $t = Title::newFromText( $name, NS_FILE );
 341                 $this->assertTrue($t->exists(), "File '$name' exists");
 342
 343                 if ( $t->exists() ) {
 344                         $file = wfFindFile( $name, array( 'ignoreRedirect' => true ) );
 345                         $empty = "";
 346                         FileDeleteForm::doDelete( $t, $file, $empty, "none", true );
 347                         $a = new Article ( $t );
 348                         $a->doDeleteArticle( "testing" );
 349                 }
 350                 $t = Title::newFromText( $name, NS_FILE );
 351
 352                 $this->assertFalse($t->exists(), "File '$name' was deleted");
 353         }
 354  }