tests/phpunit/includes/libs/rdbms/database/DatabaseDomainTest.php

   1 <?php
   2
   3 use Wikimedia\Rdbms\DatabaseDomain;
   4
   5 /**
   6  * @covers Wikimedia\Rdbms\DatabaseDomain
   7  */
   8 class DatabaseDomainTest extends PHPUnit_Framework_TestCase {
   9
  10         use MediaWikiCoversValidator;
  11
  12         public static function provideConstruct() {
  13                 return [
  14                         'All strings' =>
  15                                 [ 'foo', 'bar', 'baz', 'foo-bar-baz' ],
  16                         'Nothing' =>
  17                                 [ null, null, '', '' ],
  18                         'Invalid $database' =>
  19                                 [ 0, 'bar', '', '', true ],
  20                         'Invalid $schema' =>
  21                                 [ 'foo', 0, '', '', true ],
  22                         'Invalid $prefix' =>
  23                                 [ 'foo', 'bar', 0, '', true ],
  24                         'Dash' =>
  25                                 [ 'foo-bar', 'baz', 'baa', 'foo?hbar-baz-baa' ],
  26                         'Question mark' =>
  27                                 [ 'foo?bar', 'baz', 'baa', 'foo??bar-baz-baa' ],
  28                 ];
  29         }
  30
  31         /**
  32          * @dataProvider provideConstruct
  33          */
  34         public function testConstruct( $db, $schema, $prefix, $id, $exception = false ) {
  35                 if ( $exception ) {
  36                         $this->setExpectedException( InvalidArgumentException::class );
  37                         new DatabaseDomain( $db, $schema, $prefix );
  38                         return;
  39                 }
  40
  41                 $domain = new DatabaseDomain( $db, $schema, $prefix );
  42                 $this->assertInstanceOf( DatabaseDomain::class, $domain );
  43                 $this->assertEquals( $db, $domain->getDatabase() );
  44                 $this->assertEquals( $schema, $domain->getSchema() );
  45                 $this->assertEquals( $prefix, $domain->getTablePrefix() );
  46                 $this->assertEquals( $id, $domain->getId() );
  47                 $this->assertEquals( $id, strval( $domain ), 'toString' );
  48         }
  49
  50         public static function provideNewFromId() {
  51                 return [
  52                         'Basic' =>
  53                                 [ 'foo', 'foo', null, '' ],
  54                         'db+prefix' =>
  55                                 [ 'foo-bar', 'foo', null, 'bar' ],
  56                         'db+schema+prefix' =>
  57                                 [ 'foo-bar-baz', 'foo', 'bar', 'baz' ],
  58                         '?h -> -' =>
  59                                 [ 'foo?hbar-baz-baa', 'foo-bar', 'baz', 'baa' ],
  60                         '?? -> ?' =>
  61                                 [ 'foo??bar-baz-baa', 'foo?bar', 'baz', 'baa' ],
  62                         '? is left alone' =>
  63                                 [ 'foo?bar-baz-baa', 'foo?bar', 'baz', 'baa' ],
  64                         'too many parts' =>
  65                                 [ 'foo-bar-baz-baa', '', '', '', true ],
  66                         'from instance' =>
  67                                 [ DatabaseDomain::newUnspecified(), null, null, '' ],
  68                 ];
  69         }
  70
  71         /**
  72          * @dataProvider provideNewFromId
  73          */
  74         public function testNewFromId( $id, $db, $schema, $prefix, $exception = false ) {
  75                 if ( $exception ) {
  76                         $this->setExpectedException( InvalidArgumentException::class );
  77                         DatabaseDomain::newFromId( $id );
  78                         return;
  79                 }
  80                 $domain = DatabaseDomain::newFromId( $id );
  81                 $this->assertInstanceOf( DatabaseDomain::class, $domain );
  82                 $this->assertEquals( $db, $domain->getDatabase() );
  83                 $this->assertEquals( $schema, $domain->getSchema() );
  84                 $this->assertEquals( $prefix, $domain->getTablePrefix() );
  85         }
  86
  87         public static function provideEquals() {
  88                 return [
  89                         'Basic' =>
  90                                 [ 'foo', 'foo', null, '' ],
  91                         'db+prefix' =>
  92                                 [ 'foo-bar', 'foo', null, 'bar' ],
  93                         'db+schema+prefix' =>
  94                                 [ 'foo-bar-baz', 'foo', 'bar', 'baz' ],
  95                         '?h -> -' =>
  96                                 [ 'foo?hbar-baz-baa', 'foo-bar', 'baz', 'baa' ],
  97                         '?? -> ?' =>
  98                                 [ 'foo??bar-baz-baa', 'foo?bar', 'baz', 'baa' ],
  99                         'Nothing' =>
 100                                 [ '', null, null, '' ],
 101                 ];
 102         }
 103
 104         /**
 105          * @dataProvider provideEquals
 106          * @covers Wikimedia\Rdbms\DatabaseDomain::equals
 107          */
 108         public function testEquals( $id, $db, $schema, $prefix ) {
 109                 $fromId = DatabaseDomain::newFromId( $id );
 110                 $this->assertInstanceOf( DatabaseDomain::class, $fromId );
 111
 112                 $constructed = new DatabaseDomain( $db, $schema, $prefix );
 113
 114                 $this->assertTrue( $constructed->equals( $id ), 'constructed equals string' );
 115                 $this->assertTrue( $fromId->equals( $id ), 'fromId equals string' );
 116
 117                 $this->assertTrue( $constructed->equals( $fromId ), 'compare constructed to newId' );
 118                 $this->assertTrue( $fromId->equals( $constructed ), 'compare newId to constructed' );
 119         }
 120
 121         /**
 122          * @covers Wikimedia\Rdbms\DatabaseDomain::newUnspecified
 123          */
 124         public function testNewUnspecified() {
 125                 $domain = DatabaseDomain::newUnspecified();
 126                 $this->assertInstanceOf( DatabaseDomain::class, $domain );
 127                 $this->assertTrue( $domain->equals( '' ) );
 128                 $this->assertSame( null, $domain->getDatabase() );
 129                 $this->assertSame( null, $domain->getSchema() );
 130                 $this->assertSame( '', $domain->getTablePrefix() );
 131         }
 132 }