StatusTest.php

Go to the documentation of this file.

<?php
 
class StatusTest extends MediaWikiLangTestCase {
 
    public function testNewGood( $value = null ) {
        $status = Status::newGood( $value );
        $this->assertTrue( $status->isGood() );
        $this->assertTrue( $status->isOK() );
        $this->assertEquals( $value, $status->getValue() );
    }
 
    public static function provideValues() {
        return [
            [],
            [ 'foo' ],
            [ [ 'foo' => 'bar' ] ],
            [ new Exception() ],
            [ 1234 ],
        ];
    }
 
    public function testNewFatalWithMessage() {
        $message = $this->getMockBuilder( Message::class )
            ->disableOriginalConstructor()
            ->getMock();
 
        $status = Status::newFatal( $message );
        $this->assertFalse( $status->isGood() );
        $this->assertFalse( $status->isOK() );
        $this->assertEquals( $message, $status->getMessage() );
    }
 
    public function testNewFatalWithString() {
        $message = 'foo';
        $status = Status::newFatal( $message );
        $this->assertFalse( $status->isGood() );
        $this->assertFalse( $status->isOK() );
        $this->assertEquals( $message, $status->getMessage()->getKey() );
    }
 
    public function testOkAndErrorsGetters() {
        $status = Status::newGood( 'foo' );
        $this->assertTrue( $status->ok );
        $status = Status::newFatal( 'foo', 1, 2 );
        $this->assertFalse( $status->ok );
        $this->assertArrayEquals(
            [
                [
                    'type' => 'error',
                    'message' => 'foo',
                    'params' => [ 1, 2 ]
                ]
            ],
            $status->errors
        );
    }
 
    public function testOkSetter() {
        $status = new Status();
        $status->ok = false;
        $this->assertFalse( $status->isOK() );
        $status->ok = true;
        $this->assertTrue( $status->isOK() );
    }
 
    public function testSetResult( $ok, $value = null ) {
        $status = new Status();
        $status->setResult( $ok, $value );
        $this->assertEquals( $ok, $status->isOK() );
        $this->assertEquals( $value, $status->getValue() );
    }
 
    public static function provideSetResult() {
        return [
            [ true ],
            [ false ],
            [ true, 'value' ],
            [ false, 'value' ],
        ];
    }
 
    public function testIsOk( $ok ) {
        $status = new Status();
        $status->setOK( $ok );
        $this->assertEquals( $ok, $status->isOK() );
    }
 
    public static function provideIsOk() {
        return [
            [ true ],
            [ false ],
        ];
    }
 
    public function testGetValue() {
        $status = new Status();
        $status->value = 'foobar';
        $this->assertEquals( 'foobar', $status->getValue() );
    }
 
    public function testIsGood( $ok, $errors, $expected ) {
        $status = new Status();
        $status->setOK( $ok );
        foreach ( $errors as $error ) {
            $status->warning( $error );
        }
        $this->assertEquals( $expected, $status->isGood() );
    }
 
    public static function provideIsGood() {
        return [
            [ true, [], true ],
            [ true, [ 'foo' ], false ],
            [ false, [], false ],
            [ false, [ 'foo' ], false ],
        ];
    }
 
    public function testWarningWithMessage( $mockDetails ) {
        $status = new Status();
        $messages = $this->getMockMessages( $mockDetails );
 
        foreach ( $messages as $message ) {
            $status->warning( $message );
        }
        $warnings = $status->getWarningsArray();
 
        $this->assertEquals( count( $messages ), count( $warnings ) );
        foreach ( $messages as $key => $message ) {
            $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
            $this->assertEquals( $warnings[$key], $expectedArray );
        }
    }
 
    public function testErrorWithMessage( $mockDetails ) {
        $status = new Status();
        $messages = $this->getMockMessages( $mockDetails );
 
        foreach ( $messages as $message ) {
            $status->error( $message );
        }
        $errors = $status->getErrorsArray();
 
        $this->assertEquals( count( $messages ), count( $errors ) );
        foreach ( $messages as $key => $message ) {
            $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
            $this->assertEquals( $errors[$key], $expectedArray );
        }
    }
 
