class SchemaTest

Same name in this branch
  1. 10 core/modules/sqlite/tests/src/Kernel/sqlite/SchemaTest.php \Drupal\Tests\sqlite\Kernel\sqlite\SchemaTest
  2. 10 core/modules/mysql/tests/src/Kernel/mysql/SchemaTest.php \Drupal\Tests\mysql\Kernel\mysql\SchemaTest
  3. 10 core/modules/pgsql/tests/src/Unit/SchemaTest.php \Drupal\Tests\pgsql\Unit\SchemaTest
Same name and namespace in other branches
  1. 9 core/modules/mysql/tests/src/Kernel/mysql/SchemaTest.php \Drupal\Tests\mysql\Kernel\mysql\SchemaTest
  2. 9 core/modules/pgsql/tests/src/Unit/SchemaTest.php \Drupal\Tests\pgsql\Unit\SchemaTest
  3. 9 core/modules/pgsql/tests/src/Kernel/pgsql/SchemaTest.php \Drupal\Tests\pgsql\Kernel\pgsql\SchemaTest
  4. 9 core/tests/Drupal/KernelTests/Core/Database/SchemaTest.php \Drupal\KernelTests\Core\Database\SchemaTest
  5. 8.9.x core/tests/Drupal/KernelTests/Core/Database/SchemaTest.php \Drupal\KernelTests\Core\Database\SchemaTest
  6. 11.x core/modules/sqlite/tests/src/Kernel/sqlite/SchemaTest.php \Drupal\Tests\sqlite\Kernel\sqlite\SchemaTest
  7. 11.x core/modules/mysql/tests/src/Kernel/mysql/SchemaTest.php \Drupal\Tests\mysql\Kernel\mysql\SchemaTest
  8. 11.x core/modules/pgsql/tests/src/Unit/SchemaTest.php \Drupal\Tests\pgsql\Unit\SchemaTest
  9. 11.x core/modules/pgsql/tests/src/Kernel/pgsql/SchemaTest.php \Drupal\Tests\pgsql\Kernel\pgsql\SchemaTest
  10. 11.x core/modules/mysqli/tests/src/Kernel/mysqli/SchemaTest.php \Drupal\Tests\mysqli\Kernel\mysqli\SchemaTest

Tests schema API for the PostgreSQL driver.

@group Database

Hierarchy

Expanded class hierarchy of SchemaTest

File

core/modules/pgsql/tests/src/Kernel/pgsql/SchemaTest.php, line 17

Namespace

Drupal\Tests\pgsql\Kernel\pgsql
View source
class SchemaTest extends DriverSpecificSchemaTestBase {
  
  /**
   * {@inheritdoc}
   */
  public function checkSchemaComment(string $description, string $table, ?string $column = NULL) : void {
    $this->assertSame($description, $this->schema
      ->getComment($table, $column), 'The comment matches the schema description.');
  }
  
  /**
   * {@inheritdoc}
   */
  protected function checkSequenceRenaming(string $tableName) : void {
    // For PostgreSQL, we also need to check that the sequence has been renamed.
    // The initial name of the sequence has been generated automatically by
    // PostgreSQL when the table was created, however, on subsequent table
    // renames the name is generated by Drupal and can not be easily
    // re-constructed. Hence we can only check that we still have a sequence on
    // the new table name.
    $sequenceExists = (bool) $this->connection
      ->query("SELECT pg_get_serial_sequence('{" . $tableName . "}', 'id')")
      ->fetchField();
    $this->assertTrue($sequenceExists, 'Sequence was renamed.');
    // Rename the table again and repeat the check.
    $anotherTableName = strtolower($this->getRandomGenerator()
      ->name(63 - strlen($this->getDatabasePrefix())));
    $this->schema
      ->renameTable($tableName, $anotherTableName);
    $sequenceExists = (bool) $this->connection
      ->query("SELECT pg_get_serial_sequence('{" . $anotherTableName . "}', 'id')")
      ->fetchField();
    $this->assertTrue($sequenceExists, 'Sequence was renamed.');
  }
  
