--- /dev/null
+<?php
+
+/**
+ * @author Addshore
+ */
+class StatusTest extends MediaWikiLangTestCase {
+
+ public function testCanConstruct() {
+ new Status();
+ $this->assertTrue( true );
+ }
+
+ /**
+ * @dataProvider provideValues
+ * @covers Status::newGood
+ */
+ 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 ],
+ ];
+ }
+
+ /**
+ * @covers Status::newFatal
+ */
+ public function testNewFatalWithMessage() {
+ $message = $this->getMockBuilder( 'Message' )
+ ->disableOriginalConstructor()
+ ->getMock();
+
+ $status = Status::newFatal( $message );
+ $this->assertFalse( $status->isGood() );
+ $this->assertFalse( $status->isOK() );
+ $this->assertEquals( $message, $status->getMessage() );
+ }
+
+ /**
+ * @covers Status::newFatal
+ */
+ public function testNewFatalWithString() {
+ $message = 'foo';
+ $status = Status::newFatal( $message );
+ $this->assertFalse( $status->isGood() );
+ $this->assertFalse( $status->isOK() );
+ $this->assertEquals( $message, $status->getMessage()->getKey() );
+ }
+
+ /**
+ * Test 'ok' and 'errors' getters.
+ *
+ * @covers Status::__get
+ */
+ 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
+ );
+ }
+
+ /**
+ * Test 'ok' setter.
+ *
+ * @covers Status::__set
+ */
+ public function testOkSetter() {
+ $status = new Status();
+ $status->ok = false;
+ $this->assertFalse( $status->isOK() );
+ $status->ok = true;
+ $this->assertTrue( $status->isOK() );
+ }
+
+ /**
+ * @dataProvider provideSetResult
+ * @covers Status::setResult
+ */
+ 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' ],
+ ];
+ }
+
+ /**
+ * @dataProvider provideIsOk
+ * @covers Status::setOK
+ * @covers Status::isOK
+ */
+ public function testIsOk( $ok ) {
+ $status = new Status();
+ $status->setOK( $ok );
+ $this->assertEquals( $ok, $status->isOK() );
+ }
+
+ public static function provideIsOk() {
+ return [
+ [ true ],
+ [ false ],
+ ];
+ }
+
+ /**
+ * @covers Status::getValue
+ */
+ public function testGetValue() {
+ $status = new Status();
+ $status->value = 'foobar';
+ $this->assertEquals( 'foobar', $status->getValue() );
+ }
+
+ /**
+ * @dataProvider provideIsGood
+ * @covers Status::isGood
+ */
+ 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 ],
+ ];
+ }
+
+ /**
+ * @dataProvider provideMockMessageDetails
+ * @covers Status::warning
+ * @covers Status::getWarningsArray
+ * @covers Status::getStatusArray
+ */
+ 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 );
+ }
+ }
+
+ /**
+ * @dataProvider provideMockMessageDetails
+ * @covers Status::error
+ * @covers Status::getErrorsArray
+ * @covers Status::getStatusArray
+ * @covers Status::getErrors
+ */
+ 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 );
+ }
+ }
+
+ /**
+ * @dataProvider provideMockMessageDetails
+ * @covers Status::fatal
+ * @covers Status::getErrorsArray
+ * @covers Status::getStatusArray
+ */
+ 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' )
+ ->disableOriginalConstructor()
+ ->getMock();
+ $message->expects( $this->atLeastOnce() )
+ ->method( 'getKey' )
+ ->will( $this->returnValue( $key ) );
+ $message->expects( $this->atLeastOnce() )
+ ->method( 'getParams' )
+ ->will( $this->returnValue( $params ) );
+ return $message;
+ }
+
+ /**
+ * @param array $messageDetails E.g. array( 'KEY' => array(/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' ] ] ],
+ ];
+ }
+
+ /**
+ * @covers Status::merge
+ */
+ 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() )
+ );
+ }
+
+ /**
+ * @covers Status::merge
+ */
+ 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() );
+ }
+
+ /**
+ * @covers Status::hasMessage
+ */
+ 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' ) );
+ }
+
+ /**
+ * @dataProvider provideCleanParams
+ * @covers Status::cleanParams
+ */
+ public function testCleanParams( $cleanCallback, $params, $expected ) {
+ $method = new ReflectionMethod( 'Status', '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-' ] ],
+ ];
+ }
+
+ /**
+ * @dataProvider provideGetWikiTextAndHtml
+ * @covers Status::getWikiText
+ */
+ public function testGetWikiText(
+ Status $status, $wikitext, $wrappedWikitext, $html, $wrappedHtml
+ ) {
+ $this->assertEquals( $wikitext, $status->getWikiText() );
+
+ $this->assertEquals( $wrappedWikitext, $status->getWikiText( 'wrap-short', 'wrap-long', 'qqx' ) );
+ }
+
+ /**
+ * @dataProvider provideGetWikiTextAndHtml
+ * @covers Status::getHtml
+ */
+ public function testGetHtml(
+ Status $status, $wikitext, $wrappedWikitext, $html, $wrappedHtml
+ ) {
+ $this->assertEquals( $html, $status->getHTML() );
+
+ $this->assertEquals( $wrappedHtml, $status->getHTML( 'wrap-short', 'wrap-long', 'qqx' ) );
+ }
+
+ /**
+ * @return array Array of arrays with values;
+ * 0 => status object
+ * 1 => expected string (with no context)
+ */
+ 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() );
+ }
+
+ /**
+ * @dataProvider provideGetMessage
+ * @covers Status::getMessage
+ */
+ public function testGetMessage(
+ Status $status, $expectedParams = [], $expectedKey, $expectedWrapper
+ ) {
+ $message = $status->getMessage( null, null, 'qqx' );
+ $this->assertInstanceOf( 'Message', $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', $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', $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', $message );
+ $this->assertEquals( 'wrapper', $message->getKey(), 'Message::getKey with wrappers' );
+ $this->assertCount( 1, $message->getParams(), 'Message::getParams with wrappers' );
+ }
+
+ /**
+ * @return array Array of arrays with values;
+ * 0 => status object
+ * 1 => expected Message parameters (with no context)
+ * 2 => expected Message key
+ */
+ 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;
+ }
+
+ /**
+ * @covers Status::replaceMessage
+ */
+ 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'] );
+ }
+
+ /**
+ * @covers Status::getErrorMessage
+ */
+ public function testGetErrorMessage() {
+ $method = new ReflectionMethod( 'Status', 'getErrorMessage' );
+ $method->setAccessible( true );
+ $status = new Status();
+ $key = 'foo';
+ $params = [ 'bar' ];
+
+ /** @var Message $message */
+ $message = $method->invoke( $status, array_merge( [ $key ], $params ) );
+ $this->assertInstanceOf( 'Message', $message );
+ $this->assertEquals( $key, $message->getKey() );
+ $this->assertEquals( $params, $message->getParams() );
+ }
+
+ /**
+ * @covers Status::getErrorMessageArray
+ */
+ public function testGetErrorMessageArray() {
+ $method = new ReflectionMethod( 'Status', 'getErrorMessageArray' );
+ $method->setAccessible( true );
+ $status = new Status();
+ $key = 'foo';
+ $params = [ 'bar' ];
+
+ /** @var Message[] $messageArray */
+ $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', $message );
+ $this->assertEquals( $key, $message->getKey() );
+ $this->assertEquals( $params, $message->getParams() );
+ }
+ }
+
+ /**
+ * @covers Status::getErrorsByType
+ */
+ 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'] );
+ }
+
+ /**
+ * @covers Status::__wakeup
+ */
+ public function testWakeUpSanitizesCallback() {
+ $status = new Status();
+ $status->cleanCallback = function ( $value ) {
+ return '-' . $value . '-';
+ };
+ $status->__wakeup();
+ $this->assertEquals( false, $status->cleanCallback );
+ }
+
+ /**
+ * @dataProvider provideNonObjectMessages
+ * @covers Status::getStatusArray
+ */
+ 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' ] ],
+ ];
+ }
+
+ /**
+ * @dataProvider provideErrorsWarningsOnly
+ * @covers Status::splitByErrorType
+ * @covers StatusValue::splitByErrorType
+ */
+ 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,
+ [],
+ [],
+ ]
+ ];
+ }
+
+}
scripts.mit.edu / autoinstallsdev / mediawiki.git / blobdiff