    public function testFatalWithMessage( $mockDetails ) {
        $status = new Status();
        $messages = $this->getMockMessages( $mockDetails );
 
        foreach ( $messages as $message ) {
            $status->fatal( $message );
        }
        $errors = $status->getErrorsArray();
 
        $this->assertEquals( count( $messages ), count( $errors ) );
        foreach ( $messages as $key => $message ) {
            $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
            $this->assertEquals( $errors[$key], $expectedArray );
        }
        $this->assertFalse( $status->isOK() );
    }
 
    protected function getMockMessage( $key = 'key', $params = [] ) {
        $message = $this->getMockBuilder( Message::class )
            ->disableOriginalConstructor()
            ->getMock();
        $message->expects( $this->atLeastOnce() )
            ->method( 'getKey' )
            ->will( $this->returnValue( $key ) );
        $message->expects( $this->atLeastOnce() )
            ->method( 'getParams' )
            ->will( $this->returnValue( $params ) );
        return $message;
    }
 
    protected function getMockMessages( $messageDetails ) {
        $messages = [];
        foreach ( $messageDetails as $key => $paramsArray ) {
            $messages[] = $this->getMockMessage( $key, $paramsArray );
        }
        return $messages;
    }
 
    public static function provideMockMessageDetails() {
        return [
            [ [ 'key1' => [ 'foo' => 'bar' ] ] ],
            [ [ 'key1' => [ 'foo' => 'bar' ], 'key2' => [ 'foo2' => 'bar2' ] ] ],
        ];
    }
 
    public function testMerge() {
        $status1 = new Status();
        $status2 = new Status();
        $message1 = $this->getMockMessage( 'warn1' );
        $message2 = $this->getMockMessage( 'error2' );
        $status1->warning( $message1 );
        $status2->error( $message2 );
 
        $status1->merge( $status2 );
        $this->assertEquals(
            2,
            count( $status1->getWarningsArray() ) + count( $status1->getErrorsArray() )
        );
    }
 
    public function testMergeWithOverwriteValue() {
        $status1 = new Status();
        $status2 = new Status();
        $message1 = $this->getMockMessage( 'warn1' );
        $message2 = $this->getMockMessage( 'error2' );
        $status1->warning( $message1 );
        $status2->error( $message2 );
        $status2->value = 'FooValue';
 
        $status1->merge( $status2, true );
        $this->assertEquals(
            2,
            count( $status1->getWarningsArray() ) + count( $status1->getErrorsArray() )
        );
        $this->assertEquals( 'FooValue', $status1->getValue() );
    }
 
    public function testHasMessage() {
        $status = new Status();
        $status->fatal( 'bad' );
        $status->fatal( wfMessage( 'bad-msg' ) );
        $this->assertTrue( $status->hasMessage( 'bad' ) );
        $this->assertTrue( $status->hasMessage( 'bad-msg' ) );
        $this->assertTrue( $status->hasMessage( wfMessage( 'bad-msg' ) ) );
        $this->assertFalse( $status->hasMessage( 'good' ) );
    }
 
    public function testCleanParams( $cleanCallback, $params, $expected ) {
        $method = new ReflectionMethod( Status::class, 'cleanParams' );
        $method->setAccessible( true );
        $status = new Status();
        $status->cleanCallback = $cleanCallback;
 
        $this->assertEquals( $expected, $method->invoke( $status, $params ) );
    }
 
    public static function provideCleanParams() {
        $cleanCallback = function ( $value ) {
            return '-' . $value . '-';
        };
 
        return [
            [ false, [ 'foo' => 'bar' ], [ 'foo' => 'bar' ] ],
            [ $cleanCallback, [ 'foo' => 'bar' ], [ 'foo' => '-bar-' ] ],
        ];
    }
 