  /**
   * {@inheritdoc}
   */
  public function testTableWithSpecificDataType() : void {
    $table_specification = [
      'description' => 'Schema table description.',
      'fields' => [
        'timestamp' => [
          'pgsql_type' => 'timestamp',
          'not null' => FALSE,
          'default' => NULL,
        ],
      ],
    ];
    $this->schema
      ->createTable('test_timestamp', $table_specification);
    $this->assertTrue($this->schema
      ->tableExists('test_timestamp'));
  }
  
  /**
   * @covers \Drupal\pgsql\Driver\Database\pgsql\Schema::introspectIndexSchema
   */
  public function testIntrospectIndexSchema() : void {
    $table_specification = [
      'fields' => [
        'id' => [
          'type' => 'int',
          'not null' => TRUE,
          'default' => 0,
        ],
        'test_field_1' => [
          'type' => 'int',
          'not null' => TRUE,
          'default' => 0,
        ],
        'test_field_2' => [
          'type' => 'int',
          'default' => 0,
        ],
        'test_field_3' => [
          'type' => 'int',
          'default' => 0,
        ],
        'test_field_4' => [
          'type' => 'int',
          'default' => 0,
        ],
        'test_field_5' => [
          'type' => 'int',
          'default' => 0,
        ],
      ],
      'primary key' => [
        'id',
        'test_field_1',
      ],
      'unique keys' => [
        'test_field_2' => [
          'test_field_2',
        ],
        'test_field_3_test_field_4' => [
          'test_field_3',
          'test_field_4',
        ],
      ],
      'indexes' => [
        'test_field_4' => [
          'test_field_4',
        ],
        'test_field_4_test_field_5' => [
          'test_field_4',
          'test_field_5',
        ],
      ],
    ];
    $table_name = strtolower($this->getRandomGenerator()
      ->name());
    $this->schema
      ->createTable($table_name, $table_specification);
    unset($table_specification['fields']);
    $introspect_index_schema = new \ReflectionMethod(get_class($this->schema), 'introspectIndexSchema');
    $index_schema = $introspect_index_schema->invoke($this->schema, $table_name);
    // The PostgreSQL driver is using a custom naming scheme for its indexes, so
    // we need to adjust the initial table specification.
    $ensure_identifier_length = new \ReflectionMethod(get_class($this->schema), 'ensureIdentifiersLength');
    foreach ($table_specification['unique keys'] as $original_index_name => $columns) {
      unset($table_specification['unique keys'][$original_index_name]);
      $new_index_name = $ensure_identifier_length->invoke($this->schema, $table_name, $original_index_name, 'key');
      $table_specification['unique keys'][$new_index_name] = $columns;
    }
    foreach ($table_specification['indexes'] as $original_index_name => $columns) {
      unset($table_specification['indexes'][$original_index_name]);
      $new_index_name = $ensure_identifier_length->invoke($this->schema, $table_name, $original_index_name, 'idx');
      $table_specification['indexes'][$new_index_name] = $columns;
    }
    $this->assertEquals($table_specification, $index_schema);
  }
  
