tests/phpunit/tests/MediaWikiTestCaseTest.php

   1 <?php
   2 use MediaWiki\Logger\LoggerFactory;
   3 use MediaWiki\MediaWikiServices;
   4 use Psr\Log\LoggerInterface;
   5 use Wikimedia\Rdbms\LoadBalancer;
   6
   7 /**
   8  * @covers MediaWikiTestCase
   9  * @group MediaWikiTestCaseTest
  10  *
  11  * @author Addshore
  12  */
  13 class MediaWikiTestCaseTest extends MediaWikiTestCase {
  14
  15         private static $startGlobals = [
  16                 'MediaWikiTestCaseTestGLOBAL-ExistingString' => 'foo',
  17                 'MediaWikiTestCaseTestGLOBAL-ExistingStringEmpty' => '',
  18                 'MediaWikiTestCaseTestGLOBAL-ExistingArray' => [ 1, 'foo' => 'bar' ],
  19                 'MediaWikiTestCaseTestGLOBAL-ExistingArrayEmpty' => [],
  20         ];
  21
  22         public static function setUpBeforeClass() {
  23                 parent::setUpBeforeClass();
  24                 foreach ( self::$startGlobals as $key => $value ) {
  25                         $GLOBALS[$key] = $value;
  26                 }
  27         }
  28
  29         public static function tearDownAfterClass() {
  30                 parent::tearDownAfterClass();
  31                 foreach ( self::$startGlobals as $key => $value ) {
  32                         unset( $GLOBALS[$key] );
  33                 }
  34         }
  35
  36         public function provideExistingKeysAndNewValues() {
  37                 $providedArray = [];
  38                 foreach ( array_keys( self::$startGlobals ) as $key ) {
  39                         $providedArray[] = [ $key, 'newValue' ];
  40                         $providedArray[] = [ $key, [ 'newValue' ] ];
  41                 }
  42                 return $providedArray;
  43         }
  44
  45         /**
  46          * @dataProvider provideExistingKeysAndNewValues
  47          *
  48          * @covers MediaWikiTestCase::setMwGlobals
  49          * @covers MediaWikiTestCase::tearDown
  50          */
  51         public function testSetGlobalsAreRestoredOnTearDown( $globalKey, $newValue ) {
  52                 $this->setMwGlobals( $globalKey, $newValue );
  53                 $this->assertEquals(
  54                         $newValue,
  55                         $GLOBALS[$globalKey],
  56                         'Global failed to correctly set'
  57                 );
  58
  59                 $this->tearDown();
  60
  61                 $this->assertEquals(
  62                         self::$startGlobals[$globalKey],
  63                         $GLOBALS[$globalKey],
  64                         'Global failed to be restored on tearDown'
  65                 );
  66         }
  67
  68         /**
  69          * @dataProvider provideExistingKeysAndNewValues
  70          *
  71          * @covers MediaWikiTestCase::stashMwGlobals
  72          * @covers MediaWikiTestCase::tearDown
  73          */
  74         public function testStashedGlobalsAreRestoredOnTearDown( $globalKey, $newValue ) {
  75                 $this->hideDeprecated( 'MediaWikiTestCase::stashMwGlobals' );
  76                 $this->stashMwGlobals( $globalKey );
  77                 $GLOBALS[$globalKey] = $newValue;
  78                 $this->assertEquals(
  79                         $newValue,
  80                         $GLOBALS[$globalKey],
  81                         'Global failed to correctly set'
  82                 );
  83
  84                 $this->tearDown();
  85
  86                 $this->assertEquals(
  87                         self::$startGlobals[$globalKey],
  88                         $GLOBALS[$globalKey],
  89                         'Global failed to be restored on tearDown'
  90                 );
  91         }
  92
  93         /**
  94          * @covers MediaWikiTestCase::stashMwGlobals
  95          * @covers MediaWikiTestCase::tearDown
  96          */
  97         public function testSetNonExistentGlobalsAreUnsetOnTearDown() {
  98                 $globalKey = 'abcdefg1234567';
  99                 $this->setMwGlobals( $globalKey, true );
 100                 $this->assertTrue(
 101                         $GLOBALS[$globalKey],
 102                         'Global failed to correctly set'
 103                 );
 104
 105                 $this->tearDown();
 106
 107                 $this->assertFalse(
 108                         isset( $GLOBALS[$globalKey] ),
 109                         'Global failed to be correctly unset'
 110                 );
 111         }
 112
 113         public function testOverrideMwServices() {
 114                 $initialServices = MediaWikiServices::getInstance();
 115
 116                 $this->overrideMwServices();
 117                 $this->assertNotSame( $initialServices, MediaWikiServices::getInstance() );
 118         }
 119
 120         public function testSetService() {
 121                 $initialServices = MediaWikiServices::getInstance();
 122                 $initialService = $initialServices->getDBLoadBalancer();
 123                 $mockService = $this->getMockBuilder( LoadBalancer::class )
 124                         ->disableOriginalConstructor()->getMock();
 125
 126                 $this->setService( 'DBLoadBalancer', $mockService );
 127                 $this->assertNotSame(
 128                         $initialService,
 129                         MediaWikiServices::getInstance()->getDBLoadBalancer()
 130                 );
 131                 $this->assertSame( $mockService, MediaWikiServices::getInstance()->getDBLoadBalancer() );
 132         }
 133
 134         /**
 135          * @covers MediaWikiTestCase::setLogger
 136          * @covers MediaWikiTestCase::restoreLoggers
 137          */
 138         public function testLoggersAreRestoredOnTearDown_replacingExistingLogger() {
 139                 $logger1 = LoggerFactory::getInstance( 'foo' );
 140                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 141                 $logger2 = LoggerFactory::getInstance( 'foo' );
 142                 $this->tearDown();
 143                 $logger3 = LoggerFactory::getInstance( 'foo' );
 144
 145                 $this->assertSame( $logger1, $logger3 );
 146                 $this->assertNotSame( $logger1, $logger2 );
 147         }
 148
 149         /**
 150          * @covers MediaWikiTestCase::setLogger
 151          * @covers MediaWikiTestCase::restoreLoggers
 152          */
 153         public function testLoggersAreRestoredOnTearDown_replacingNonExistingLogger() {
 154                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 155                 $logger1 = LoggerFactory::getInstance( 'foo' );
 156                 $this->tearDown();
 157                 $logger2 = LoggerFactory::getInstance( 'foo' );
 158
 159                 $this->assertNotSame( $logger1, $logger2 );
 160                 $this->assertInstanceOf( \Psr\Log\LoggerInterface::class, $logger2 );
 161         }
 162
 163         /**
 164          * @covers MediaWikiTestCase::setLogger
 165          * @covers MediaWikiTestCase::restoreLoggers
 166          */
 167         public function testLoggersAreRestoredOnTearDown_replacingSameLoggerTwice() {
 168                 $logger1 = LoggerFactory::getInstance( 'baz' );
 169                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 170                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 171                 $this->tearDown();
 172                 $logger2 = LoggerFactory::getInstance( 'baz' );
 173
 174                 $this->assertSame( $logger1, $logger2 );
 175         }
 176 }