    public function testGetWikiText(
        Status $status, $wikitext, $wrappedWikitext, $html, $wrappedHtml
    ) {
        $this->assertEquals( $wikitext, $status->getWikiText() );
 
        $this->assertEquals( $wrappedWikitext, $status->getWikiText( 'wrap-short', 'wrap-long', 'qqx' ) );
    }
 
    public function testGetHtml(
        Status $status, $wikitext, $wrappedWikitext, $html, $wrappedHtml
    ) {
        $this->assertEquals( $html, $status->getHTML() );
 
        $this->assertEquals( $wrappedHtml, $status->getHTML( 'wrap-short', 'wrap-long', 'qqx' ) );
    }
 
    public static function provideGetWikiTextAndHtml() {
        $testCases = [];
 
        $testCases['GoodStatus'] = [
            new Status(),
            "Internal error: Status::getWikiText called for a good result, this is incorrect\n",
            "(wrap-short: (internalerror_info: Status::getWikiText called for a good result, " .
                "this is incorrect\n))",
            "<p>Internal error: Status::getWikiText called for a good result, this is incorrect\n</p>",
            "<p>(wrap-short: (internalerror_info: Status::getWikiText called for a good result, " .
                "this is incorrect\n))\n</p>",
        ];
 
        $status = new Status();
        $status->setOK( false );
        $testCases['GoodButNoError'] = [
            $status,
            "Internal error: Status::getWikiText: Invalid result object: no error text but not OK\n",
            "(wrap-short: (internalerror_info: Status::getWikiText: Invalid result object: " .
                "no error text but not OK\n))",
            "<p>Internal error: Status::getWikiText: Invalid result object: no error text but not OK\n</p>",
            "<p>(wrap-short: (internalerror_info: Status::getWikiText: Invalid result object: " .
                "no error text but not OK\n))\n</p>",
        ];
 
        $status = new Status();
        $status->warning( 'fooBar!' );
        $testCases['1StringWarning'] = [
            $status,
            "⧼fooBar!⧽",
            "(wrap-short: (fooBar!))",
            "<p>⧼fooBar!⧽\n</p>",
            "<p>(wrap-short: (fooBar!))\n</p>",
        ];
 
        $status = new Status();
        $status->warning( 'fooBar!' );
        $status->warning( 'fooBar2!' );
        $testCases['2StringWarnings'] = [
            $status,
            "* ⧼fooBar!⧽\n* ⧼fooBar2!⧽\n",
            "(wrap-long: * (fooBar!)\n* (fooBar2!)\n)",
            "<ul><li>⧼fooBar!⧽</li>\n<li>⧼fooBar2!⧽</li></ul>\n",
            "<p>(wrap-long: * (fooBar!)\n</p>\n<ul><li>(fooBar2!)</li></ul>\n<p>)\n</p>",
        ];
 
        $status = new Status();
        $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
        $testCases['1MessageWarning'] = [
            $status,
            "⧼fooBar!⧽",
            "(wrap-short: (fooBar!: foo, bar))",
            "<p>⧼fooBar!⧽\n</p>",
            "<p>(wrap-short: (fooBar!: foo, bar))\n</p>",
        ];
 
        $status = new Status();
        $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
        $status->warning( new Message( 'fooBar2!' ) );
        $testCases['2MessageWarnings'] = [
            $status,
            "* ⧼fooBar!⧽\n* ⧼fooBar2!⧽\n",
            "(wrap-long: * (fooBar!: foo, bar)\n* (fooBar2!)\n)",
            "<ul><li>⧼fooBar!⧽</li>\n<li>⧼fooBar2!⧽</li></ul>\n",
            "<p>(wrap-long: * (fooBar!: foo, bar)\n</p>\n<ul><li>(fooBar2!)</li></ul>\n<p>)\n</p>",
        ];
 
        return $testCases;
    }
 
