tests/phpunit/includes/libs/Message/MessageValueTest.php

   1 <?php
   2
   3 namespace Wikimedia\Tests\Message;
   4
   5 use Wikimedia\Message\ListType;
   6 use Wikimedia\Message\MessageValue;
   7 use Wikimedia\Message\ParamType;
   8 use Wikimedia\Message\ScalarParam;
   9 use MediaWikiTestCase;
  10
  11 /**
  12  * @covers \Wikimedia\Message\MessageValue
  13  * @covers \Wikimedia\Message\ListParam
  14  * @covers \Wikimedia\Message\ScalarParam
  15  * @covers \Wikimedia\Message\MessageParam
  16  */
  17 class MessageValueTest extends MediaWikiTestCase {
  18         public static function provideConstruct() {
  19                 return [
  20                         [
  21                                 [],
  22                                 '<message key="key"></message>',
  23                         ],
  24                         [
  25                                 [ 'a' ],
  26                                 '<message key="key"><text>a</text></message>'
  27                         ],
  28                         [
  29                                 [ new ScalarParam( ParamType::BITRATE, 100 ) ],
  30                                 '<message key="key"><bitrate>100</bitrate></message>'
  31                         ],
  32                 ];
  33         }
  34
  35         /** @dataProvider provideConstruct */
  36         public function testConstruct( $input, $expected ) {
  37                 $mv = new MessageValue( 'key', $input );
  38                 $this->assertSame( $expected, $mv->dump() );
  39         }
  40
  41         public function testGetKey() {
  42                 $mv = new MessageValue( 'key' );
  43                 $this->assertSame( 'key', $mv->getKey() );
  44         }
  45
  46         public function testParams() {
  47                 $mv = new MessageValue( 'key' );
  48                 $mv->params( 1, 'x' );
  49                 $mv2 = $mv->params( new ScalarParam( ParamType::BITRATE, 100 ) );
  50                 $this->assertSame(
  51                         '<message key="key"><text>1</text><text>x</text><bitrate>100</bitrate></message>',
  52                         $mv->dump() );
  53                 $this->assertSame( $mv, $mv2 );
  54         }
  55
  56         public function testTextParamsOfType() {
  57                 $mv = new MessageValue( 'key' );
  58                 $mv2 = $mv->textParamsOfType( ParamType::BITRATE, 1, 2 );
  59                 $this->assertSame( '<message key="key">' .
  60                         '<bitrate>1</bitrate><bitrate>2</bitrate>' .
  61                         '</message>',
  62                         $mv->dump() );
  63                 $this->assertSame( $mv, $mv2 );
  64         }
  65
  66         public function testListParamsOfType() {
  67                 $mv = new MessageValue( 'key' );
  68                 $mv2 = $mv->listParamsOfType( ListType::COMMA, [ 'a' ], [ 'b', 'c' ] );
  69                 $this->assertSame( '<message key="key">' .
  70                         '<list listType="comma"><text>a</text></list>' .
  71                         '<list listType="comma"><text>b</text><text>c</text></list>' .
  72                         '</message>',
  73                         $mv->dump() );
  74                 $this->assertSame( $mv, $mv2 );
  75         }
  76
  77         public function testTextParams() {
  78                 $mv = new MessageValue( 'key' );
  79                 $mv2 = $mv->textParams( 'a', 'b', new MessageValue( 'key2' ) );
  80                 $this->assertSame( '<message key="key">' .
  81                         '<text>a</text>' .
  82                         '<text>b</text>' .
  83                         '<text><message key="key2"></message></text>' .
  84                         '</message>',
  85                         $mv->dump() );
  86                 $this->assertSame( $mv, $mv2 );
  87         }
  88
  89         public function testNumParams() {
  90                 $mv = new MessageValue( 'key' );
  91                 $mv2 = $mv->numParams( 1, 2 );
  92                 $this->assertSame( '<message key="key">' .
  93                         '<num>1</num>' .
  94                         '<num>2</num>' .
  95                         '</message>',
  96                         $mv->dump() );
  97                 $this->assertSame( $mv, $mv2 );
  98         }
  99
 100         public function testLongDurationParams() {
 101                 $mv = new MessageValue( 'key' );
 102                 $mv2 = $mv->longDurationParams( 1, 2 );
 103                 $this->assertSame( '<message key="key">' .
 104                         '<duration>1</duration>' .
 105                         '<duration>2</duration>' .
 106                         '</message>',
 107                         $mv->dump() );
 108                 $this->assertSame( $mv, $mv2 );
 109         }
 110
 111         public function testShortDurationParams() {
 112                 $mv = new MessageValue( 'key' );
 113                 $mv2 = $mv->shortDurationParams( 1, 2 );
 114                 $this->assertSame( '<message key="key">' .
 115                         '<timeperiod>1</timeperiod>' .
 116                         '<timeperiod>2</timeperiod>' .
 117                         '</message>',
 118                         $mv->dump() );
 119                 $this->assertSame( $mv, $mv2 );
 120         }
 121
 122         public function testExpiryParams() {
 123                 $mv = new MessageValue( 'key' );
 124                 $mv2 = $mv->expiryParams( 1, 2 );
 125                 $this->assertSame( '<message key="key">' .
 126                         '<expiry>1</expiry>' .
 127                         '<expiry>2</expiry>' .
 128                         '</message>',
 129                         $mv->dump() );
 130                 $this->assertSame( $mv, $mv2 );
 131         }
 132
 133         public function testSizeParams() {
 134                 $mv = new MessageValue( 'key' );
 135                 $mv2 = $mv->sizeParams( 1, 2 );
 136                 $this->assertSame( '<message key="key">' .
 137                         '<size>1</size>' .
 138                         '<size>2</size>' .
 139                         '</message>',
 140                         $mv->dump() );
 141                 $this->assertSame( $mv, $mv2 );
 142         }
 143
 144         public function testBitrateParams() {
 145                 $mv = new MessageValue( 'key' );
 146                 $mv2 = $mv->bitrateParams( 1, 2 );
 147                 $this->assertSame( '<message key="key">' .
 148                         '<bitrate>1</bitrate>' .
 149                         '<bitrate>2</bitrate>' .
 150                         '</message>',
 151                         $mv->dump() );
 152                 $this->assertSame( $mv, $mv2 );
 153         }
 154
 155         public function testRawParams() {
 156                 $mv = new MessageValue( 'key' );
 157                 $mv2 = $mv->rawParams( 1, 2 );
 158                 $this->assertSame( '<message key="key">' .
 159                         '<raw>1</raw>' .
 160                         '<raw>2</raw>' .
 161                         '</message>',
 162                         $mv->dump() );
 163                 $this->assertSame( $mv, $mv2 );
 164         }
 165
 166         public function testPlaintextParams() {
 167                 $mv = new MessageValue( 'key' );
 168                 $mv2 = $mv->plaintextParams( 1, 2 );
 169                 $this->assertSame( '<message key="key">' .
 170                         '<plaintext>1</plaintext>' .
 171                         '<plaintext>2</plaintext>' .
 172                         '</message>',
 173                         $mv->dump() );
 174                 $this->assertSame( $mv, $mv2 );
 175         }
 176
 177         public function testCommaListParams() {
 178                 $mv = new MessageValue( 'key' );
 179                 $mv2 = $mv->commaListParams( [ 'a', 'b' ] );
 180                 $this->assertSame( '<message key="key">' .
 181                         '<list listType="comma">' .
 182                         '<text>a</text><text>b</text>' .
 183                         '</list></message>',
 184                         $mv->dump() );
 185                 $this->assertSame( $mv, $mv2 );
 186         }
 187
 188         public function tesSemicolonListParams() {
 189                 $mv = new MessageValue( 'key' );
 190                 $mv2 = $mv->semicolonListParams( [ 'a', 'b' ] );
 191                 $this->assertSame( '<message key="key">' .
 192                         '<list listType="semicolon">' .
 193                         '<text>a</text><text>b</text>' .
 194                         '</list></message>',
 195                         $mv->dump() );
 196                 $this->assertSame( $mv, $mv2 );
 197         }
 198
 199         public function testPipeListParams() {
 200                 $mv = new MessageValue( 'key' );
 201                 $mv2 = $mv->pipeListParams( [ 'a', 'b' ] );
 202                 $this->assertSame( '<message key="key">' .
 203                         '<list listType="pipe">' .
 204                         '<text>a</text><text>b</text>' .
 205                         '</list></message>',
 206                         $mv->dump() );
 207                 $this->assertSame( $mv, $mv2 );
 208         }
 209
 210         public function testTextListParams() {
 211                 $mv = new MessageValue( 'key' );
 212                 $mv2 = $mv->textListParams( [ 'a', 'b' ] );
 213                 $this->assertSame( '<message key="key">' .
 214                         '<list listType="text">' .
 215                         '<text>a</text><text>b</text>' .
 216                         '</list></message>',
 217                         $mv->dump() );
 218                 $this->assertSame( $mv, $mv2 );
 219         }
 220 }