UploadFromUrlTest.php

Go to the documentation of this file.

<?php

class UploadFromUrlTest extends ApiTestCase {
    protected function setUp() {
        parent::setUp();

        $this->setMwGlobals( array(
            'wgEnableUploads' => true,
            'wgAllowCopyUploads' => true,
            'wgAllowAsyncCopyUploads' => true,
        ) );
        wfSetupSession();

        if ( wfLocalFile( 'UploadFromUrlTest.png' )->exists() ) {
            $this->deleteFile( 'UploadFromUrlTest.png' );
        }
    }

    protected function doApiRequest( array $params, array $unused = null,
        $appendModule = false, User $user = null
    ) {
        $sessionId = session_id();
        session_write_close();

        $req = new FauxRequest( $params, true, $_SESSION );
        $module = new ApiMain( $req, true );
        $module->execute();

        wfSetupSession( $sessionId );

        return array( $module->getResultData(), $req );
    }

    public function testClearQueue() {
        $job = JobQueueGroup::singleton()->pop();
        while ( $job ) {
            $job = JobQueueGroup::singleton()->pop();
        }
        $this->assertFalse( $job );
    }

    public function testSetupUrlDownload( $data ) {
        $token = $this->user->getEditToken();
        $exception = false;

        try {
            $this->doApiRequest( array(
                'action' => 'upload',
            ) );
        } catch ( UsageException $e ) {
            $exception = true;
            $this->assertEquals( "The token parameter must be set", $e->getMessage() );
        }
        $this->assertTrue( $exception, "Got exception" );

        $exception = false;
        try {
            $this->doApiRequest( array(
                'action' => 'upload',
                'token' => $token,
            ), $data );
        } catch ( UsageException $e ) {
            $exception = true;
            $this->assertEquals( "One of the parameters sessionkey, file, url, statuskey is required",
                $e->getMessage() );
        }
        $this->assertTrue( $exception, "Got exception" );

        $exception = false;
        try {
            $this->doApiRequest( array(
                'action' => 'upload',
                'url' => 'http://www.example.com/test.png',
                'token' => $token,
            ), $data );
        } catch ( UsageException $e ) {
            $exception = true;
            $this->assertEquals( "The filename parameter must be set", $e->getMessage() );
        }
        $this->assertTrue( $exception, "Got exception" );

        $this->user->removeGroup( 'sysop' );
        $exception = false;
        try {
            $this->doApiRequest( array(
                'action' => 'upload',
                'url' => 'http://www.example.com/test.png',
                'filename' => 'UploadFromUrlTest.png',
                'token' => $token,
            ), $data );
        } catch ( UsageException $e ) {
            $exception = true;
            $this->assertEquals( "Permission denied", $e->getMessage() );
        }
        $this->assertTrue( $exception, "Got exception" );

        $this->user->addGroup( 'sysop' );
        $data = $this->doApiRequest( array(
            'action' => 'upload',
            'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
            'asyncdownload' => 1,
            'filename' => 'UploadFromUrlTest.png',
            'token' => $token,
        ), $data );

        $this->assertEquals( $data[0]['upload']['result'], 'Queued', 'Queued upload' );

        $job = JobQueueGroup::singleton()->pop();
        $this->assertThat( $job, $this->isInstanceOf( 'UploadFromUrlJob' ), 'Queued upload inserted' );
    }

    public function testAsyncUpload( $data ) {
        $token = $this->user->getEditToken();

        $this->user->addGroup( 'users' );

        $data = $this->doAsyncUpload( $token, true );
        $this->assertEquals( $data[0]['upload']['result'], 'Success' );
        $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
        $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );

        $this->deleteFile( 'UploadFromUrlTest.png' );