  /**
   * {@inheritdoc}
   */
  public function testReservedKeywordsForNaming() : void {
    $table_specification = [
      'description' => 'A test table with an ANSI reserved keywords for naming.',
      'fields' => [
        'primary' => [
          'description' => 'Simple unique ID.',
          'type' => 'int',
          'not null' => TRUE,
        ],
        'update' => [
          'description' => 'A column with reserved name.',
          'type' => 'varchar',
          'length' => 255,
        ],
      ],
      'primary key' => [
        'primary',
      ],
      'unique keys' => [
        'having' => [
          'update',
        ],
      ],
      'indexes' => [
        'in' => [
          'primary',
          'update',
        ],
      ],
    ];
    // Creating a table.
    $table_name = 'select';
    $this->schema
      ->createTable($table_name, $table_specification);
    $this->assertTrue($this->schema
      ->tableExists($table_name));
    // Finding all tables.
    $tables = $this->schema
      ->findTables('%');
    sort($tables);
    $this->assertEquals([
      'config',
      'select',
    ], $tables);
    // Renaming a table.
    $table_name_new = 'from';
    $this->schema
      ->renameTable($table_name, $table_name_new);
    $this->assertFalse($this->schema
      ->tableExists($table_name));
    $this->assertTrue($this->schema
      ->tableExists($table_name_new));
    // Adding a field.
    $field_name = 'delete';
    $this->schema
      ->addField($table_name_new, $field_name, [
      'type' => 'int',
      'not null' => TRUE,
    ]);
    $this->assertTrue($this->schema
      ->fieldExists($table_name_new, $field_name));
    // Dropping a primary key.
    $this->schema
      ->dropPrimaryKey($table_name_new);
    // Adding a primary key.
    $this->schema
      ->addPrimaryKey($table_name_new, [
      $field_name,
    ]);
    // Check the primary key columns.
    $find_primary_key_columns = new \ReflectionMethod(get_class($this->schema), 'findPrimaryKeyColumns');
    $this->assertEquals([
      $field_name,
    ], $find_primary_key_columns->invoke($this->schema, $table_name_new));
    // Dropping a primary key.
    $this->schema
      ->dropPrimaryKey($table_name_new);
    // Changing a field.
    $field_name_new = 'where';
    $this->schema
      ->changeField($table_name_new, $field_name, $field_name_new, [
      'type' => 'int',
      'not null' => FALSE,
    ]);
    $this->assertFalse($this->schema
      ->fieldExists($table_name_new, $field_name));
    $this->assertTrue($this->schema
      ->fieldExists($table_name_new, $field_name_new));
    // Adding an unique key
    $unique_key_name = $unique_key_introspect_name = 'unique';
    $this->schema
      ->addUniqueKey($table_name_new, $unique_key_name, [
      $field_name_new,
    ]);
    // Check the unique key columns.
    $introspect_index_schema = new \ReflectionMethod(get_class($this->schema), 'introspectIndexSchema');
    $ensure_identifiers_length = new \ReflectionMethod(get_class($this->schema), 'ensureIdentifiersLength');
    $unique_key_introspect_name = $ensure_identifiers_length->invoke($this->schema, $table_name_new, $unique_key_name, 'key');
    $this->assertEquals([
      $field_name_new,
    ], $introspect_index_schema->invoke($this->schema, $table_name_new)['unique keys'][$unique_key_introspect_name]);
    // Dropping an unique key
    $this->schema
      ->dropUniqueKey($table_name_new, $unique_key_name);
    // Dropping a field.
    $this->schema
      ->dropField($table_name_new, $field_name_new);
    $this->assertFalse($this->schema
      ->fieldExists($table_name_new, $field_name_new));
    // Adding an index.
    $index_name = $index_introspect_name = 'index';
    $this->schema
      ->addIndex($table_name_new, $index_name, [
      'update',
    ], $table_specification);
    $this->assertTrue($this->schema
      ->indexExists($table_name_new, $index_name));
    // Check the index columns.
    $index_introspect_name = $ensure_identifiers_length->invoke($this->schema, $table_name_new, $index_name, 'idx');
    $this->assertEquals([
      'update',
    ], $introspect_index_schema->invoke($this->schema, $table_name_new)['indexes'][$index_introspect_name]);
    // Dropping an index.
    $this->schema
      ->dropIndex($table_name_new, $index_name);
    $this->assertFalse($this->schema
      ->indexExists($table_name_new, $index_name));
    // Dropping a table.
    $this->schema
      ->dropTable($table_name_new);
    $this->assertFalse($this->schema
      ->tableExists($table_name_new));
  }
  
  /**
   * @covers \Drupal\Core\Database\Driver\pgsql\Schema::extensionExists
   */
  public function testPgsqlExtensionExists() : void {
    // Test the method for a non existing extension.
    $this->assertFalse($this->schema
      ->extensionExists('non_existing_extension'));
    // Test the method for an existing extension.
    $this->assertTrue($this->schema
      ->extensionExists('pg_trgm'));
  }
  
