SiteTest.php

Go to the documentation of this file.

<?php
 
class SiteTest extends MediaWikiTestCase {
 
    public function instanceProvider() {
        return $this->arrayWrap( TestSites::getSites() );
    }
 
    public function testGetInterwikiIds( Site $site ) {
        $this->assertInternalType( 'array', $site->getInterwikiIds() );
    }
 
    public function testGetNavigationIds( Site $site ) {
        $this->assertInternalType( 'array', $site->getNavigationIds() );
    }
 
    public function testAddNavigationId( Site $site ) {
        $site->addNavigationId( 'foobar' );
        $this->assertTrue( in_array( 'foobar', $site->getNavigationIds(), true ) );
    }
 
    public function testAddInterwikiId( Site $site ) {
        $site->addInterwikiId( 'foobar' );
        $this->assertTrue( in_array( 'foobar', $site->getInterwikiIds(), true ) );
    }
 
    public function testGetLanguageCode( Site $site ) {
        $this->assertTypeOrValue( 'string', $site->getLanguageCode(), null );
    }
 
    public function testSetLanguageCode( Site $site ) {
        $site->setLanguageCode( 'en' );
        $this->assertEquals( 'en', $site->getLanguageCode() );
    }
 
    public function testNormalizePageName( Site $site ) {
        $this->assertInternalType( 'string', $site->normalizePageName( 'Foobar' ) );
    }
 
    public function testGetGlobalId( Site $site ) {
        $this->assertTypeOrValue( 'string', $site->getGlobalId(), null );
    }
 
    public function testSetGlobalId( Site $site ) {
        $site->setGlobalId( 'foobar' );
        $this->assertEquals( 'foobar', $site->getGlobalId() );
    }
 
    public function testGetType( Site $site ) {
        $this->assertInternalType( 'string', $site->getType() );
    }
 
    public function testGetPath( Site $site ) {
        $this->assertTypeOrValue( 'string', $site->getPath( 'page_path' ), null );
        $this->assertTypeOrValue( 'string', $site->getPath( 'file_path' ), null );
        $this->assertTypeOrValue( 'string', $site->getPath( 'foobar' ), null );
    }
 
    public function testGetAllPaths( Site $site ) {
        $this->assertInternalType( 'array', $site->getAllPaths() );
    }
 
    public function testSetAndRemovePath( Site $site ) {
        $count = count( $site->getAllPaths() );
 
        $site->setPath( 'spam', 'http://www.wikidata.org/$1' );
        $site->setPath( 'spam', 'http://www.wikidata.org/foo/$1' );
        $site->setPath( 'foobar', 'http://www.wikidata.org/bar/$1' );
 
        $this->assertEquals( $count + 2, count( $site->getAllPaths() ) );
 
        $this->assertInternalType( 'string', $site->getPath( 'foobar' ) );
        $this->assertEquals( 'http://www.wikidata.org/foo/$1', $site->getPath( 'spam' ) );
 
        $site->removePath( 'spam' );
        $site->removePath( 'foobar' );
 
        $this->assertEquals( $count, count( $site->getAllPaths() ) );
 
        $this->assertNull( $site->getPath( 'foobar' ) );
        $this->assertNull( $site->getPath( 'spam' ) );
    }
 
    public function testSetLinkPath() {
        $site = new Site();
        $path = "TestPath/$1";
 
        $site->setLinkPath( $path );
        $this->assertEquals( $path, $site->getLinkPath() );
    }
 
    public function testGetLinkPathType() {
        $site = new Site();
 
        $path = 'TestPath/$1';
        $site->setLinkPath( $path );
        $this->assertEquals( $path, $site->getPath( $site->getLinkPathType() ) );
 
        $path = 'AnotherPath/$1';
        $site->setPath( $site->getLinkPathType(), $path );
        $this->assertEquals( $path, $site->getLinkPath() );
    }
 
    public function testSetPath() {
        $site = new Site();
 
        $path = 'TestPath/$1';
        $site->setPath( 'foo', $path );
 
        $this->assertEquals( $path, $site->getPath( 'foo' ) );
    }
 
    public function testProtocolRelativePath() {
        $site = new Site();
 
        $type = $site->getLinkPathType();
        $path = '//acme.com/'; // protocol-relative URL
        $site->setPath( $type, $path );
 
        $this->assertEquals( '', $site->getProtocol() );
    }
 
    public static function provideGetPageUrl() {
        // NOTE: the assumption that the URL is built by replacing $1
        //      with the urlencoded version of $page
        //      is true for Site but not guaranteed for subclasses.
        //      Subclasses need to override this provider appropriately.
 
        return [
            [ # 0
                'http://acme.test/TestPath/$1',
                'Foo',
                '/TestPath/Foo',
            ],
            [ # 1
                'http://acme.test/TestScript?x=$1&y=bla',
                'Foo',
                'TestScript?x=Foo&y=bla',
            ],
            [ # 2
                'http://acme.test/TestPath/$1',
                'foo & bar/xyzzy (quux-shmoox?)',
                '/TestPath/foo%20%26%20bar%2Fxyzzy%20%28quux-shmoox%3F%29',
            ],
        ];
    }
 
    public function testGetPageUrl( $path, $page, $expected ) {
        $site = new Site();
 
        // NOTE: the assumption that getPageUrl is based on getLinkPath
        //      is true for Site but not guaranteed for subclasses.
        //      Subclasses need to override this test case appropriately.
        $site->setLinkPath( $path );
        $this->assertContains( $path, $site->getPageUrl() );
 
        $this->assertContains( $expected, $site->getPageUrl( $page ) );
    }
 
    protected function assertTypeOrFalse( $type, $value ) {
        if ( $value === false ) {
            $this->assertTrue( true );
        } else {
            $this->assertInternalType( $type, $value );
        }
    }
 
    public function testSerialization( Site $site ) {
        $this->assertInstanceOf( Serializable::class, $site );
 
        $serialization = serialize( $site );
        $newInstance = unserialize( $serialization );
 
        $this->assertInstanceOf( Site::class, $newInstance );
 
        $this->assertEquals( $serialization, serialize( $newInstance ) );
    }
}