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                 $data = $this->doApiRequest( array(
 137                         'action' => 'upload',
 138                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 139                         'asyncdownload' => 1,
 140                         'filename' => 'UploadFromUrlTest.png',
 141                         'token' => $token,
 142                 ), $data );
 143
 144                 $this->assertEquals( $data[0]['upload']['result'], 'Queued', 'Queued upload' );
 145
 146                 $job = Job::pop();
 147                 $this->assertThat( $job, $this->isInstanceOf( 'UploadFromUrlJob' ), 'Queued upload inserted' );
 148         }
 149
 150         /**
 151          * @depends testLogin
 152          * @depends testClearQueue
 153          */
 154         public function testAsyncUpload( $data ) {
 155                 $token = self::$user->editToken();
 156
 157                 self::$user->addGroup( 'users' );
 158
 159                 $data = $this->doAsyncUpload( $token, true );
 160                 $this->assertEquals( $data[0]['upload']['result'], 'Success' );
 161                 $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
 162                 $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );
 163
 164                 $this->deleteFile( 'UploadFromUrlTest.png' );
 165
 166                 return $data;
 167         }
 168
 169         /**
 170          * @depends testLogin
 171          * @depends testClearQueue
 172          */
 173         public function testAsyncUploadWarning( $data ) {
 174                 $token = self::$user->editToken();
 175
 176                 self::$user->addGroup( 'users' );
 177
 178
 179                 $data = $this->doAsyncUpload( $token );
 180
 181                 $this->assertEquals( $data[0]['upload']['result'], 'Warning' );
 182                 $this->assertTrue( isset( $data[0]['upload']['sessionkey'] ) );
 183
 184                 $data = $this->doApiRequest( array(
 185                         'action' => 'upload',
 186                         'sessionkey' => $data[0]['upload']['sessionkey'],
 187                         'filename' => 'UploadFromUrlTest.png',
 188                         'ignorewarnings' => 1,
 189                         'token' => $token,
 190                 ) );
 191                 $this->assertEquals( $data[0]['upload']['result'], 'Success' );
 192                 $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
 193                 $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );
 194
 195                 $this->deleteFile( 'UploadFromUrlTest.png' );
 196
 197                 return $data;
 198         }
 199
 200         /**
 201          * @depends testLogin
 202          * @depends testClearQueue
 203          */
 204         public function testSyncDownload( $data ) {
 205                 $token = self::$user->editToken();
 206
 207                 $job = Job::pop();
 208                 $this->assertFalse( $job, 'Starting with an empty jobqueue' );
 209
 210                 self::$user->addGroup( 'users' );
 211                 $data = $this->doApiRequest( array(
 212                         'action' => 'upload',
 213                         'filename' => 'UploadFromUrlTest.png',
 214                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 215                         'ignorewarnings' => true,
 216                         'token' => $token,
 217                 ), $data );
 218
 219                 $job = Job::pop();
 220                 $this->assertFalse( $job );
 221
 222                 $this->assertEquals( 'Success', $data[0]['upload']['result'] );
 223                 $this->deleteFile( 'UploadFromUrlTest.png' );
 224
 225                 return $data;
 226         }
 227
 228         public function testLeaveMessage() {
 229                 $token = self::$user->editToken();
 230
 231                 $talk = self::$user->getTalkPage();
 232                 if ( $talk->exists() ) {
 233                         $a = new Article( $talk );
 234                         $a->doDeleteArticle( '' );
 235                 }
 236
 237                 $this->assertFalse( (bool)$talk->getArticleId( Title::GAID_FOR_UPDATE ), 'User talk does not exist' );
 238
 239                 $data = $this->doApiRequest( array(
 240                         'action' => 'upload',
 241                         'filename' => 'UploadFromUrlTest.png',
 242                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 243                         'asyncdownload' => 1,
 244                         'token' => $token,
 245                         'leavemessage' => 1,
 246                         'ignorewarnings' => 1,
 247                 ) );
 248
 249                 $job = Job::pop();
 250                 $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );
 251                 $job->run();
 252
 253                 $this->assertTrue( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );
 254                 $this->assertTrue( (bool)$talk->getArticleId( Title::GAID_FOR_UPDATE ), 'User talk exists' );
 255
 256                 $this->deleteFile( 'UploadFromUrlTest.png' );
 257
 258                 $talkRev = Revision::newFromTitle( $talk );
 259                 $talkSize = $talkRev->getSize();
 260
 261                 $exception = false;
 262                 try {
 263                         $data = $this->doApiRequest( array(
 264                                 'action' => 'upload',
 265                                 'filename' => 'UploadFromUrlTest.png',
 266                                 'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 267                                 'asyncdownload' => 1,
 268                                 'token' => $token,
 269                                 'leavemessage' => 1,
 270                         ) );
 271                 } catch ( UsageException $e ) {
 272                         $exception = true;
 273                         $this->assertEquals( 'Using leavemessage without ignorewarnings is not supported', $e->getMessage() );
 274                 }
 275                 $this->assertTrue( $exception );
 276
 277                 $job = Job::pop();
 278                 $this->assertFalse( $job );
 279
 280                 return;
 281
 282                 /**
 283                 // Broken until using leavemessage with ignorewarnings is supported
 284                 $job->run();
 285
 286                 $this->assertFalse( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );
 287
 288                 $talkRev = Revision::newFromTitle( $talk );
 289                 $this->assertTrue( $talkRev->getSize() > $talkSize, 'New message left' );
 290                 */
 291         }
 292
 293         /**
 294          * Helper function to perform an async upload, execute the job and fetch
 295          * the status
 296          *
 297          * @return array The result of action=upload&statuskey=key
 298          */
 299         private function doAsyncUpload( $token, $ignoreWarnings = false, $leaveMessage = false ) {
 300                 $params = array(
 301                         'action' => 'upload',
 302                         'filename' => 'UploadFromUrlTest.png',
 303                         'url' => 'http://bits.wikimedia.org/skins-1.5/common/images/poweredby_mediawiki_88x31.png',
 304                         'asyncdownload' => 1,
 305                         'token' => $token,
 306                 );
 307                 if ( $ignoreWarnings ) {
 308                         $params['ignorewarnings'] = 1;
 309                 }
 310                 if ( $leaveMessage ) {
 311                         $params['leavemessage'] = 1;
 312                 }
 313
 314                 $data = $this->doApiRequest( $params );
 315                 $this->assertEquals( $data[0]['upload']['result'], 'Queued' );
 316                 $this->assertTrue( isset( $data[0]['upload']['statuskey'] ) );
 317                 $statusKey = $data[0]['upload']['statuskey'];
 318
 319                 $job = Job::pop();
 320                 $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );
 321
 322                 $status = $job->run();
 323                 $this->assertTrue( $status );
 324
 325                 $data = $this->doApiRequest( array(
 326                         'action' => 'upload',
 327                         'statuskey' => $statusKey,
 328                         'token' => $token,
 329                 ) );
 330
 331                 return $data;
 332         }
 333
 334
 335         /**
 336          *
 337          */
 338         protected function deleteFile( $name ) {
 339                 $t = Title::newFromText( $name, NS_FILE );
 340                 $this->assertTrue($t->exists(), "File '$name' exists");
 341
 342                 if ( $t->exists() ) {
 343                         $file = wfFindFile( $name, array( 'ignoreRedirect' => true ) );
 344                         $empty = "";
 345                         FileDeleteForm::doDelete( $t, $file, $empty, "none", true );
 346                         $a = new Article ( $t );
 347                         $a->doDeleteArticle( "testing" );
 348                 }
 349                 $t = Title::newFromText( $name, NS_FILE );
 350
 351                 $this->assertFalse($t->exists(), "File '$name' was deleted");
 352         }
 353  }