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->stashMwGlobals( $globalKey );
  76                 $GLOBALS[$globalKey] = $newValue;
  77                 $this->assertEquals(
  78                         $newValue,
  79                         $GLOBALS[$globalKey],
  80                         'Global failed to correctly set'
  81                 );
  82
  83                 $this->tearDown();
  84
  85                 $this->assertEquals(
  86                         self::$startGlobals[$globalKey],
  87                         $GLOBALS[$globalKey],
  88                         'Global failed to be restored on tearDown'
  89                 );
  90         }
  91
  92         /**
  93          * @covers MediaWikiTestCase::stashMwGlobals
  94          * @covers MediaWikiTestCase::tearDown
  95          */
  96         public function testSetNonExistentGlobalsAreUnsetOnTearDown() {
  97                 $globalKey = 'abcdefg1234567';
  98                 $this->setMwGlobals( $globalKey, true );
  99                 $this->assertTrue(
 100                         $GLOBALS[$globalKey],
 101                         'Global failed to correctly set'
 102                 );
 103
 104                 $this->tearDown();
 105
 106                 $this->assertFalse(
 107                         isset( $GLOBALS[$globalKey] ),
 108                         'Global failed to be correctly unset'
 109                 );
 110         }
 111
 112         public function testOverrideMwServices() {
 113                 $initialServices = MediaWikiServices::getInstance();
 114
 115                 $this->overrideMwServices();
 116                 $this->assertNotSame( $initialServices, MediaWikiServices::getInstance() );
 117         }
 118
 119         public function testSetService() {
 120                 $initialServices = MediaWikiServices::getInstance();
 121                 $initialService = $initialServices->getDBLoadBalancer();
 122                 $mockService = $this->getMockBuilder( LoadBalancer::class )
 123                         ->disableOriginalConstructor()->getMock();
 124
 125                 $this->setService( 'DBLoadBalancer', $mockService );
 126                 $this->assertNotSame(
 127                         $initialService,
 128                         MediaWikiServices::getInstance()->getDBLoadBalancer()
 129                 );
 130                 $this->assertSame( $mockService, MediaWikiServices::getInstance()->getDBLoadBalancer() );
 131         }
 132
 133         /**
 134          * @covers MediaWikiTestCase::setLogger
 135          * @covers MediaWikiTestCase::restoreLoggers
 136          */
 137         public function testLoggersAreRestoredOnTearDown_replacingExistingLogger() {
 138                 $logger1 = LoggerFactory::getInstance( 'foo' );
 139                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 140                 $logger2 = LoggerFactory::getInstance( 'foo' );
 141                 $this->tearDown();
 142                 $logger3 = LoggerFactory::getInstance( 'foo' );
 143
 144                 $this->assertSame( $logger1, $logger3 );
 145                 $this->assertNotSame( $logger1, $logger2 );
 146         }
 147
 148         /**
 149          * @covers MediaWikiTestCase::setLogger
 150          * @covers MediaWikiTestCase::restoreLoggers
 151          */
 152         public function testLoggersAreRestoredOnTearDown_replacingNonExistingLogger() {
 153                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 154                 $logger1 = LoggerFactory::getInstance( 'foo' );
 155                 $this->tearDown();
 156                 $logger2 = LoggerFactory::getInstance( 'foo' );
 157
 158                 $this->assertNotSame( $logger1, $logger2 );
 159                 $this->assertInstanceOf( \Psr\Log\LoggerInterface::class, $logger2 );
 160         }
 161
 162         /**
 163          * @covers MediaWikiTestCase::setLogger
 164          * @covers MediaWikiTestCase::restoreLoggers
 165          */
 166         public function testLoggersAreRestoredOnTearDown_replacingSameLoggerTwice() {
 167                 $logger1 = LoggerFactory::getInstance( 'baz' );
 168                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 169                 $this->setLogger( 'foo', $this->createMock( LoggerInterface::class ) );
 170                 $this->tearDown();
 171                 $logger2 = LoggerFactory::getInstance( 'baz' );
 172
 173                 $this->assertSame( $logger1, $logger2 );
 174         }
 175 }