tests/phpunit/includes/Storage/MutableRevisionSlotsTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Storage;
   4
   5 use Content;
   6 use InvalidArgumentException;
   7 use MediaWiki\Storage\MutableRevisionSlots;
   8 use MediaWiki\Storage\RevisionAccessException;
   9 use MediaWiki\Storage\RevisionSlots;
  10 use MediaWiki\Storage\SlotRecord;
  11 use WikitextContent;
  12
  13 /**
  14  * @covers \MediaWiki\Storage\MutableRevisionSlots
  15  */
  16 class MutableRevisionSlotsTest extends RevisionSlotsTest {
  17
  18         /**
  19          * @param SlotRecord[] $slots
  20          * @return RevisionSlots
  21          */
  22         protected function newRevisionSlots( $slots = [] ) {
  23                 return new MutableRevisionSlots( $slots );
  24         }
  25
  26         public function provideConstructorFailue() {
  27                 yield 'array or the wrong thing' => [
  28                         [ 1, 2, 3 ]
  29                 ];
  30         }
  31
  32         /**
  33          * @dataProvider provideConstructorFailue
  34          * @param $slots
  35          *
  36          * @covers \MediaWiki\Storage\RevisionSlots::__construct
  37          * @covers \MediaWiki\Storage\RevisionSlots::setSlotsInternal
  38          */
  39         public function testConstructorFailue( $slots ) {
  40                 $this->setExpectedException( InvalidArgumentException::class );
  41
  42                 new MutableRevisionSlots( $slots );
  43         }
  44
  45         public function testSetMultipleSlots() {
  46                 $slots = new MutableRevisionSlots();
  47
  48                 $this->assertSame( [], $slots->getSlots() );
  49
  50                 $slotA = SlotRecord::newUnsaved( 'some', new WikitextContent( 'A' ) );
  51                 $slots->setSlot( $slotA );
  52                 $this->assertTrue( $slots->hasSlot( 'some' ) );
  53                 $this->assertSame( $slotA, $slots->getSlot( 'some' ) );
  54                 $this->assertSame( [ 'some' => $slotA ], $slots->getSlots() );
  55
  56                 $slotB = SlotRecord::newUnsaved( 'other', new WikitextContent( 'B' ) );
  57                 $slots->setSlot( $slotB );
  58                 $this->assertTrue( $slots->hasSlot( 'other' ) );
  59                 $this->assertSame( $slotB, $slots->getSlot( 'other' ) );
  60                 $this->assertSame( [ 'some' => $slotA, 'other' => $slotB ], $slots->getSlots() );
  61         }
  62
  63         public function testSetExistingSlotOverwritesSlot() {
  64                 $slots = new MutableRevisionSlots();
  65
  66                 $this->assertSame( [], $slots->getSlots() );
  67
  68                 $slotA = SlotRecord::newUnsaved( 'main', new WikitextContent( 'A' ) );
  69                 $slots->setSlot( $slotA );
  70                 $this->assertSame( $slotA, $slots->getSlot( 'main' ) );
  71                 $this->assertSame( [ 'main' => $slotA ], $slots->getSlots() );
  72
  73                 $slotB = SlotRecord::newUnsaved( 'main', new WikitextContent( 'B' ) );
  74                 $slots->setSlot( $slotB );
  75                 $this->assertSame( $slotB, $slots->getSlot( 'main' ) );
  76                 $this->assertSame( [ 'main' => $slotB ], $slots->getSlots() );
  77         }
  78
  79         /**
  80          * @param string $role
  81          * @param Content $content
  82          * @return SlotRecord
  83          */
  84         private function newSavedSlot( $role, Content $content ) {
  85                 return SlotRecord::newSaved( 7, 7, 'xyz', SlotRecord::newUnsaved( $role, $content ) );
  86         }
  87
  88         public function testInheritSlotOverwritesSlot() {
  89                 $slots = new MutableRevisionSlots();
  90                 $slotA = SlotRecord::newUnsaved( 'main', new WikitextContent( 'A' ) );
  91                 $slots->setSlot( $slotA );
  92                 $slotB = $this->newSavedSlot( 'main', new WikitextContent( 'B' ) );
  93                 $slotC = $this->newSavedSlot( 'foo', new WikitextContent( 'C' ) );
  94                 $slots->inheritSlot( $slotB );
  95                 $slots->inheritSlot( $slotC );
  96                 $this->assertSame( [ 'main', 'foo' ], $slots->getSlotRoles() );
  97                 $this->assertNotSame( $slotB, $slots->getSlot( 'main' ) );
  98                 $this->assertNotSame( $slotC, $slots->getSlot( 'foo' ) );
  99                 $this->assertTrue( $slots->getSlot( 'main' )->isInherited() );
 100                 $this->assertTrue( $slots->getSlot( 'foo' )->isInherited() );
 101                 $this->assertSame( $slotB->getContent(), $slots->getSlot( 'main' )->getContent() );
 102                 $this->assertSame( $slotC->getContent(), $slots->getSlot( 'foo' )->getContent() );
 103         }
 104
 105         public function testSetContentOfExistingSlotOverwritesContent() {
 106                 $slots = new MutableRevisionSlots();
 107
 108                 $this->assertSame( [], $slots->getSlots() );
 109
 110                 $slotA = SlotRecord::newUnsaved( 'main', new WikitextContent( 'A' ) );
 111                 $slots->setSlot( $slotA );
 112                 $this->assertSame( $slotA, $slots->getSlot( 'main' ) );
 113                 $this->assertSame( [ 'main' => $slotA ], $slots->getSlots() );
 114
 115                 $newContent = new WikitextContent( 'B' );
 116                 $slots->setContent( 'main', $newContent );
 117                 $this->assertSame( $newContent, $slots->getContent( 'main' ) );
 118         }
 119
 120         public function testRemoveExistingSlot() {
 121                 $slotA = SlotRecord::newUnsaved( 'main', new WikitextContent( 'A' ) );
 122                 $slots = new MutableRevisionSlots( [ $slotA ] );
 123
 124                 $this->assertSame( [ 'main' => $slotA ], $slots->getSlots() );
 125
 126                 $slots->removeSlot( 'main' );
 127                 $this->assertSame( [], $slots->getSlots() );
 128                 $this->setExpectedException( RevisionAccessException::class );
 129                 $slots->getSlot( 'main' );
 130         }
 131
 132         public function testNewFromParentRevisionSlots() {
 133                 /** @var SlotRecord[] $parentSlots */
 134                 $parentSlots = [
 135                         'some' => $this->newSavedSlot( 'some', new WikitextContent( 'X' ) ),
 136                         'other' => $this->newSavedSlot( 'other', new WikitextContent( 'Y' ) ),
 137                 ];
 138                 $slots = MutableRevisionSlots::newFromParentRevisionSlots( $parentSlots );
 139                 $this->assertSame( [ 'some', 'other' ], $slots->getSlotRoles() );
 140                 $this->assertNotSame( $parentSlots['some'], $slots->getSlot( 'some' ) );
 141                 $this->assertNotSame( $parentSlots['other'], $slots->getSlot( 'other' ) );
 142                 $this->assertTrue( $slots->getSlot( 'some' )->isInherited() );
 143                 $this->assertTrue( $slots->getSlot( 'other' )->isInherited() );
 144                 $this->assertSame( $parentSlots['some']->getContent(), $slots->getContent( 'some' ) );
 145                 $this->assertSame( $parentSlots['other']->getContent(), $slots->getContent( 'other' ) );
 146         }
 147
 148 }