    private static function sanitizedMessageParams( Message $message ) {
        return array_map( function ( $p ) {
            return $p instanceof Message
                ? [
                    'key' => $p->getKey(),
                    'params' => self::sanitizedMessageParams( $p ),
                    'lang' => $p->getLanguage()->getCode(),
                ]
                : $p;
        }, $message->getParams() );
    }
 
    public function testGetMessage(
        Status $status, $expectedParams = [], $expectedKey, $expectedWrapper
    ) {
        $message = $status->getMessage( null, null, 'qqx' );
        $this->assertInstanceOf( Message::class, $message );
        $this->assertEquals( $expectedParams, self::sanitizedMessageParams( $message ),
            'Message::getParams' );
        $this->assertEquals( $expectedKey, $message->getKey(), 'Message::getKey' );
 
        $message = $status->getMessage( 'wrapper-short', 'wrapper-long' );
        $this->assertInstanceOf( Message::class, $message );
        $this->assertEquals( $expectedWrapper, $message->getKey(), 'Message::getKey with wrappers' );
        $this->assertCount( 1, $message->getParams(), 'Message::getParams with wrappers' );
 
        $message = $status->getMessage( 'wrapper' );
        $this->assertInstanceOf( Message::class, $message );
        $this->assertEquals( 'wrapper', $message->getKey(), 'Message::getKey with wrappers' );
        $this->assertCount( 1, $message->getParams(), 'Message::getParams with wrappers' );
 
        $message = $status->getMessage( false, 'wrapper' );
        $this->assertInstanceOf( Message::class, $message );
        $this->assertEquals( 'wrapper', $message->getKey(), 'Message::getKey with wrappers' );
        $this->assertCount( 1, $message->getParams(), 'Message::getParams with wrappers' );
    }
 
    public static function provideGetMessage() {
        $testCases = [];
 
        $testCases['GoodStatus'] = [
            new Status(),
            [ "Status::getMessage called for a good result, this is incorrect\n" ],
            'internalerror_info',
            'wrapper-short'
        ];
 
        $status = new Status();
        $status->setOK( false );
        $testCases['GoodButNoError'] = [
            $status,
            [ "Status::getMessage: Invalid result object: no error text but not OK\n" ],
            'internalerror_info',
            'wrapper-short'
        ];
 
        $status = new Status();
        $status->warning( 'fooBar!' );
        $testCases['1StringWarning'] = [
            $status,
            [],
            'fooBar!',
            'wrapper-short'
        ];
 
        $status = new Status();
        $status->warning( 'fooBar!' );
        $status->warning( 'fooBar2!' );
        $testCases[ '2StringWarnings' ] = [
            $status,
            [
                [ 'key' => 'fooBar!', 'params' => [], 'lang' => 'qqx' ],
                [ 'key' => 'fooBar2!', 'params' => [], 'lang' => 'qqx' ]
            ],
            "* \$1\n* \$2",
            'wrapper-long'
        ];
 
        $status = new Status();
        $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
        $testCases['1MessageWarning'] = [
            $status,
            [ 'foo', 'bar' ],
            'fooBar!',
            'wrapper-short'
        ];
 
        $status = new Status();
        $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
        $status->warning( new Message( 'fooBar2!' ) );
        $testCases['2MessageWarnings'] = [
            $status,
            [
                [ 'key' => 'fooBar!', 'params' => [ 'foo', 'bar' ], 'lang' => 'qqx' ],
                [ 'key' => 'fooBar2!', 'params' => [], 'lang' => 'qqx' ]
            ],
            "* \$1\n* \$2",
            'wrapper-long'
        ];
 
        return $testCases;
    }
 
    public function testReplaceMessage() {
        $status = new Status();
        $message = new Message( 'key1', [ 'foo1', 'bar1' ] );
        $status->error( $message );
        $newMessage = new Message( 'key2', [ 'foo2', 'bar2' ] );
 
        $status->replaceMessage( $message, $newMessage );
 
        $this->assertEquals( $newMessage, $status->errors[0]['message'] );
    }
 
