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