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
 134         public static function provideIsCompatible() {
 135                 return [
 136                         'Basic' =>
 137                                 [ 'foo', 'foo', null, '', true ],
 138                         'db+prefix' =>
 139                                 [ 'foo-bar_', 'foo', null, 'bar_', true ],
 140                         'db+schema+prefix' =>
 141                                 [ 'foo-bar-baz_', 'foo', 'bar', 'baz_', true ],
 142                         'db+dontcare_schema+prefix' =>
 143                                 [ 'foo-bar-baz_', 'foo', null, 'baz_', false ],
 144                         '?h -> -' =>
 145                                 [ 'foo?hbar-baz-baa_', 'foo-bar', 'baz', 'baa_', true ],
 146                         '?? -> ?' =>
 147                                 [ 'foo??bar-baz-baa_', 'foo?bar', 'baz', 'baa_', true ],
 148                         'Nothing' =>
 149                                 [ '', null, null, '', true ],
 150                         'dontcaredb+dontcaredbschema+prefix' =>
 151                                 [ 'mywiki-mediawiki-prefix_', null, null, 'prefix_', false ],
 152                         'db+dontcareschema+prefix' =>
 153                                 [ 'mywiki-schema-prefix_', 'mywiki', null, 'prefix_', false ],
 154                         'postgres-db-jobqueue' =>
 155                                 [ 'postgres-mediawiki-', 'postgres', null, '', false ]
 156                 ];
 157         }
 158
 159         /**
 160          * @dataProvider provideIsCompatible
 161          * @covers Wikimedia\Rdbms\DatabaseDomain::isCompatible
 162          */
 163         public function testIsCompatible( $id, $db, $schema, $prefix, $transitive ) {
 164                 $compareIdObj = DatabaseDomain::newFromId( $id );
 165                 $this->assertInstanceOf( DatabaseDomain::class, $compareIdObj );
 166
 167                 $fromId = new DatabaseDomain( $db, $schema, $prefix );
 168
 169                 $this->assertTrue( $fromId->isCompatible( $id ), 'constructed equals string' );
 170                 $this->assertTrue( $fromId->isCompatible( $compareIdObj ), 'fromId equals string' );
 171
 172                 $this->assertEquals( $transitive, $compareIdObj->isCompatible( $fromId ),
 173                         'test transitivity of nulls components' );
 174         }
 175
 176         public static function provideIsCompatible2() {
 177                 return [
 178                         'db+schema+prefix' =>
 179                                 [ 'mywiki-schema-prefix_', 'thatwiki', 'schema', 'prefix_' ],
 180                         'dontcaredb+dontcaredbschema+prefix' =>
 181                                 [ 'thatwiki-mediawiki-otherprefix_', null, null, 'prefix_' ],
 182                         'db+dontcareschema+prefix' =>
 183                                 [ 'notmywiki-schema-prefix_', 'mywiki', null, 'prefix_' ],
 184                 ];
 185         }
 186
 187         /**
 188          * @dataProvider provideIsCompatible2
 189          * @covers Wikimedia\Rdbms\DatabaseDomain::isCompatible
 190          */
 191         public function testIsCompatible2( $id, $db, $schema, $prefix ) {
 192                 $compareIdObj = DatabaseDomain::newFromId( $id );
 193                 $this->assertInstanceOf( DatabaseDomain::class, $compareIdObj );
 194
 195                 $fromId = new DatabaseDomain( $db, $schema, $prefix );
 196
 197                 $this->assertFalse( $fromId->isCompatible( $id ), 'constructed equals string' );
 198                 $this->assertFalse( $fromId->isCompatible( $compareIdObj ), 'fromId equals string' );
 199         }
 200
 201         /**
 202          * @expectedException InvalidArgumentException
 203          */
 204         public function testSchemaWithNoDB1() {
 205                 new DatabaseDomain( null, 'schema', '' );
 206         }
 207
 208         /**
 209          * @expectedException InvalidArgumentException
 210          */
 211         public function testSchemaWithNoDB2() {
 212                 DatabaseDomain::newFromId( '-schema-prefix' );
 213         }
 214
 215         /**
 216          * @covers Wikimedia\Rdbms\DatabaseDomain::isUnspecified
 217          */
 218         public function testIsUnspecified() {
 219                 $domain = new DatabaseDomain( null, null, '' );
 220                 $this->assertTrue( $domain->isUnspecified() );
 221                 $domain = new DatabaseDomain( 'mywiki', null, '' );
 222                 $this->assertFalse( $domain->isUnspecified() );
 223                 $domain = new DatabaseDomain( 'mywiki', null, '' );
 224                 $this->assertFalse( $domain->isUnspecified() );
 225         }
 226 }