tests/phpunit/includes/api/ApiUploadTest.php

   1 <?php
   2
   3 /**
   4  * @group Database
   5  * @group Destructive
   6  */
   7
   8 /**
   9  * n.b. Ensure that you can write to the images/ directory as the
  10  * user that will run tests.
  11  */
  12
  13 // Note for reviewers: this intentionally duplicates functionality already in "ApiSetup" and so on.
  14 // This framework works better IMO and has less strangeness (such as test cases inheriting from "ApiSetup"...)
  15 // (and in the case of the other Upload tests, this flat out just actually works... )
  16
  17 // TODO: port the other Upload tests, and other API tests to this framework
  18
  19 require_once( 'ApiTestCaseUpload.php' );
  20
  21 /**
  22  * @group Database
  23  * @group Destructive
  24  *
  25  * This is pretty sucky... needs to be prettified.
  26  */
  27 class ApiUploadTest extends ApiTestCaseUpload {
  28
  29         /**
  30          * Testing login
  31          * XXX this is a funny way of getting session context
  32          */
  33         function testLogin() {
  34                 $user = self::$users['uploader'];
  35
  36                 $params = array(
  37                         'action' => 'login',
  38                         'lgname' => $user->username,
  39                         'lgpassword' => $user->password
  40                 );
  41                 list( $result, , $session ) = $this->doApiRequest( $params );
  42                 $this->assertArrayHasKey( "login", $result );
  43                 $this->assertArrayHasKey( "result", $result['login'] );
  44                 $this->assertEquals( "NeedToken", $result['login']['result'] );
  45                 $token = $result['login']['token'];
  46
  47                 $params = array(
  48                         'action' => 'login',
  49                         'lgtoken' => $token,
  50                         'lgname' => $user->username,
  51                         'lgpassword' => $user->password
  52                 );
  53                 list( $result, , $session ) = $this->doApiRequest( $params, $session );
  54                 $this->assertArrayHasKey( "login", $result );
  55                 $this->assertArrayHasKey( "result", $result['login'] );
  56                 $this->assertEquals( "Success", $result['login']['result'] );
  57                 $this->assertArrayHasKey( 'lgtoken', $result['login'] );
  58
  59                 return $session;
  60
  61         }
  62
  63         /**
  64          * @depends testLogin
  65          */
  66         public function testUploadRequiresToken( $session ) {
  67                 $exception = false;
  68                 try {
  69                         $this->doApiRequest( array(
  70                                 'action' => 'upload'
  71                         ) );
  72                 } catch ( UsageException $e ) {
  73                         $exception = true;
  74                         $this->assertEquals( "The token parameter must be set", $e->getMessage() );
  75                 }
  76                 $this->assertTrue( $exception, "Got exception" );
  77         }
  78
  79         /**
  80          * @depends testLogin
  81          */
  82         public function testUploadMissingParams( $session ) {
  83                 global $wgUser;
  84                 $wgUser = self::$users['uploader']->user;
  85
  86                 $exception = false;
  87                 try {
  88                         $this->doApiRequestWithToken( array(
  89                                 'action' => 'upload',
  90                         ), $session );
  91                 } catch ( UsageException $e ) {
  92                         $exception = true;
  93                         $this->assertEquals( "One of the parameters sessionkey, file, url, statuskey is required",
  94                                 $e->getMessage() );
  95                 }
  96                 $this->assertTrue( $exception, "Got exception" );
  97         }
  98
  99
 100         /**
 101          * @depends testLogin
 102          */
 103         public function testUpload( $session ) {
 104                 global $wgUser;
 105                 $wgUser = self::$users['uploader']->user;
 106
 107                 $extension = 'png';
 108                 $mimeType = 'image/png';
 109
 110                 try {
 111                         $randomImageGenerator = new RandomImageGenerator();
 112                 }
 113                 catch ( Exception $e ) {
 114                         $this->markTestIncomplete( $e->getMessage() );
 115                 }
 116
 117                 $filePaths = $randomImageGenerator->writeImages( 1, $extension, wfTempDir() );
 118                 $filePath = $filePaths[0];
 119                 $fileSize = filesize( $filePath );
 120                 $fileName = basename( $filePath );
 121
 122                 $this->deleteFileByFileName( $fileName );
 123                 $this->deleteFileByContent( $filePath );
 124
 125
 126                 if (! $this->fakeUploadFile( 'file', $fileName, $mimeType, $filePath ) ) {
 127                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 128                 }
 129
 130                 $params = array(
 131                         'action' => 'upload',
 132                         'filename' => $fileName,
 133                         'file' => 'dummy content',
 134                         'comment' => 'dummy comment',
 135                         'text'  => "This is the page text for $fileName",
 136                 );
 137
 138                 $exception = false;
 139                 try {
 140                         list( $result, , ) = $this->doApiRequestWithToken( $params, $session );
 141                 } catch ( UsageException $e ) {
 142                         $exception = true;
 143                 }
 144                 $this->assertTrue( isset( $result['upload'] ) );
 145                 $this->assertEquals( 'Success', $result['upload']['result'] );
 146                 $this->assertEquals( $fileSize, ( int )$result['upload']['imageinfo']['size'] );
 147                 $this->assertEquals( $mimeType, $result['upload']['imageinfo']['mime'] );
 148                 $this->assertFalse( $exception );
 149
 150                 // clean up
 151                 $this->deleteFileByFilename( $fileName );
 152                 unlink( $filePath );
 153         }
 154
 155
 156         /**
 157          * @depends testLogin
 158          */
 159         public function testUploadZeroLength( $session ) {
 160                 global $wgUser;
 161                 $wgUser = self::$users['uploader']->user;
 162
 163                 $mimeType = 'image/png';
 164
 165                 $filePath = tempnam( wfTempDir(), "" );
 166                 $fileName = "apiTestUploadZeroLength.png";
 167
 168                 $this->deleteFileByFileName( $fileName );
 169
 170                 if (! $this->fakeUploadFile( 'file', $fileName, $mimeType, $filePath ) ) {
 171                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 172                 }
 173
 174                 $params = array(
 175                         'action' => 'upload',
 176                         'filename' => $fileName,
 177                         'file' => 'dummy content',
 178                         'comment' => 'dummy comment',
 179                         'text'  => "This is the page text for $fileName",
 180                 );
 181
 182                 $exception = false;
 183                 try {
 184                         $this->doApiRequestWithToken( $params, $session );
 185                 } catch ( UsageException $e ) {
 186                         $this->assertContains( 'The file you submitted was empty', $e->getMessage() );
 187                         $exception = true;
 188                 }
 189                 $this->assertTrue( $exception );
 190
 191                 // clean up
 192                 $this->deleteFileByFilename( $fileName );
 193                 unlink( $filePath );
 194         }
 195
 196
 197         /**
 198          * @depends testLogin
 199          */
 200         public function testUploadSameFileName( $session ) {
 201                 global $wgUser;
 202                 $wgUser = self::$users['uploader']->user;
 203
 204                 $extension = 'png';
 205                 $mimeType = 'image/png';
 206
 207                 try {
 208                         $randomImageGenerator = new RandomImageGenerator();
 209                 }
 210                 catch ( Exception $e ) {
 211                         $this->markTestIncomplete( $e->getMessage() );
 212                 }
 213
 214                 $filePaths = $randomImageGenerator->writeImages( 2, $extension, wfTempDir() );
 215                 // we'll reuse this filename
 216                 $fileName = basename( $filePaths[0] );
 217
 218                 // clear any other files with the same name
 219                 $this->deleteFileByFileName( $fileName );
 220
 221                 // we reuse these params
 222                 $params = array(
 223                         'action' => 'upload',
 224                         'filename' => $fileName,
 225                         'file' => 'dummy content',
 226                         'comment' => 'dummy comment',
 227                         'text'  => "This is the page text for $fileName",
 228                 );
 229
 230                 // first upload .... should succeed
 231
 232                 if (! $this->fakeUploadFile( 'file', $fileName, $mimeType, $filePaths[0] ) ) {
 233                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 234                 }
 235
 236                 $exception = false;
 237                 try {
 238                         list( $result, , $session ) = $this->doApiRequestWithToken( $params, $session );
 239                 } catch ( UsageException $e ) {
 240                         $exception = true;
 241                 }
 242                 $this->assertTrue( isset( $result['upload'] ) );
 243                 $this->assertEquals( 'Success', $result['upload']['result'] );
 244                 $this->assertFalse( $exception );
 245
 246                 // second upload with the same name (but different content)
 247
 248                 if (! $this->fakeUploadFile( 'file', $fileName, $mimeType, $filePaths[1] ) ) {
 249                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 250                 }
 251
 252                 $exception = false;
 253                 try {
 254                         list( $result, , ) = $this->doApiRequestWithToken( $params, $session );
 255                 } catch ( UsageException $e ) {
 256                         $exception = true;
 257                 }
 258                 $this->assertTrue( isset( $result['upload'] ) );
 259                 $this->assertEquals( 'Warning', $result['upload']['result'] );
 260                 $this->assertTrue( isset( $result['upload']['warnings'] ) );
 261                 $this->assertTrue( isset( $result['upload']['warnings']['exists'] ) );
 262                 $this->assertFalse( $exception );
 263
 264                 // clean up
 265                 $this->deleteFileByFilename( $fileName );
 266                 unlink( $filePaths[0] );
 267                 unlink( $filePaths[1] );
 268         }
 269
 270
 271         /**
 272          * @depends testLogin
 273          */
 274         public function testUploadSameContent( $session ) {
 275                 global $wgUser;
 276                 $wgUser = self::$users['uploader']->user;
 277
 278                 $extension = 'png';
 279                 $mimeType = 'image/png';
 280
 281                 try {
 282                         $randomImageGenerator = new RandomImageGenerator();
 283                 }
 284                 catch ( Exception $e ) {
 285                         $this->markTestIncomplete( $e->getMessage() );
 286                 }
 287                 $filePaths = $randomImageGenerator->writeImages( 1, $extension, wfTempDir() );
 288                 $fileNames[0] = basename( $filePaths[0] );
 289                 $fileNames[1] = "SameContentAs" . $fileNames[0];
 290
 291                 // clear any other files with the same name or content
 292                 $this->deleteFileByContent( $filePaths[0] );
 293                 $this->deleteFileByFileName( $fileNames[0] );
 294                 $this->deleteFileByFileName( $fileNames[1] );
 295
 296                 // first upload .... should succeed
 297
 298                 $params = array(
 299                         'action' => 'upload',
 300                         'filename' => $fileNames[0],
 301                         'file' => 'dummy content',
 302                         'comment' => 'dummy comment',
 303                         'text'  => "This is the page text for " . $fileNames[0],
 304                 );
 305
 306                 if (! $this->fakeUploadFile( 'file', $fileNames[0], $mimeType, $filePaths[0] ) ) {
 307                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 308                 }
 309
 310                 $exception = false;
 311                 try {
 312                         list( $result, $request, $session ) = $this->doApiRequestWithToken( $params, $session );
 313                 } catch ( UsageException $e ) {
 314                         $exception = true;
 315                 }
 316                 $this->assertTrue( isset( $result['upload'] ) );
 317                 $this->assertEquals( 'Success', $result['upload']['result'] );
 318                 $this->assertFalse( $exception );
 319
 320
 321                 // second upload with the same content (but different name)
 322
 323                 if (! $this->fakeUploadFile( 'file', $fileNames[1], $mimeType, $filePaths[0] ) ) {
 324                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 325                 }
 326
 327                 $params = array(
 328                         'action' => 'upload',
 329                         'filename' => $fileNames[1],
 330                         'file' => 'dummy content',
 331                         'comment' => 'dummy comment',
 332                         'text'  => "This is the page text for " . $fileNames[1],
 333                 );
 334
 335                 $exception = false;
 336                 try {
 337                         list( $result, $request, $session ) = $this->doApiRequestWithToken( $params, $session );
 338                 } catch ( UsageException $e ) {
 339                         $exception = true;
 340                 }
 341                 $this->assertTrue( isset( $result['upload'] ) );
 342                 $this->assertEquals( 'Warning', $result['upload']['result'] );
 343                 $this->assertTrue( isset( $result['upload']['warnings'] ) );
 344                 $this->assertTrue( isset( $result['upload']['warnings']['duplicate'] ) );
 345                 $this->assertFalse( $exception );
 346
 347                 // clean up
 348                 $this->deleteFileByFilename( $fileNames[0] );
 349                 $this->deleteFileByFilename( $fileNames[1] );
 350                 unlink( $filePaths[0] );
 351         }
 352
 353
 354         /**
 355          * @depends testLogin
 356          */
 357         public function testUploadStash( $session ) {
 358                 global $wgUser;
 359                 $wgUser = self::$users['uploader']->user;
 360
 361                 $extension = 'png';
 362                 $mimeType = 'image/png';
 363
 364                 try {
 365                         $randomImageGenerator = new RandomImageGenerator();
 366                 }
 367                 catch ( Exception $e ) {
 368                         $this->markTestIncomplete( $e->getMessage() );
 369                 }
 370
 371                 $filePaths = $randomImageGenerator->writeImages( 1, $extension, wfTempDir() );
 372                 $filePath = $filePaths[0];
 373                 $fileSize = filesize( $filePath );
 374                 $fileName = basename( $filePath );
 375
 376                 $this->deleteFileByFileName( $fileName );
 377                 $this->deleteFileByContent( $filePath );
 378
 379                 if (! $this->fakeUploadFile( 'file', $fileName, $mimeType, $filePath ) ) {
 380                         $this->markTestIncomplete( "Couldn't upload file!\n" );
 381                 }
 382
 383                 $params = array(
 384                         'action' => 'upload',
 385                         'stash' => 1,
 386                         'filename' => $fileName,
 387                         'file' => 'dummy content',
 388                         'comment' => 'dummy comment',
 389                         'text'  => "This is the page text for $fileName",
 390                 );
 391
 392                 $exception = false;
 393                 try {
 394                         list( $result, $request, $session ) = $this->doApiRequestWithToken( $params, $session );
 395                 } catch ( UsageException $e ) {
 396                         $exception = true;
 397                 }
 398                 $this->assertFalse( $exception );
 399                 $this->assertTrue( isset( $result['upload'] ) );
 400                 $this->assertEquals( 'Success', $result['upload']['result'] );
 401                 $this->assertEquals( $fileSize, ( int )$result['upload']['imageinfo']['size'] );
 402                 $this->assertEquals( $mimeType, $result['upload']['imageinfo']['mime'] );
 403                 $this->assertTrue( isset( $result['upload']['sessionkey'] ) );
 404                 $sessionkey = $result['upload']['sessionkey'];
 405
 406                 // it should be visible from Special:UploadStash
 407                 // XXX ...but how to test this, with a fake WebRequest with the session?
 408
 409                 // now we should try to release the file from stash
 410                 $params = array(
 411                         'action' => 'upload',
 412                         'sessionkey' => $sessionkey,
 413                         'filename' => $fileName,
 414                         'comment' => 'dummy comment',
 415                         'text'  => "This is the page text for $fileName, altered",
 416                 );
 417                 $session[ UploadBase::getSessionKeyname() ] = $_SESSION[ UploadBase::getSessionKeyname() ];
 418
 419                 $this->clearFakeUploads();
 420                 $exception = false;
 421                 try {
 422                         list( $result, $request, $session ) = $this->doApiRequestWithToken( $params, $session );
 423                 } catch ( UsageException $e ) {
 424                         $exception = true;
 425                 }
 426                 $this->assertTrue( isset( $result['upload'] ) );
 427                 $this->assertEquals( 'Success', $result['upload']['result'] );
 428                 $this->assertFalse( $exception );
 429
 430                 // clean up
 431                 $this->deleteFileByFilename( $fileName );
 432                 unlink( $filePath );
 433         }
 434 }
 435