tests/phpunit/includes/Storage/McrReadNewRevisionStoreDbTest.php

   1 <?php
   2 namespace MediaWiki\Tests\Storage;
   3
   4 use CommentStoreComment;
   5 use MediaWiki\MediaWikiServices;
   6 use MediaWiki\Storage\RevisionRecord;
   7 use MediaWiki\Storage\SlotRecord;
   8 use TextContent;
   9 use Title;
  10 use WikitextContent;
  11
  12 /**
  13  * Tests RevisionStore against the intermediate MCR DB schema for use during schema migration.
  14  *
  15  * @covers \MediaWiki\Storage\RevisionStore
  16  *
  17  * @group RevisionStore
  18  * @group Storage
  19  * @group Database
  20  * @group medium
  21  */
  22 class McrReadNewRevisionStoreDbTest extends RevisionStoreDbTestBase {
  23
  24         use McrReadNewSchemaOverride;
  25
  26         protected function assertRevisionExistsInDatabase( RevisionRecord $rev ) {
  27                 $numberOfSlots = count( $rev->getSlotRoles() );
  28
  29                 // new schema is written
  30                 $this->assertSelect(
  31                         'slots',
  32                         [ 'count(*)' ],
  33                         [ 'slot_revision_id' => $rev->getId() ],
  34                         [ [ (string)$numberOfSlots ] ]
  35                 );
  36
  37                 $store = MediaWikiServices::getInstance()->getRevisionStore();
  38                 $revQuery = $store->getSlotsQueryInfo( [ 'content' ] );
  39
  40                 $this->assertSelect(
  41                         $revQuery['tables'],
  42                         [ 'count(*)' ],
  43                         [
  44                                 'slot_revision_id' => $rev->getId(),
  45                         ],
  46                         [ [ (string)$numberOfSlots ] ],
  47                         [],
  48                         $revQuery['joins']
  49                 );
  50
  51                 // Legacy schema is still being written
  52                 $this->assertSelect(
  53                         [ 'revision', 'text' ],
  54                         [ 'count(*)' ],
  55                         [ 'rev_id' => $rev->getId(), 'rev_text_id > 0' ],
  56                         [ [ 1 ] ],
  57                         [],
  58                         [ 'text' => [ 'INNER JOIN', [ 'rev_text_id = old_id' ] ] ]
  59                 );
  60
  61                 parent::assertRevisionExistsInDatabase( $rev );
  62         }
  63
  64         /**
  65          * @param SlotRecord $a
  66          * @param SlotRecord $b
  67          */
  68         protected function assertSameSlotContent( SlotRecord $a, SlotRecord $b ) {
  69                 parent::assertSameSlotContent( $a, $b );
  70
  71                 // Assert that the same content ID has been used
  72                 $this->assertSame( $a->getContentId(), $b->getContentId() );
  73         }
  74
  75         public function provideInsertRevisionOn_successes() {
  76                 foreach ( parent::provideInsertRevisionOn_successes() as $case ) {
  77                         yield $case;
  78                 }
  79
  80                 yield 'Multi-slot revision insertion' => [
  81                         [
  82                                 'content' => [
  83                                         'main' => new WikitextContent( 'Chicken' ),
  84                                         'aux' => new TextContent( 'Egg' ),
  85                                 ],
  86                                 'page' => true,
  87                                 'comment' => $this->getRandomCommentStoreComment(),
  88                                 'timestamp' => '20171117010101',
  89                                 'user' => true,
  90                         ],
  91                 ];
  92         }
  93
  94         public function provideNewNullRevision() {
  95                 foreach ( parent::provideNewNullRevision() as $case ) {
  96                         yield $case;
  97                 }
  98
  99                 yield [
 100                         Title::newFromText( 'UTPage_notAutoCreated' ),
 101                         [
 102                                 'content' => [
 103                                         'main' => new WikitextContent( 'Chicken' ),
 104                                         'aux' => new WikitextContent( 'Omelet' ),
 105                                 ],
 106                         ],
 107                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment multi' ),
 108                 ];
 109         }
 110
 111         public function testGetQueryInfo_NoSlotDataJoin() {
 112                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 113                 $queryInfo = $store->getQueryInfo();
 114
 115                 // with the new schema enabled, query info should not join the main slot info
 116                 $this->assertFalse( array_key_exists( 'a_slot_data', $queryInfo['tables'] ) );
 117                 $this->assertFalse( array_key_exists( 'a_slot_data', $queryInfo['joins'] ) );
 118         }
 119
 120         public function provideGetArchiveQueryInfo() {
 121                 yield [
 122                         [
 123                                 'tables' => [
 124                                         'archive',
 125                                 ],
 126                                 'fields' => array_merge(
 127                                         $this->getDefaultArchiveFields( false ),
 128                                         [
 129                                                 'ar_comment_text' => 'ar_comment',
 130                                                 'ar_comment_data' => 'NULL',
 131                                                 'ar_comment_cid' => 'NULL',
 132                                                 'ar_user_text' => 'ar_user_text',
 133                                                 'ar_user' => 'ar_user',
 134                                                 'ar_actor' => 'NULL',
 135                                         ]
 136                                 ),
 137                                 'joins' => [
 138                                 ],
 139                         ]
 140                 ];
 141         }
 142
 143         public function provideGetQueryInfo() {
 144                 // TODO: more option variations
 145                 yield [
 146                         [ 'page', 'user' ],
 147                         [
 148                                 'tables' => [
 149                                         'revision',
 150                                         'page',
 151                                         'user',
 152                                 ],
 153                                 'fields' => array_merge(
 154                                         $this->getDefaultQueryFields( false ),
 155                                         $this->getCommentQueryFields(),
 156                                         $this->getActorQueryFields(),
 157                                         [
 158                                                 'page_namespace',
 159                                                 'page_title',
 160                                                 'page_id',
 161                                                 'page_latest',
 162                                                 'page_is_redirect',
 163                                                 'page_len',
 164                                                 'user_name',
 165                                         ]
 166                                 ),
 167                                 'joins' => [
 168                                         'page' => [ 'INNER JOIN', [ 'page_id = rev_page' ] ],
 169                                         'user' => [ 'LEFT JOIN', [ 'rev_user != 0', 'user_id = rev_user' ] ],
 170                                 ],
 171                         ]
 172                 ];
 173         }
 174
 175         public function provideGetSlotsQueryInfo() {
 176                 yield [
 177                         [],
 178                         [
 179                                 'tables' => [
 180                                         'slots',
 181                                         'slot_roles',
 182                                 ],
 183                                 'fields' => array_merge(
 184                                         [
 185                                                 'slot_revision_id',
 186                                                 'slot_content_id',
 187                                                 'slot_origin',
 188                                                 'role_name',
 189                                         ]
 190                                 ),
 191                                 'joins' => [
 192                                         'slot_roles' => [ 'INNER JOIN', [ 'slot_role_id = role_id' ] ],
 193                                 ],
 194                         ]
 195                 ];
 196                 yield [
 197                         [ 'content' ],
 198                         [
 199                                 'tables' => [
 200                                         'slots',
 201                                         'slot_roles',
 202                                         'content',
 203                                         'content_models',
 204                                 ],
 205                                 'fields' => array_merge(
 206                                         [
 207                                                 'slot_revision_id',
 208                                                 'slot_content_id',
 209                                                 'slot_origin',
 210                                                 'role_name',
 211                                                 'content_size',
 212                                                 'content_sha1',
 213                                                 'content_address',
 214                                                 'model_name',
 215                                         ]
 216                                 ),
 217                                 'joins' => [
 218                                         'slot_roles' => [ 'INNER JOIN', [ 'slot_role_id = role_id' ] ],
 219                                         'content' => [ 'INNER JOIN', [ 'slot_content_id = content_id' ] ],
 220                                         'content_models' => [ 'INNER JOIN', [ 'content_model = model_id' ] ],
 221                                 ],
 222                         ]
 223                 ];
 224         }
 225
 226         public function provideNewMutableRevisionFromArray() {
 227                 foreach ( parent::provideNewMutableRevisionFromArray() as $case ) {
 228                         yield $case;
 229                 }
 230
 231                 yield 'Basic array, multiple roles' => [
 232                         [
 233                                 'id' => 2,
 234                                 'page' => 1,
 235                                 'timestamp' => '20171017114835',
 236                                 'user_text' => '111.0.1.2',
 237                                 'user' => 0,
 238                                 'minor_edit' => false,
 239                                 'deleted' => 0,
 240                                 'len' => 29,
 241                                 'parent_id' => 1,
 242                                 'sha1' => '89qs83keq9c9ccw9olvvm4oc9oq50ii',
 243                                 'comment' => 'Goat Comment!',
 244                                 'content' => [
 245                                         'main' => new WikitextContent( 'Söme Cöntent' ),
 246                                         'aux' => new TextContent( 'Öther Cöntent' ),
 247                                 ]
 248                         ]
 249                 ];
 250         }
 251
 252 }