    public function testGetErrorMessage() {
        $method = new ReflectionMethod( Status::class, 'getErrorMessage' );
        $method->setAccessible( true );
        $status = new Status();
        $key = 'foo';
        $params = [ 'bar' ];
 
        $message = $method->invoke( $status, array_merge( [ $key ], $params ) );
        $this->assertInstanceOf( Message::class, $message );
        $this->assertEquals( $key, $message->getKey() );
        $this->assertEquals( $params, $message->getParams() );
    }
 
    public function testGetErrorMessageArray() {
        $method = new ReflectionMethod( Status::class, 'getErrorMessageArray' );
        $method->setAccessible( true );
        $status = new Status();
        $key = 'foo';
        $params = [ 'bar' ];
 
        $messageArray = $method->invoke(
            $status,
            [
                array_merge( [ $key ], $params ),
                array_merge( [ $key ], $params )
            ]
        );
 
        $this->assertInternalType( 'array', $messageArray );
        $this->assertCount( 2, $messageArray );
        foreach ( $messageArray as $message ) {
            $this->assertInstanceOf( Message::class, $message );
            $this->assertEquals( $key, $message->getKey() );
            $this->assertEquals( $params, $message->getParams() );
        }
    }
 
    public function testGetErrorsByType() {
        $status = new Status();
        $warning = new Message( 'warning111' );
        $error = new Message( 'error111' );
        $status->warning( $warning );
        $status->error( $error );
 
        $warnings = $status->getErrorsByType( 'warning' );
        $errors = $status->getErrorsByType( 'error' );
 
        $this->assertCount( 1, $warnings );
        $this->assertCount( 1, $errors );
        $this->assertEquals( $warning, $warnings[0]['message'] );
        $this->assertEquals( $error, $errors[0]['message'] );
    }
 
    public function testWakeUpSanitizesCallback() {
        $status = new Status();
        $status->cleanCallback = function ( $value ) {
            return '-' . $value . '-';
        };
        $status->__wakeup();
        $this->assertEquals( false, $status->cleanCallback );
    }
 
    public function testGetStatusArrayWithNonObjectMessages( $nonObjMsg ) {
        $status = new Status();
        if ( !array_key_exists( 1, $nonObjMsg ) ) {
            $status->warning( $nonObjMsg[0] );
        } else {
            $status->warning( $nonObjMsg[0], $nonObjMsg[1] );
        }
 
        $array = $status->getWarningsArray(); // We use getWarningsArray to access getStatusArray
 
        $this->assertEquals( 1, count( $array ) );
        $this->assertEquals( $nonObjMsg, $array[0] );
    }
 
    public static function provideNonObjectMessages() {
        return [
            [ [ 'ImaString', [ 'param1' => 'value1' ] ] ],
            [ [ 'ImaString' ] ],
        ];
    }
 
    public function testGetErrorsWarningsOnlyStatus( $errorText, $warningText, $type, $errorResult,
        $warningResult
    ) {
        $status = Status::newGood();
        if ( $errorText ) {
            $status->fatal( $errorText );
        }
        if ( $warningText ) {
            $status->warning( $warningText );
        }
        $testStatus = $status->splitByErrorType()[$type];
        $this->assertEquals( $errorResult, $testStatus->getErrorsByType( 'error' ) );
        $this->assertEquals( $warningResult, $testStatus->getErrorsByType( 'warning' ) );
    }
 
    public static function provideErrorsWarningsOnly() {
        return [
            [
                'Just an error',
                'Just a warning',
                0,
                [
                    0 => [
                        'type' => 'error',
                        'message' => 'Just an error',
                        'params' => []
                    ],
                ],
                [],
            ], [
                'Just an error',
                'Just a warning',
                1,
                [],
                [
                    0 => [
                        'type' => 'warning',
                        'message' => 'Just a warning',
                        'params' => []
                    ],
                ],
            ], [
                null,
                null,
                1,
                [],
                [],
            ], [
                null,
                null,
                0,
                [],
                [],
            ]
        ];
    }
 
}