tests/phpunit/includes/api/ApiUploadTest.php

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