tests/phpunit/includes/UploadFromUrlTest.php

   1 <?php
   2
   3 require_once dirname( __FILE__ ) . '/api/ApiSetup.php';
   4
   5 /**
   6  * @group Broken
   7  * @group Upload
   8  */
   9 class UploadFromUrlTest extends ApiTestSetup {
  10
  11         public function setUp() {
  12                 global $wgEnableUploads, $wgAllowCopyUploads, $wgAllowAsyncCopyUploads;
  13                 parent::setUp();
  14
  15                 $wgEnableUploads = true;
  16                 $wgAllowCopyUploads = true;
  17                 $wgAllowAsyncCopyUploads = true;
  18                 wfSetupSession();
  19
  20                 ini_set( 'log_errors', 1 );
  21                 ini_set( 'error_reporting', 1 );
  22                 ini_set( 'display_errors', 1 );
  23
  24                 if ( wfLocalFile( 'UploadFromUrlTest.png' )->exists() ) {
  25                         $this->deleteFile( 'UploadFromUrlTest.png' );
  26                 }
  27         }
  28
  29         protected function doApiRequest( $params, $unused = null, $appendModule = false ) {
  30                 $sessionId = session_id();
  31                 session_write_close();
  32
  33                 $req = new FauxRequest( $params, true, $_SESSION );
  34                 $module = new ApiMain( $req, true );
  35                 $module->execute();
  36
  37                 wfSetupSession( $sessionId );
  38                 return array( $module->getResultData(), $req );
  39         }
  40
  41         /**
  42          * Ensure that the job queue is empty before continuing
  43          */
  44         public function testClearQueue() {
  45                 while ( $job = Job::pop() ) { }
  46                 $this->assertFalse( $job );
  47         }
  48
  49         /**
  50          * @todo Document why we test login, since the $wgUser hack used doesn't
  51          * require login
  52          */
  53         public function testLogin() {
  54                 $data = $this->doApiRequest( array(
  55                         'action' => 'login',
  56                         'lgname' => $this->user->userName,
  57                         'lgpassword' => $this->user->passWord ) );
  58                 $this->assertArrayHasKey( "login", $data[0] );
  59                 $this->assertArrayHasKey( "result", $data[0]['login'] );
  60                 $this->assertEquals( "NeedToken", $data[0]['login']['result'] );
  61                 $token = $data[0]['login']['token'];
  62
  63                 $data = $this->doApiRequest( array(
  64                         'action' => 'login',
  65                         "lgtoken" => $token,
  66                         'lgname' => $this->user->userName,
  67                         'lgpassword' => $this->user->passWord ) );
  68
  69                 $this->assertArrayHasKey( "login", $data[0] );
  70                 $this->assertArrayHasKey( "result", $data[0]['login'] );
  71                 $this->assertEquals( "Success", $data[0]['login']['result'] );
  72                 $this->assertArrayHasKey( 'lgtoken', $data[0]['login'] );
  73
  74                 return $data;
  75         }
  76
  77         /**
  78          * @depends testLogin
  79          * @depends testClearQueue
  80          */
  81         public function testSetupUrlDownload( $data ) {
  82                 $token = $this->user->editToken();
  83                 $exception = false;
  84
  85                 try {
  86                         $this->doApiRequest( array(
  87                                 'action' => 'upload',
  88                         ) );
  89                 } catch ( UsageException $e ) {
  90                         $exception = true;
  91                         $this->assertEquals( "The token parameter must be set", $e->getMessage() );
  92                 }
  93                 $this->assertTrue( $exception, "Got exception" );
  94
  95                 $exception = false;
  96                 try {
  97                         $this->doApiRequest( array(
  98                                 'action' => 'upload',
  99                                 'token' => $token,
 100                         ), $data );
 101                 } catch ( UsageException $e ) {
 102                         $exception = true;
 103                         $this->assertEquals( "One of the parameters sessionkey, file, url, statuskey is required",
 104                                 $e->getMessage() );
 105                 }
 106                 $this->assertTrue( $exception, "Got exception" );
 107
 108                 $exception = false;
 109                 try {
 110                         $this->doApiRequest( array(
 111                                 'action' => 'upload',
 112                                 'url' => 'http://www.example.com/test.png',
 113                                 'token' => $token,
 114                         ), $data );
 115                 } catch ( UsageException $e ) {
 116                         $exception = true;
 117                         $this->assertEquals( "The filename parameter must be set", $e->getMessage() );
 118                 }
 119                 $this->assertTrue( $exception, "Got exception" );
 120
 121                 $this->user->removeGroup( 'sysop' );
 122                 $exception = false;
 123                 try {
 124                         $this->doApiRequest( array(
 125                                 'action' => 'upload',
 126                                 'url' => 'http://www.example.com/test.png',
 127                                 'filename' => 'UploadFromUrlTest.png',
 128                                 'token' => $token,
 129                         ), $data );
 130                 } catch ( UsageException $e ) {
 131                         $exception = true;
 132                         $this->assertEquals( "Permission denied", $e->getMessage() );
 133                 }
 134                 $this->assertTrue( $exception, "Got exception" );
 135
 136                 $this->user->addGroup( 'sysop' );
 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 = $this->user->editToken();
 157
 158                 $this->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 = $this->user->editToken();
 176
 177                 $this->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 = $this->user->editToken();
 207
 208                 $job = Job::pop();
 209                 $this->assertFalse( $job, 'Starting with an empty jobqueue' );
 210
 211                 $this->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 = $this->user->user->editToken();
 231
 232                 $talk = $this->user->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  }