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\TextParam;
   9 use MediaWikiTestCase;
  10
  11 /**
  12  * @covers \Wikimedia\Message\MessageValue
  13  * @covers \Wikimedia\Message\ListParam
  14  * @covers \Wikimedia\Message\TextParam
  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 TextParam( 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 TextParam( 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' );
  80                 $this->assertSame( '<message key="key">' .
  81                         '<text>a</text>' .
  82                         '<text>b</text>' .
  83                         '</message>',
  84                         $mv->dump() );
  85                 $this->assertSame( $mv, $mv2 );
  86         }
  87
  88         public function testNumParams() {
  89                 $mv = new MessageValue( 'key' );
  90                 $mv2 = $mv->numParams( 1, 2 );
  91                 $this->assertSame( '<message key="key">' .
  92                         '<num>1</num>' .
  93                         '<num>2</num>' .
  94                         '</message>',
  95                         $mv->dump() );
  96                 $this->assertSame( $mv, $mv2 );
  97         }
  98
  99         public function testLongDurationParams() {
 100                 $mv = new MessageValue( 'key' );
 101                 $mv2 = $mv->longDurationParams( 1, 2 );
 102                 $this->assertSame( '<message key="key">' .
 103                         '<duration>1</duration>' .
 104                         '<duration>2</duration>' .
 105                         '</message>',
 106                         $mv->dump() );
 107                 $this->assertSame( $mv, $mv2 );
 108         }
 109
 110         public function testShortDurationParams() {
 111                 $mv = new MessageValue( 'key' );
 112                 $mv2 = $mv->shortDurationParams( 1, 2 );
 113                 $this->assertSame( '<message key="key">' .
 114                         '<timeperiod>1</timeperiod>' .
 115                         '<timeperiod>2</timeperiod>' .
 116                         '</message>',
 117                         $mv->dump() );
 118                 $this->assertSame( $mv, $mv2 );
 119         }
 120
 121         public function testExpiryParams() {
 122                 $mv = new MessageValue( 'key' );
 123                 $mv2 = $mv->expiryParams( 1, 2 );
 124                 $this->assertSame( '<message key="key">' .
 125                         '<expiry>1</expiry>' .
 126                         '<expiry>2</expiry>' .
 127                         '</message>',
 128                         $mv->dump() );
 129                 $this->assertSame( $mv, $mv2 );
 130         }
 131
 132         public function testSizeParams() {
 133                 $mv = new MessageValue( 'key' );
 134                 $mv2 = $mv->sizeParams( 1, 2 );
 135                 $this->assertSame( '<message key="key">' .
 136                         '<size>1</size>' .
 137                         '<size>2</size>' .
 138                         '</message>',
 139                         $mv->dump() );
 140                 $this->assertSame( $mv, $mv2 );
 141         }
 142
 143         public function testBitrateParams() {
 144                 $mv = new MessageValue( 'key' );
 145                 $mv2 = $mv->bitrateParams( 1, 2 );
 146                 $this->assertSame( '<message key="key">' .
 147                         '<bitrate>1</bitrate>' .
 148                         '<bitrate>2</bitrate>' .
 149                         '</message>',
 150                         $mv->dump() );
 151                 $this->assertSame( $mv, $mv2 );
 152         }
 153
 154         public function testRawParams() {
 155                 $mv = new MessageValue( 'key' );
 156                 $mv2 = $mv->rawParams( 1, 2 );
 157                 $this->assertSame( '<message key="key">' .
 158                         '<raw>1</raw>' .
 159                         '<raw>2</raw>' .
 160                         '</message>',
 161                         $mv->dump() );
 162                 $this->assertSame( $mv, $mv2 );
 163         }
 164
 165         public function testPlaintextParams() {
 166                 $mv = new MessageValue( 'key' );
 167                 $mv2 = $mv->plaintextParams( 1, 2 );
 168                 $this->assertSame( '<message key="key">' .
 169                         '<plaintext>1</plaintext>' .
 170                         '<plaintext>2</plaintext>' .
 171                         '</message>',
 172                         $mv->dump() );
 173                 $this->assertSame( $mv, $mv2 );
 174         }
 175
 176         public function testCommaListParams() {
 177                 $mv = new MessageValue( 'key' );
 178                 $mv2 = $mv->commaListParams( [ 'a', 'b' ] );
 179                 $this->assertSame( '<message key="key">' .
 180                         '<list listType="comma">' .
 181                         '<text>a</text><text>b</text>' .
 182                         '</list></message>',
 183                         $mv->dump() );
 184                 $this->assertSame( $mv, $mv2 );
 185         }
 186
 187         public function tesSemicolonListParams() {
 188                 $mv = new MessageValue( 'key' );
 189                 $mv2 = $mv->semicolonListParams( [ 'a', 'b' ] );
 190                 $this->assertSame( '<message key="key">' .
 191                         '<list listType="semicolon">' .
 192                         '<text>a</text><text>b</text>' .
 193                         '</list></message>',
 194                         $mv->dump() );
 195                 $this->assertSame( $mv, $mv2 );
 196         }
 197
 198         public function testPipeListParams() {
 199                 $mv = new MessageValue( 'key' );
 200                 $mv2 = $mv->pipeListParams( [ 'a', 'b' ] );
 201                 $this->assertSame( '<message key="key">' .
 202                         '<list listType="pipe">' .
 203                         '<text>a</text><text>b</text>' .
 204                         '</list></message>',
 205                         $mv->dump() );
 206                 $this->assertSame( $mv, $mv2 );
 207         }
 208
 209         public function testTextListParams() {
 210                 $mv = new MessageValue( 'key' );
 211                 $mv2 = $mv->textListParams( [ 'a', 'b' ] );
 212                 $this->assertSame( '<message key="key">' .
 213                         '<list listType="text">' .
 214                         '<text>a</text><text>b</text>' .
 215                         '</list></message>',
 216                         $mv->dump() );
 217                 $this->assertSame( $mv, $mv2 );
 218         }
 219 }