        return $data;
    }

    public function testAsyncUploadWarning( $data ) {
        $token = $this->user->getEditToken();

        $this->user->addGroup( 'users' );

        $data = $this->doAsyncUpload( $token );

        $this->assertEquals( $data[0]['upload']['result'], 'Warning' );
        $this->assertTrue( isset( $data[0]['upload']['sessionkey'] ) );

        $data = $this->doApiRequest( array(
            'action' => 'upload',
            'sessionkey' => $data[0]['upload']['sessionkey'],
            'filename' => 'UploadFromUrlTest.png',
            'ignorewarnings' => 1,
            'token' => $token,
        ) );
        $this->assertEquals( $data[0]['upload']['result'], 'Success' );
        $this->assertEquals( $data[0]['upload']['filename'], 'UploadFromUrlTest.png' );
        $this->assertTrue( wfLocalFile( $data[0]['upload']['filename'] )->exists() );

        $this->deleteFile( 'UploadFromUrlTest.png' );

        return $data;
    }

    public function testSyncDownload( $data ) {
        $token = $this->user->getEditToken();

        $job = JobQueueGroup::singleton()->pop();
        $this->assertFalse( $job, 'Starting with an empty jobqueue' );

        $this->user->addGroup( 'users' );
        $data = $this->doApiRequest( array(
            'action' => 'upload',
            'filename' => 'UploadFromUrlTest.png',
            'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
            'ignorewarnings' => true,
            'token' => $token,
        ), $data );

        $job = JobQueueGroup::singleton()->pop();
        $this->assertFalse( $job );

        $this->assertEquals( 'Success', $data[0]['upload']['result'] );
        $this->deleteFile( 'UploadFromUrlTest.png' );

        return $data;
    }

    public function testLeaveMessage() {
        $token = $this->user->user->getEditToken();

        $talk = $this->user->user->getTalkPage();
        if ( $talk->exists() ) {
            $page = WikiPage::factory( $talk );
            $page->doDeleteArticle( '' );
        }

        $this->assertFalse(
            (bool)$talk->getArticleID( Title::GAID_FOR_UPDATE ),
            'User talk does not exist'
        );

        $this->doApiRequest( array(
            'action' => 'upload',
            'filename' => 'UploadFromUrlTest.png',
            'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
            'asyncdownload' => 1,
            'token' => $token,
            'leavemessage' => 1,
            'ignorewarnings' => 1,
        ) );

        $job = JobQueueGroup::singleton()->pop();
        $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );
        $job->run();

        $this->assertTrue( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );
        $this->assertTrue( (bool)$talk->getArticleID( Title::GAID_FOR_UPDATE ), 'User talk exists' );

        $this->deleteFile( 'UploadFromUrlTest.png' );

        $exception = false;
        try {
            $this->doApiRequest( array(
                'action' => 'upload',
                'filename' => 'UploadFromUrlTest.png',
                'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
                'asyncdownload' => 1,
                'token' => $token,
                'leavemessage' => 1,
            ) );
        } catch ( UsageException $e ) {
            $exception = true;
            $this->assertEquals(
                'Using leavemessage without ignorewarnings is not supported',
                $e->getMessage()
            );
        }
        $this->assertTrue( $exception );

        $job = JobQueueGroup::singleton()->pop();
        $this->assertFalse( $job );

        return;
        /*
        // Broken until using leavemessage with ignorewarnings is supported
        $talkRev = Revision::newFromTitle( $talk );
        $talkSize = $talkRev->getSize();

        $job->run();

        $this->assertFalse( wfLocalFile( 'UploadFromUrlTest.png' )->exists() );

        $talkRev = Revision::newFromTitle( $talk );
        $this->assertTrue( $talkRev->getSize() > $talkSize, 'New message left' );
        */
    }

    private function doAsyncUpload( $token, $ignoreWarnings = false, $leaveMessage = false ) {
        $params = array(
            'action' => 'upload',
            'filename' => 'UploadFromUrlTest.png',
            'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
            'asyncdownload' => 1,
            'token' => $token,
        );
        if ( $ignoreWarnings ) {
            $params['ignorewarnings'] = 1;
        }
        if ( $leaveMessage ) {
            $params['leavemessage'] = 1;
        }

        $data = $this->doApiRequest( $params );
        $this->assertEquals( $data[0]['upload']['result'], 'Queued' );
        $this->assertTrue( isset( $data[0]['upload']['statuskey'] ) );
        $statusKey = $data[0]['upload']['statuskey'];

        $job = JobQueueGroup::singleton()->pop();
        $this->assertEquals( 'UploadFromUrlJob', get_class( $job ) );

        $status = $job->run();
        $this->assertTrue( $status );

        $data = $this->doApiRequest( array(
            'action' => 'upload',
            'statuskey' => $statusKey,
            'token' => $token,
        ) );

        return $data;
    }

    protected function deleteFile( $name ) {
        $t = Title::newFromText( $name, NS_FILE );
        $this->assertTrue( $t->exists(), "File '$name' exists" );

        if ( $t->exists() ) {
            $file = wfFindFile( $name, array( 'ignoreRedirect' => true ) );
            $empty = "";
            FileDeleteForm::doDelete( $t, $file, $empty, "none", true );
            $page = WikiPage::factory( $t );
            $page->doDeleteArticle( "testing" );
        }
        $t = Title::newFromText( $name, NS_FILE );

        $this->assertFalse( $t->exists(), "File '$name' was deleted" );
    }
}