MWExceptionTest.php

Go to the documentation of this file.

<?php
class MWExceptionTest extends MediaWikiTestCase {
 
    public function testMwexceptionThrowing() {
        throw new MWException();
    }
 
    public function testUseOutputPage( $expected, $langObj, $wgFullyInitialised, $wgOut ) {
        $this->setMwGlobals( [
            'wgLang' => $langObj,
            'wgFullyInitialised' => $wgFullyInitialised,
            'wgOut' => $wgOut,
        ] );
 
        $e = new MWException();
        $this->assertEquals( $expected, $e->useOutputPage() );
    }
 
    public function provideTextUseOutputPage() {
        return [
            // expected, langObj, wgFullyInitialised, wgOut
            [ false, null, null, null ],
            [ false, $this->getMockLanguage(), null, null ],
            [ false, $this->getMockLanguage(), true, null ],
            [ false, null, true, null ],
            [ false, null, null, true ],
            [ true, $this->getMockLanguage(), true, true ],
        ];
    }
 
    private function getMockLanguage() {
        return $this->getMockBuilder( Language::class )
            ->disableOriginalConstructor()
            ->getMock();
    }
 
    public function testUseMessageCache( $expected, $langObj ) {
        $this->setMwGlobals( [
            'wgLang' => $langObj,
        ] );
        $e = new MWException();
        $this->assertEquals( $expected, $e->useMessageCache() );
    }
 
    public function provideUseMessageCache() {
        return [
            [ false, null ],
            [ true, $this->getMockLanguage() ],
        ];
    }
 
    public function testIsLogable() {
        $e = new MWException();
        $this->assertTrue( $e->isLoggable() );
    }
 
    public function testisCommandLine( $expected, $wgCommandLineMode ) {
        $this->setMwGlobals( [
            'wgCommandLineMode' => $wgCommandLineMode,
        ] );
        $e = new MWException();
        $this->assertEquals( $expected, $e->isCommandLine() );
    }
 
    public static function provideIsCommandLine() {
        return [
            [ false, null ],
            [ true, true ],
        ];
    }
 
    public function testJsonSerializeExceptions( $exception_class ) {
        $json = MWExceptionHandler::jsonSerializeException(
            new $exception_class()
        );
        $this->assertNotEquals( false, $json,
            "The $exception_class exception should be JSON serializable, got false." );
    }
 
    public static function provideExceptionClasses() {
        return [
            [ Exception::class ],
            [ MWException::class ],
        ];
    }
 
    public function testJsonserializeexceptionKeys( $expectedKeyType, $exClass, $key ) {
        # Make sure we log a backtrace:
        $this->setMwGlobals( [ 'wgLogExceptionBacktrace' => true ] );
 
        $json = json_decode(
            MWExceptionHandler::jsonSerializeException( new $exClass() )
        );
        $this->assertObjectHasAttribute( $key, $json,
            "JSON serialized exception is missing key '$key'"
        );
        $this->assertInternalType( $expectedKeyType, $json->$key,
            "JSON serialized key '$key' has type " . gettype( $json->$key )
            . " (expected: $expectedKeyType)."
        );
    }
 
    public static function provideJsonSerializedKeys() {
        $testCases = [];
        foreach ( [ Exception::class, MWException::class ] as $exClass ) {
            $exTests = [
                [ 'string', $exClass, 'id' ],
                [ 'string', $exClass, 'file' ],
                [ 'integer', $exClass, 'line' ],
                [ 'string', $exClass, 'message' ],
                [ 'null', $exClass, 'url' ],
                # Backtrace only enabled with wgLogExceptionBacktrace = true
                [ 'array', $exClass, 'backtrace' ],
            ];
            $testCases = array_merge( $testCases, $exTests );
        }
        return $testCases;
    }
 
    public function testJsonserializeexceptionBacktracingEnabled() {
        $this->setMwGlobals( [ 'wgLogExceptionBacktrace' => true ] );
        $json = json_decode(
            MWExceptionHandler::jsonSerializeException( new Exception() )
        );
        $this->assertObjectHasAttribute( 'backtrace', $json );
    }
 
    public function testJsonserializeexceptionBacktracingDisabled() {
        $this->setMwGlobals( [ 'wgLogExceptionBacktrace' => false ] );
        $json = json_decode(
            MWExceptionHandler::jsonSerializeException( new Exception() )
        );
        $this->assertObjectNotHasAttribute( 'backtrace', $json );
    }
 
}