  /**
   * Tests if the new sequences get the right ownership.
   */
  public function testPgsqlSequences() : void {
    $table_specification = [
      'description' => 'A test table with an ANSI reserved keywords for naming.',
      'fields' => [
        'uid' => [
          'description' => 'Simple unique ID.',
          'type' => 'serial',
          'not null' => TRUE,
        ],
        'update' => [
          'description' => 'A column with reserved name.',
          'type' => 'varchar',
          'length' => 255,
        ],
      ],
      'primary key' => [
        'uid',
      ],
      'unique keys' => [
        'having' => [
          'update',
        ],
      ],
      'indexes' => [
        'in' => [
          'uid',
          'update',
        ],
      ],
    ];
    // Creating a table.
    $table_name = 'sequence_test';
    $this->schema
      ->createTable($table_name, $table_specification);
    $this->assertTrue($this->schema
      ->tableExists($table_name));
    // Retrieves a sequence name that is owned by the table and column.
    $sequence_name = $this->connection
      ->query("SELECT pg_get_serial_sequence(:table, :column)", [
      ':table' => $this->connection
        ->getPrefix() . 'sequence_test',
      ':column' => 'uid',
    ])
      ->fetchField();
    $schema = $this->connection
      ->getConnectionOptions()['schema'] ?? 'public';
    $this->assertEquals($schema . '.' . $this->connection
      ->getPrefix() . 'sequence_test_uid_seq', $sequence_name);
    // Checks if the sequence exists.
    $this->assertTrue((bool) \Drupal::database()->query("SELECT c.relname FROM pg_class as c WHERE c.relkind = 'S' AND c.relname = :name", [
      ':name' => $this->connection
        ->getPrefix() . 'sequence_test_uid_seq',
    ])
      ->fetchField());
    // Retrieves the sequence owner object.
    $sequence_owner = \Drupal::database()->query("SELECT d.refobjid::regclass as table_name, a.attname as field_name\n      FROM pg_depend d\n      JOIN pg_attribute a ON a.attrelid = d.refobjid AND a.attnum = d.refobjsubid\n      WHERE d.objid = :seq_name::regclass\n      AND d.refobjsubid > 0\n      AND d.classid = 'pg_class'::regclass", [
      ':seq_name' => $sequence_name,
    ])
      ->fetchObject();
    $this->assertEquals($this->connection
      ->getPrefix() . 'sequence_test', $sequence_owner->table_name);
    $this->assertEquals('uid', $sequence_owner->field_name, 'New sequence is owned by its table.');
  }
  
  /**
   * Tests the method tableExists().
   */
  public function testTableExists() : void {
    $table_name = 'test_table';
    $table_specification = [
      'fields' => [
        'id' => [
          'type' => 'int',
          'default' => NULL,
        ],
      ],
    ];
    $this->schema
      ->createTable($table_name, $table_specification);
    $prefixed_table_name = $this->connection
      ->getPrefix($table_name) . $table_name;
    // Three different calls to the method Schema::tableExists() with an
    // unprefixed table name.
    $this->assertTrue($this->schema
      ->tableExists($table_name));
    $this->assertTrue($this->schema
      ->tableExists($table_name, TRUE));
    $this->assertFalse($this->schema
      ->tableExists($table_name, FALSE));
    // Three different calls to the method Schema::tableExists() with a
    // prefixed table name.
    $this->assertFalse($this->schema
      ->tableExists($prefixed_table_name));
    $this->assertFalse($this->schema
      ->tableExists($prefixed_table_name, TRUE));
    $this->assertTrue($this->schema
      ->tableExists($prefixed_table_name, FALSE));
  }
  
  /**
   * Tests renaming a table where the new index name is equal to the table name.
   */
  public function testRenameTableWithNewIndexNameEqualsTableName() : void {
    // Special table names for colliding with the PostgreSQL new index name.
    $table_name_old = 'some_new_table_name__id__idx';
    $table_name_new = 'some_new_table_name';
    $table_specification = [
      'fields' => [
        'id' => [
          'type' => 'int',
          'default' => NULL,
        ],
      ],
      'indexes' => [
        'id' => [
          'id',
        ],
      ],
    ];
    $this->schema
      ->createTable($table_name_old, $table_specification);
    // Renaming the table can fail for PostgreSQL, when a new index name is
    // equal to the old table name.
    $this->schema
      ->renameTable($table_name_old, $table_name_new);
    $this->assertTrue($this->schema
      ->tableExists($table_name_new));
  }
  
  /**
   * Tests column name escaping in field constraints.
   */
  public function testUnsignedField() : void {
    $table_name = 'unsigned_table';
    $table_spec = [
      'fields' => [
        'order' => [
          'type' => 'int',
          'unsigned' => TRUE,
          'not null' => TRUE,
        ],
      ],
      'primary key' => [
        'order',
      ],
    ];
    $this->schema
      ->createTable($table_name, $table_spec);
    $this->assertTrue($this->schema
      ->tableExists($table_name));
  }

}

Members

Title Sort descending Deprecated Modifiers Object type Summary Overriden Title Overrides
AssertContentTrait::$content protected property The current raw content.
AssertContentTrait::$drupalSettings protected property The drupalSettings value from the current raw $content.
AssertContentTrait::$elements protected property The XML structure parsed from the current raw $content. 1
AssertContentTrait::$plainTextContent protected property The plain-text content of raw $content (text nodes).
AssertContentTrait::assertEscaped protected function Passes if the raw text IS found escaped on the loaded page, fail otherwise.
AssertContentTrait::assertField protected function Asserts that a field exists with the given name or ID.
AssertContentTrait::assertFieldById protected function Asserts that a field exists with the given ID and value.
AssertContentTrait::assertFieldByName protected function Asserts that a field exists with the given name and value.
AssertContentTrait::assertFieldByXPath protected function Asserts that a field exists in the current page by the given XPath.
AssertContentTrait::assertFieldChecked protected function Asserts that a checkbox field in the current page is checked.
AssertContentTrait::assertFieldsByValue protected function Asserts that a field exists in the current page with a given Xpath result.
AssertContentTrait::assertLink protected function Passes if a link with the specified label is found.
AssertContentTrait::assertLinkByHref protected function Passes if a link containing a given href (part) is found.
AssertContentTrait::assertNoDuplicateIds protected function Asserts that each HTML ID is used for just a single element.
AssertContentTrait::assertNoEscaped protected function Passes if raw text IS NOT found escaped on loaded page, fail otherwise.
AssertContentTrait::assertNoField protected function Asserts that a field does not exist with the given name or ID.
AssertContentTrait::assertNoFieldById protected function Asserts that a field does not exist with the given ID and value.
AssertContentTrait::assertNoFieldByName protected function Asserts that a field does not exist with the given name and value.
AssertContentTrait::assertNoFieldByXPath protected function Asserts that a field does not exist or its value does not match, by XPath.
AssertContentTrait::assertNoFieldChecked protected function Asserts that a checkbox field in the current page is not checked.
AssertContentTrait::assertNoLink protected function Passes if a link with the specified label is not found.
AssertContentTrait::assertNoLinkByHref protected function Passes if a link containing a given href (part) is not found.
AssertContentTrait::assertNoLinkByHrefInMainRegion protected function Passes if a link containing a given href is not found in the main region.
AssertContentTrait::assertNoOption protected function Asserts that a select option in the current page does not exist.
AssertContentTrait::assertNoOptionSelected protected function Asserts that a select option in the current page is not checked.
AssertContentTrait::assertNoPattern protected function Triggers a pass if the perl regex pattern is not found in raw content.
AssertContentTrait::assertNoRaw protected function Passes if the raw text is NOT found on the loaded page, fail otherwise.
AssertContentTrait::assertNoText protected function Passes if the page (with HTML stripped) does not contains the text.
AssertContentTrait::assertNoTitle protected function Pass if the page title is not the given string.
AssertContentTrait::assertNoUniqueText protected function Passes if the text is found MORE THAN ONCE on the text version of the page.
AssertContentTrait::assertOption protected function Asserts that a select option in the current page exists.
AssertContentTrait::assertOptionByText protected function Asserts that a select option with the visible text exists.
AssertContentTrait::assertOptionSelected protected function Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionSelectedWithDrupalSelector protected function Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionWithDrupalSelector protected function Asserts that a select option in the current page exists.
AssertContentTrait::assertPattern protected function Triggers a pass if the Perl regex pattern is found in the raw content.
AssertContentTrait::assertRaw protected function Passes if the raw text IS found on the loaded page, fail otherwise.
AssertContentTrait::assertText protected function Passes if the page (with HTML stripped) contains the text.
AssertContentTrait::assertTextHelper protected function Helper for assertText and assertNoText.
AssertContentTrait::assertTextPattern protected function Asserts that a Perl regex pattern is found in the plain-text content.
AssertContentTrait::assertThemeOutput protected function Asserts themed output.
AssertContentTrait::assertTitle protected function Pass if the page title is the given string.
AssertContentTrait::assertUniqueText protected function Passes if the text is found ONLY ONCE on the text version of the page.
AssertContentTrait::assertUniqueTextHelper protected function Helper for assertUniqueText and assertNoUniqueText.
AssertContentTrait::buildXPathQuery protected function Builds an XPath query.
AssertContentTrait::constructFieldXpath protected function Helper: Constructs an XPath for the given set of attributes and value.
AssertContentTrait::cssSelect protected function Searches elements using a CSS selector in the raw content.
AssertContentTrait::getAllOptions protected function Get all option elements, including nested options, in a select.
AssertContentTrait::getDrupalSettings protected function Gets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::getRawContent protected function Gets the current raw content.
AssertContentTrait::getSelectedItem protected function Get the selected value from a select field.
AssertContentTrait::getTextContent protected function Retrieves the plain-text content from the current raw content.
AssertContentTrait::parse protected function Parse content returned from curlExec using DOM and SimpleXML.
AssertContentTrait::removeWhiteSpace protected function Removes all white-space between HTML tags from the raw content.
AssertContentTrait::setDrupalSettings protected function Sets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::setRawContent protected function Sets the raw content (e.g. HTML).
AssertContentTrait::xpath protected function Performs an xpath search on the contents of the internal browser.
ConfigTestTrait::configImporter protected function Returns a ConfigImporter object to import test configuration.
ConfigTestTrait::copyConfig protected function Copies configuration objects from source storage to target storage.
DriverSpecificSchemaTestBase::$connection protected property Connection to the database. Overrides DriverSpecificKernelTestBase::$connection
DriverSpecificSchemaTestBase::$counter protected property A global counter for table and field creation.
DriverSpecificSchemaTestBase::$schema protected property Database schema instance.
DriverSpecificSchemaTestBase::assertCollation protected function Asserts that fields have the correct collation, if supported. 1
DriverSpecificSchemaTestBase::assertFieldAdditionRemoval protected function Asserts that a given field can be added and removed from a table.
DriverSpecificSchemaTestBase::assertFieldChange protected function Asserts that a field can be changed from one spec to another.
DriverSpecificSchemaTestBase::assertFieldCharacteristics protected function Asserts that a newly added field has the correct characteristics.
DriverSpecificSchemaTestBase::providerTestSchemaCreateTablePrimaryKey public static function Provides test cases for SchemaTest::testSchemaCreateTablePrimaryKey().
DriverSpecificSchemaTestBase::setUp protected function Overrides DriverSpecificKernelTestBase::setUp
DriverSpecificSchemaTestBase::testChangePrimaryKeyToSerial public function Tests converting an int to a serial when the int column has data.
DriverSpecificSchemaTestBase::testChangeSerialFieldLength public function Tests changing a field length.
DriverSpecificSchemaTestBase::testDefaultAfterAlter public function Tests default values after altering table.
DriverSpecificSchemaTestBase::testFindPrimaryKeyColumns public function @covers ::findPrimaryKeyColumns[[api-linebreak]]
DriverSpecificSchemaTestBase::testFindTables public function Tests the findTables() method.
DriverSpecificSchemaTestBase::testInvalidPrimaryKeyAddition public function Tests adding an invalid field specification as a primary key.
DriverSpecificSchemaTestBase::testInvalidPrimaryKeyChange public function Tests changing the primary key with an invalid field specification.
DriverSpecificSchemaTestBase::testInvalidPrimaryKeyOnTableCreation public function Tests an invalid field specification as a primary key on table creation.
DriverSpecificSchemaTestBase::testSchema public function Tests database interactions.
DriverSpecificSchemaTestBase::testSchemaAddFieldDefaultInitial public function Tests adding columns to an existing table with default and initial value.
DriverSpecificSchemaTestBase::testSchemaChangeFieldDefaultInitial public function Tests changing columns between types with default and initial values.
DriverSpecificSchemaTestBase::testSchemaChangePrimaryKey public function Tests various schema changes' effect on the table's primary key.
DriverSpecificSchemaTestBase::testUnsignedColumns public function Tests creating unsigned columns and data integrity thereof.
DriverSpecificSchemaTestBase::testUpperCaseTableName public function Tests handling of uppercase table names.
DriverSpecificSchemaTestBase::tryInsert public function Tests inserting data into an existing table.
DriverSpecificSchemaTestBase::tryInsertExpectsIntegrityConstraintViolationException protected function Tries to insert a value that throws an IntegrityConstraintViolationException. 1
DriverSpecificSchemaTestBase::tryUnsignedInsert public function Tries to insert a negative value into columns defined as unsigned.
ExtensionListTestTrait::getModulePath protected function Gets the path for the specified module.
ExtensionListTestTrait::getThemePath protected function Gets the path for the specified theme.
KernelTestBase::$backupGlobals protected property Back up and restore any global variables that may be changed by tests.
KernelTestBase::$backupStaticAttributes protected property Back up and restore static class properties that may be changed by tests.
KernelTestBase::$backupStaticAttributesBlacklist protected property Contains a few static class properties for performance.
KernelTestBase::$classLoader protected property
KernelTestBase::$configImporter protected property @todo Move into Config test base class. 6
KernelTestBase::$configSchemaCheckerExclusions protected static property An array of config object names that are excluded from schema checking. 3
KernelTestBase::$container protected property
KernelTestBase::$databasePrefix protected property
KernelTestBase::$keyValue protected property The key_value service that must persist between container rebuilds.
KernelTestBase::$modules protected static property Modules to install. 558
KernelTestBase::$preserveGlobalState protected property Do not forward any global state from the parent process to the processes
that run the actual tests.
KernelTestBase::$root protected property The app root.
KernelTestBase::$runTestInSeparateProcess protected property Kernel tests are run in separate processes because they allow autoloading
of code from extensions. Running the test in a separate process isolates
this behavior from other tests. Subclasses should not override this
property.
KernelTestBase::$siteDirectory protected property
KernelTestBase::$strictConfigSchema protected property Set to TRUE to strict check all configuration saved. 9
KernelTestBase::$usesSuperUserAccessPolicy protected property Set to TRUE to make user 1 a super user. 7
KernelTestBase::$vfsRoot protected property The virtual filesystem root directory.
KernelTestBase::assertPostConditions protected function 1
KernelTestBase::bootEnvironment protected function Bootstraps a basic test environment.
KernelTestBase::bootKernel protected function Bootstraps a kernel for a test. 1
KernelTestBase::config protected function Configuration accessor for tests. Returns non-overridden configuration.
KernelTestBase::disableModules protected function Disables modules for this test.
KernelTestBase::enableModules protected function Enables modules for this test. 1
KernelTestBase::getConfigSchemaExclusions protected function Gets the config schema exclusions for this test.
KernelTestBase::getDatabaseConnectionInfo protected function Returns the Database connection info to be used for this test. 2
KernelTestBase::getDatabasePrefix public function
KernelTestBase::getExtensionsForModules private function Returns Extension objects for $modules to install.
KernelTestBase::getModulesToEnable private static function Returns the modules to install for this test.
KernelTestBase::initFileCache protected function Initializes the FileCache component.
KernelTestBase::installConfig protected function Installs default configuration for a given list of modules.
KernelTestBase::installEntitySchema protected function Installs the storage schema for a specific entity type.
KernelTestBase::installSchema protected function Installs database tables from a module schema definition.
KernelTestBase::register public function Registers test-specific services. Overrides ServiceProviderInterface::register 27
KernelTestBase::render protected function Renders a render array. 1
KernelTestBase::setInstallProfile protected function Sets the install profile and rebuilds the container to update it.
KernelTestBase::setSetting protected function Sets an in-memory Settings variable.
KernelTestBase::setUpBeforeClass public static function 1
KernelTestBase::setUpFilesystem protected function Sets up the filesystem, so things like the file directory. 2
KernelTestBase::stop Deprecated protected function Stops test execution.
KernelTestBase::tearDown protected function 6
KernelTestBase::tearDownCloseDatabaseConnection public function @after
KernelTestBase::vfsDump protected function Dumps the current state of the virtual filesystem to STDOUT.
KernelTestBase::__get public function
KernelTestBase::__sleep public function Prevents serializing any properties.
PhpUnitWarnings::$deprecationWarnings private static property Deprecation warnings from PHPUnit to raise with @trigger_error().
PhpUnitWarnings::addWarning public function Converts PHPUnit deprecation warnings to E_USER_DEPRECATED.
RandomGeneratorTrait::getRandomGenerator protected function Gets the random generator for the utility methods.
RandomGeneratorTrait::randomMachineName protected function Generates a unique random string containing letters and numbers.
RandomGeneratorTrait::randomObject public function Generates a random PHP object.
RandomGeneratorTrait::randomString public function Generates a pseudo-random string of ASCII characters of codes 32 to 126.
RandomGeneratorTrait::randomStringValidate Deprecated public function Callback for random string validation.
SchemaIntrospectionTestTrait::assertIndexOnColumns protected function Checks that an index covering exactly the given column names exists.
SchemaIntrospectionTestTrait::assertNoIndexOnColumns protected function Checks that an index covering exactly the given column names doesn't exist.
SchemaIntrospectionTestTrait::getIndexColumnNames protected function Returns the column names used by the indexes of a table.
SchemaTest::checkSchemaComment public function Checks that a table or column comment matches a given description. Overrides DriverSpecificSchemaTestBase::checkSchemaComment
SchemaTest::checkSequenceRenaming protected function Check that the ID sequence gets renamed when the table is renamed. Overrides DriverSpecificSchemaTestBase::checkSequenceRenaming
SchemaTest::testIntrospectIndexSchema public function @covers \Drupal\pgsql\Driver\Database\pgsql\Schema::introspectIndexSchema[[api-linebreak]]
SchemaTest::testPgsqlExtensionExists public function @covers \Drupal\Core\Database\Driver\pgsql\Schema::extensionExists[[api-linebreak]]
SchemaTest::testPgsqlSequences public function Tests if the new sequences get the right ownership.
SchemaTest::testRenameTableWithNewIndexNameEqualsTableName public function Tests renaming a table where the new index name is equal to the table name.
SchemaTest::testReservedKeywordsForNaming public function Tests handling with reserved keywords for naming tables, fields and more. Overrides DriverSpecificSchemaTestBase::testReservedKeywordsForNaming
SchemaTest::testTableExists public function Tests the method tableExists().
SchemaTest::testTableWithSpecificDataType public function Tests creating a table with database specific data type. Overrides DriverSpecificSchemaTestBase::testTableWithSpecificDataType
SchemaTest::testUnsignedField public function Tests column name escaping in field constraints.
StorageCopyTrait::replaceStorageContents protected static function Copy the configuration from one storage to another and remove stale items.
TestRequirementsTrait::checkModuleRequirements Deprecated private function Checks missing module requirements.
TestRequirementsTrait::checkRequirements Deprecated protected function Check module requirements for the Drupal use case.
TestRequirementsTrait::getDrupalRoot protected static function Returns the Drupal root directory.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.