abstract class KernelTestBase in Drupal 9

Base class for functional integration tests.

This base class should be useful for testing some types of integrations which don't require the overhead of a fully-installed Drupal instance, but which have many dependencies on parts of Drupal which can't or shouldn't be mocked.

This base class partially boots a fixture Drupal. The state of the fixture Drupal is comparable to the state of a system during the early part of the installation process.

Tests extending this base class can access services and the database, but the system is initially empty. This Drupal runs in a minimal mocked filesystem which operates within vfsStream.

Modules specified in the $modules property are added to the service container for each test. The module/hook system is functional. Additional modules needed in a test should override $modules. Modules specified in this way will be added to those specified in superclasses.

Unlike \Drupal\Tests\BrowserTestBase, the modules are not installed. They are loaded such that their services and hooks are available, but the install process has not been performed.

Other modules can be made available in this way using KernelTestBase::enableModules().

Some modules can be brought into a fully-installed state using KernelTestBase::installConfig(), KernelTestBase::installSchema(), and KernelTestBase::installEntitySchema(). Alternately, tests which need modules to be fully installed could inherit from \Drupal\Tests\BrowserTestBase.

Using Symfony's dump() function in Kernel tests will produce output on the command line, whether the call to dump() is in test code or site code.

Hierarchy

• class \Drupal\KernelTests\KernelTestBase extends \PHPUnit\Framework\TestCase implements ServiceProviderInterface uses \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, AssertContentTrait, AssertLegacyTrait, ConfigTestTrait, ExtensionListTestTrait, PhpUnitCompatibilityTrait, RandomGeneratorTrait, TestRequirementsTrait, PhpUnitWarnings

See also

\Drupal\Tests\KernelTestBase::$modules

\Drupal\Tests\KernelTestBase::enableModules()

\Drupal\Tests\KernelTestBase::installConfig()

\Drupal\Tests\KernelTestBase::installEntitySchema()

\Drupal\Tests\KernelTestBase::installSchema()

\Drupal\Tests\BrowserTestBase

Related topics

Automated tests

Overview of PHPUnit and Nightwatch automated tests.

541 files declare their use of KernelTestBase

AccessPermissionTest.php in core/modules/user/tests/src/Kernel/Views/AccessPermissionTest.php

AccessTest.php in core/modules/file/tests/src/Kernel/AccessTest.php

AccountSwitcherTest.php in core/tests/Drupal/KernelTests/Core/Session/AccountSwitcherTest.php

ActionsTest.php in core/tests/Drupal/KernelTests/Core/Render/Element/ActionsTest.php

ActionTest.php in core/modules/system/tests/src/Kernel/Action/ActionTest.php

... See full list

File

core/tests/Drupal/KernelTests/KernelTestBase.php, line 83

Namespace

Drupal\KernelTests

abstract class KernelTestBase extends TestCase implements ServiceProviderInterface {
  use AssertLegacyTrait;
  use AssertContentTrait;
  use RandomGeneratorTrait;
  use ConfigTestTrait;
  use ExtensionListTestTrait;
  use TestRequirementsTrait;
  use PhpUnitWarnings;
  use PhpUnitCompatibilityTrait;
  use ExpectDeprecationTrait;

  /**
   * {@inheritdoc}
   *
   * Back up and restore any global variables that may be changed by tests.
   *
   * @see self::runTestInSeparateProcess
   */
  protected $backupGlobals = TRUE;

  /**
   * {@inheritdoc}
   *
   * 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.
   */
  protected $runTestInSeparateProcess = TRUE;

  /**
   * {@inheritdoc}
   *
   * Back up and restore static class properties that may be changed by tests.
   *
   * @see self::runTestInSeparateProcess
   */
  protected $backupStaticAttributes = TRUE;

  /**
   * {@inheritdoc}
   *
   * Contains a few static class properties for performance.
   */
  protected $backupStaticAttributesBlacklist = [
    // Ignore static discovery/parser caches to speed up tests.
    'Drupal\\Component\\Discovery\\YamlDiscovery' => [
      'parsedFiles',
    ],
    'Drupal\\Core\\DependencyInjection\\YamlFileLoader' => [
      'yaml',
    ],
    'Drupal\\Core\\Extension\\ExtensionDiscovery' => [
      'files',
    ],
    'Drupal\\Core\\Extension\\InfoParser' => [
      'parsedInfos',
    ],
    // Drupal::$container cannot be serialized.
    'Drupal' => [
      'container',
    ],
    // Settings cannot be serialized.
    'Drupal\\Core\\Site\\Settings' => [
      'instance',
    ],
  ];

  /**
   * {@inheritdoc}
   *
   * Do not forward any global state from the parent process to the processes
   * that run the actual tests.
   *
   * @see self::runTestInSeparateProcess
   */
  protected $preserveGlobalState = FALSE;

  /**
   * @var \Composer\Autoload\Classloader
   */
  protected $classLoader;

  /**
   * @var string
   */
  protected $siteDirectory;

  /**
   * @var string
   */
  protected $databasePrefix;

  /**
   * @var \Drupal\Core\DependencyInjection\ContainerBuilder
   */
  protected $container;

  /**
   * Modules to enable.
   *
   * The test runner will merge the $modules lists from this class, the class
   * it extends, and so on up the class hierarchy. It is not necessary to
   * include modules in your list that a parent class has already declared.
   *
   * @see \Drupal\Tests\KernelTestBase::enableModules()
   * @see \Drupal\Tests\KernelTestBase::bootKernel()
   *
   * @var array
   */
  protected static $modules = [];

  /**
   * The virtual filesystem root directory.
   *
   * @var \org\bovigo\vfs\vfsStreamDirectory
   */
  protected $vfsRoot;

  /**
   * @todo Move into Config test base class.
   * @var \Drupal\Core\Config\ConfigImporter
   */
  protected $configImporter;

  /**
   * The app root.
   *
   * @var string
   */
  protected $root;

  /**
   * Set to TRUE to strict check all configuration saved.
   *
   * @see \Drupal\Core\Config\Development\ConfigSchemaChecker
   *
   * @var bool
   */
  protected $strictConfigSchema = TRUE;

  /**
   * An array of config object names that are excluded from schema checking.
   *
   * @var string[]
   */
  protected static $configSchemaCheckerExclusions = [
    // Following are used to test lack of or partial schema. Where partial
    // schema is provided, that is explicitly tested in specific tests.
    'config_schema_test.noschema',
    'config_schema_test.someschema',
    'config_schema_test.schema_data_types',
    'config_schema_test.no_schema_data_types',
    // Used to test application of schema to filtering of configuration.
    'config_test.dynamic.system',
  ];

  /**
   * {@inheritdoc}
   */
  public static function setUpBeforeClass() {
    parent::setUpBeforeClass();
    VarDumper::setHandler(TestVarDumper::class . '::cliHandler');

    // Change the current dir to DRUPAL_ROOT.
    chdir(static::getDrupalRoot());
  }

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();

    // Allow tests to compare MarkupInterface objects via assertEquals().
    $this
      ->registerComparator(new MarkupInterfaceComparator());
    $this->root = static::getDrupalRoot();
    $this
      ->initFileCache();
    $this
      ->bootEnvironment();
    $this
      ->bootKernel();
  }

  /**
   * Bootstraps a basic test environment.
   *
   * Should not be called by tests. Only visible for DrupalKernel integration
   * tests.
   *
   * @see \Drupal\KernelTests\Core\DrupalKernel\DrupalKernelTest
   * @internal
   */
  protected function bootEnvironment() {
    $this->streamWrappers = [];
    \Drupal::unsetContainer();
    $this->classLoader = (require $this->root . '/autoload.php');

    // Set up virtual filesystem.
    Database::addConnectionInfo('default', 'test-runner', $this
      ->getDatabaseConnectionInfo()['default']);
    $test_db = new TestDatabase();
    $this->siteDirectory = $test_db
      ->getTestSitePath();

    // Ensure that all code that relies on drupal_valid_test_ua() can still be
    // safely executed. This primarily affects the (test) site directory
    // resolution (used by e.g. LocalStream and PhpStorage).
    $this->databasePrefix = $test_db
      ->getDatabasePrefix();
    drupal_valid_test_ua($this->databasePrefix);
    $settings = [
      'hash_salt' => static::class,
      'file_public_path' => $this->siteDirectory . '/files',
      // Disable Twig template caching/dumping.
      'twig_cache' => FALSE,
    ];
    new Settings($settings);
    $this
      ->setUpFilesystem();
    foreach (Database::getAllConnectionInfo() as $key => $targets) {
      Database::removeConnection($key);
    }
    Database::addConnectionInfo('default', 'default', $this
      ->getDatabaseConnectionInfo()['default']);
  }

  /**
   * Sets up the filesystem, so things like the file directory.
   */
  protected function setUpFilesystem() {
    $test_db = new TestDatabase($this->databasePrefix);
    $test_site_path = $test_db
      ->getTestSitePath();
    $this->vfsRoot = vfsStream::setup('root');
    $this->vfsRoot
      ->addChild(vfsStream::newDirectory($test_site_path));
    $this->siteDirectory = vfsStream::url('root/' . $test_site_path);
    mkdir($this->siteDirectory . '/files', 0775);
    mkdir($this->siteDirectory . '/files/config/sync', 0775, TRUE);
    $settings = Settings::getInstance() ? Settings::getAll() : [];
    $settings['file_public_path'] = $this->siteDirectory . '/files';
    $settings['config_sync_directory'] = $this->siteDirectory . '/files/config/sync';
    new Settings($settings);
  }

  /**
   * @return string
   */
  public function getDatabasePrefix() {
    return $this->databasePrefix;
  }

  /**
   * Bootstraps a kernel for a test.
   */
  private function bootKernel() {
    $this
      ->setSetting('container_yamls', []);

    // Allow for test-specific overrides.
    $settings_services_file = $this->root . '/sites/default/testing.services.yml';
    if (file_exists($settings_services_file)) {

      // Copy the testing-specific service overrides in place.
      $testing_services_file = $this->siteDirectory . '/services.yml';
      copy($settings_services_file, $testing_services_file);
      $this
        ->setSetting('container_yamls', [
        $testing_services_file,
      ]);
    }

    // Allow for global test environment overrides.
    if (file_exists($test_env = $this->root . '/sites/default/testing.services.yml')) {
      $GLOBALS['conf']['container_yamls']['testing'] = $test_env;
    }

    // Add this test class as a service provider.
    $GLOBALS['conf']['container_service_providers']['test'] = $this;
    $modules = self::getModulesToEnable(static::class);

    // When a module is providing the database driver, then enable that module.
    $connection_info = Database::getConnectionInfo();
    $driver = $connection_info['default']['driver'];
    $namespace = $connection_info['default']['namespace'] ?? NULL;
    $autoload = $connection_info['default']['autoload'] ?? NULL;
    if (strpos($autoload, 'src/Driver/Database/') !== FALSE) {
      [
        $first,
        $second,
      ] = explode('\\', $namespace, 3);
      if ($first === 'Drupal' && strtolower($second) === $second) {

        // Add the module that provides the database driver to the list of
        // modules as the first to be enabled.
        array_unshift($modules, $second);
      }
    }

    // Bootstrap the kernel. Do not use createFromRequest() to retain Settings.
    $kernel = new DrupalKernel('testing', $this->classLoader, FALSE);
    $kernel
      ->setSitePath($this->siteDirectory);

    // Boot a new one-time container from scratch. Set the module list upfront
    // to avoid a subsequent rebuild or setting the kernel into the
    // pre-installer mode.
    $extensions = $modules ? $this
      ->getExtensionsForModules($modules) : [];
    $kernel
      ->updateModules($extensions, $extensions);

    // DrupalKernel::boot() is not sufficient as it does not invoke preHandle(),
    // which is required to initialize legacy global variables.
    $request = Request::create('/');
    $kernel
      ->boot();
    $request->attributes
      ->set(RouteObjectInterface::ROUTE_OBJECT, new Route('<none>'));
    $request->attributes
      ->set(RouteObjectInterface::ROUTE_NAME, '<none>');
    $kernel
      ->preHandle($request);
    $this->container = $kernel
      ->getContainer();

    // Ensure database tasks have been run.
    require_once __DIR__ . '/../../../includes/install.inc';
    $errors = db_installer_object($driver, $namespace)
      ->runTasks();
    if (!empty($errors)) {
      $this
        ->fail('Failed to run installer database tasks: ' . implode(', ', $errors));
    }
    if ($modules) {
      $this->container
        ->get('module_handler')
        ->loadAll();
    }

    // Setup the destination to the be frontpage by default.
    \Drupal::destination()
      ->set('/');

    // Write the core.extension configuration.
    // Required for ConfigInstaller::installDefaultConfig() to work.
    $this->container
      ->get('config.storage')
      ->write('core.extension', [
      'module' => array_fill_keys($modules, 0),
      'theme' => [],
      'profile' => '',
    ]);
    $settings = Settings::getAll();
    $settings['php_storage']['default'] = [
      'class' => '\\Drupal\\Component\\PhpStorage\\FileStorage',
    ];
    new Settings($settings);

    // Manually configure the test mail collector implementation to prevent
    // tests from sending out emails and collect them in state instead.
    // While this should be enforced via settings.php prior to installation,
    // some tests expect to be able to test mail system implementations.
    $GLOBALS['config']['system.mail']['interface']['default'] = 'test_mail_collector';

    // Manually configure the default file scheme so that modules that use file
    // functions don't have to install system and its configuration.
    // @see file_default_scheme()
    $GLOBALS['config']['system.file']['default_scheme'] = 'public';
  }

  /**
   * Configuration accessor for tests. Returns non-overridden configuration.
   *
   * @param string $name
   *   The configuration name.
   *
   * @return \Drupal\Core\Config\Config
   *   The configuration object with original configuration data.
   */
  protected function config($name) {
    return $this->container
      ->get('config.factory')
      ->getEditable($name);
  }

  /**
   * Returns the Database connection info to be used for this test.
   *
   * This method only exists for tests of the Database component itself, because
   * they require multiple database connections. Each SQLite :memory: connection
   * creates a new/separate database in memory. A shared-memory SQLite file URI
   * triggers PHP open_basedir/allow_url_fopen/allow_url_include restrictions.
   * Due to that, Database tests are running against a SQLite database that is
   * located in an actual file in the system's temporary directory.
   *
   * Other tests should not override this method.
   *
   * @return array
   *   A Database connection info array.
   *
   * @internal
   */
  protected function getDatabaseConnectionInfo() {

    // If the test is run with argument dburl then use it.
    $db_url = getenv('SIMPLETEST_DB');
    if (empty($db_url)) {
      throw new \Exception('There is no database connection so no tests can be run. You must provide a SIMPLETEST_DB environment variable to run PHPUnit based functional tests outside of run-tests.sh. See https://www.drupal.org/node/2116263#skipped-tests for more information.');
    }
    else {
      $database = Database::convertDbUrlToConnectionInfo($db_url, $this->root);
      Database::addConnectionInfo('default', 'default', $database);
    }

    // Clone the current connection and replace the current prefix.
    $connection_info = Database::getConnectionInfo('default');
    if (!empty($connection_info)) {
      Database::renameConnection('default', 'simpletest_original_default');
      foreach ($connection_info as $target => $value) {

        // Replace the full table prefix definition to ensure that no table
        // prefixes of the test runner leak into the test.
        $connection_info[$target]['prefix'] = $this->databasePrefix;
      }
    }
    return $connection_info;
  }

  /**
   * Initializes the FileCache component.
   *
   * We can not use the Settings object in a component, that's why we have to do
   * it here instead of \Drupal\Component\FileCache\FileCacheFactory.
   */
  protected function initFileCache() {
    $configuration = Settings::get('file_cache');

    // Provide a default configuration, if not set.
    if (!isset($configuration['default'])) {

      // @todo Use extension_loaded('apcu') for non-testbot
      //   https://www.drupal.org/node/2447753.
      if (function_exists('apcu_fetch')) {
        $configuration['default']['cache_backend_class'] = ApcuFileCacheBackend::class;
      }
    }
    FileCacheFactory::setConfiguration($configuration);
    FileCacheFactory::setPrefix(Settings::getApcuPrefix('file_cache', $this->root));
  }

  /**
   * Returns Extension objects for $modules to enable.
   *
   * @param string[] $modules
   *   The list of modules to enable.
   *
   * @return \Drupal\Core\Extension\Extension[]
   *   Extension objects for $modules, keyed by module name.
   *
   * @throws \PHPUnit\Framework\Exception
   *   If a module is not available.
   *
   * @see \Drupal\Tests\KernelTestBase::enableModules()
   * @see \Drupal\Core\Extension\ModuleHandler::add()
   */
  private function getExtensionsForModules(array $modules) {
    $extensions = [];
    $discovery = new ExtensionDiscovery($this->root);
    $discovery
      ->setProfileDirectories([]);
    $list = $discovery
      ->scan('module');
    foreach ($modules as $name) {
      if (!isset($list[$name])) {
        throw new Exception("Unavailable module: '{$name}'. If this module needs to be downloaded separately, annotate the test class with '@requires module {$name}'.");
      }
      $extensions[$name] = $list[$name];
    }
    return $extensions;
  }

  /**
   * Registers test-specific services.
   *
   * Extend this method in your test to register additional services. This
   * method is called whenever the kernel is rebuilt.
   *
   * @param \Drupal\Core\DependencyInjection\ContainerBuilder $container
   *   The service container to enhance.
   *
   * @see \Drupal\Tests\KernelTestBase::bootKernel()
   */
  public function register(ContainerBuilder $container) {

    // Keep the container object around for tests.
    $this->container = $container;
    $container
      ->register('flood', 'Drupal\\Core\\Flood\\MemoryBackend')
      ->addArgument(new Reference('request_stack'));
    $container
      ->register('lock', 'Drupal\\Core\\Lock\\NullLockBackend');
    $container
      ->register('cache_factory', 'Drupal\\Core\\Cache\\MemoryBackendFactory');
    $container
      ->register('keyvalue.memory', 'Drupal\\Core\\KeyValueStore\\KeyValueMemoryFactory')
      ->addTag('persist');
    $container
      ->setAlias('keyvalue', 'keyvalue.memory');

    // Set the default language on the minimal container.
    $container
      ->setParameter('language.default_values', Language::$defaultValues);
    if ($this->strictConfigSchema) {
      $container
        ->register('testing.config_schema_checker', ConfigSchemaChecker::class)
        ->addArgument(new Reference('config.typed'))
        ->addArgument($this
        ->getConfigSchemaExclusions())
        ->addTag('event_subscriber');
    }
    if ($container
      ->hasDefinition('path_alias.path_processor')) {

      // The alias-based processor requires the path_alias entity schema to be
      // installed, so we prevent it from being registered to the path processor
      // manager. We do this by removing the tags that the compiler pass looks
      // for. This means that the URL generator can safely be used within tests.
      $container
        ->getDefinition('path_alias.path_processor')
        ->clearTag('path_processor_inbound')
        ->clearTag('path_processor_outbound');
    }
    if ($container
      ->hasDefinition('password')) {
      $container
        ->getDefinition('password')
        ->setArguments([
        1,
      ]);
    }

    // Add the on demand rebuild route provider service.
    $route_provider_service_name = 'router.route_provider';

    // While $container->get() does a recursive resolve, getDefinition() does
    // not, so do it ourselves.
    $id = $route_provider_service_name;
    while ($container
      ->hasAlias($id)) {
      $id = (string) $container
        ->getAlias($id);
    }
    $definition = $container
      ->getDefinition($id);
    $definition
      ->clearTag('needs_destruction');
    $container
      ->setDefinition("simpletest.{$route_provider_service_name}", $definition);
    $route_provider_definition = new Definition(RouteProvider::class);
    $route_provider_definition
      ->setPublic(TRUE);
    $container
      ->setDefinition($id, $route_provider_definition);
  }

  /**
   * Gets the config schema exclusions for this test.
   *
   * @return string[]
   *   An array of config object names that are excluded from schema checking.
   */
  protected function getConfigSchemaExclusions() {
    $class = static::class;
    $exceptions = [];
    while ($class) {
      if (property_exists($class, 'configSchemaCheckerExclusions')) {
        $exceptions = array_merge($exceptions, $class::$configSchemaCheckerExclusions);
      }
      $class = get_parent_class($class);
    }

    // Filter out any duplicates.
    return array_unique($exceptions);
  }

  /**
   * {@inheritdoc}
   */
  protected function assertPostConditions() {

    // Execute registered Drupal shutdown functions prior to tearing down.
    // @see _drupal_shutdown_function()
    $callbacks =& drupal_register_shutdown_function();
    while ($callback = array_shift($callbacks)) {
      call_user_func_array($callback['callback'], $callback['arguments']);
    }

    // Shut down the kernel (if bootKernel() was called).
    // @see \Drupal\KernelTests\Core\DrupalKernel\DrupalKernelTest
    if ($this->container) {
      $this->container
        ->get('kernel')
        ->shutdown();
    }
    parent::assertPostConditions();
  }

  /**
   * {@inheritdoc}
   */
  protected function tearDown() {

    // Destroy the testing kernel.
    if (isset($this->kernel)) {
      $this->kernel
        ->shutdown();
    }

    // Remove all prefixed tables.
    $original_connection_info = Database::getConnectionInfo('simpletest_original_default');
    $original_prefix = $original_connection_info['default']['prefix'] ?? NULL;
    $test_connection_info = Database::getConnectionInfo('default');
    $test_prefix = $test_connection_info['default']['prefix'] ?? NULL;
    if ($original_prefix != $test_prefix) {
      $tables = Database::getConnection()
        ->schema()
        ->findTables('%');
      foreach ($tables as $table) {
        if (Database::getConnection()
          ->schema()
          ->dropTable($table)) {
          unset($tables[$table]);
        }
      }
    }

    // Free up memory: Own properties.
    $this->classLoader = NULL;
    $this->vfsRoot = NULL;
    $this->configImporter = NULL;

    // Free up memory: Custom test class properties.
    // Note: Private properties cannot be cleaned up.
    $rc = new \ReflectionClass(__CLASS__);
    $blacklist = [];
    foreach ($rc
      ->getProperties() as $property) {
      $blacklist[$property->name] = $property
        ->getDeclaringClass()->name;
    }
    $rc = new \ReflectionClass($this);
    foreach ($rc
      ->getProperties(\ReflectionProperty::IS_PUBLIC | \ReflectionProperty::IS_PROTECTED) as $property) {
      if (!$property
        ->isStatic() && !isset($blacklist[$property->name])) {
        $this->{$property->name} = NULL;
      }
    }

    // Clean FileCache cache.
    FileCache::reset();

    // Clean up statics, container, and settings.
    if (function_exists('drupal_static_reset')) {
      drupal_static_reset();
    }
    \Drupal::unsetContainer();
    $this->container = NULL;
    new Settings([]);
    parent::tearDown();
  }

  /**
   * @after
   *
   * Additional tear down method to close the connection at the end.
   */
  public function tearDownCloseDatabaseConnection() {

    // Destroy the database connection, which for example removes the memory
    // from sqlite in memory.
    foreach (Database::getAllConnectionInfo() as $key => $targets) {
      Database::removeConnection($key);
    }
  }

  /**
   * Installs default configuration for a given list of modules.
   *
   * @param string|string[] $modules
   *   A module or list of modules for which to install default configuration.
   *
   * @throws \LogicException
   *   If any module in $modules is not enabled.
   */
  protected function installConfig($modules) {
    foreach ((array) $modules as $module) {
      if (!$this->container
        ->get('module_handler')
        ->moduleExists($module)) {
        throw new \LogicException("{$module} module is not enabled.");
      }
      $this->container
        ->get('config.installer')
        ->installDefaultConfig('module', $module);
    }
  }

  /**
   * Installs database tables from a module schema definition.
   *
   * @param string $module
   *   The name of the module that defines the table's schema.
   * @param string|array $tables
   *   The name or an array of the names of the tables to install.
   *
   * @throws \LogicException
   *   If $module is not enabled or the table schema cannot be found.
   */
  protected function installSchema($module, $tables) {

    /** @var \Drupal\Core\Extension\ModuleHandlerInterface $module_handler */
    $module_handler = $this->container
      ->get('module_handler');

    // Database connection schema is technically able to create database tables
    // using any valid specification, for example of a non-enabled module. But
    // ability to load the module's .install file depends on many other factors.
    // To prevent differences in test behavior and non-reproducible test
    // failures, we only allow the schema of explicitly loaded/enabled modules
    // to be installed.
    if (!$module_handler
      ->moduleExists($module)) {
      throw new \LogicException("{$module} module is not enabled.");
    }
    $specification = SchemaInspector::getTablesSpecification($module_handler, $module);

    /** @var \Drupal\Core\Database\Schema $schema */
    $schema = $this->container
      ->get('database')
      ->schema();
    $tables = (array) $tables;
    foreach ($tables as $table) {

      // The tables key_value and key_value_expire are lazy loaded and therefore
      // no longer have to be created with the installSchema() method.
      // @see https://www.drupal.org/node/3143286
      if ($module === 'system' && in_array($table, [
        'key_value',
        'key_value_expire',
      ])) {
        @trigger_error('Installing the tables key_value and key_value_expire with the method KernelTestBase::installSchema() is deprecated in drupal:9.1.0 and is removed from drupal:10.0.0. The tables are now lazy loaded and therefore will be installed automatically when used. See https://www.drupal.org/node/3143286', E_USER_DEPRECATED);
        continue;
      }
      if (empty($specification[$table])) {
        throw new \LogicException("{$module} module does not define a schema for table '{$table}'.");
      }
      $schema
        ->createTable($table, $specification[$table]);
    }
  }

  /**
   * Installs the storage schema for a specific entity type.
   *
   * @param string $entity_type_id
   *   The ID of the entity type.
   */
  protected function installEntitySchema($entity_type_id) {
    $entity_type_manager = \Drupal::entityTypeManager();
    $entity_type = $entity_type_manager
      ->getDefinition($entity_type_id);
    \Drupal::service('entity_type.listener')
      ->onEntityTypeCreate($entity_type);

    // For test runs, the most common storage backend is a SQL database. For
    // this case, ensure the tables got created.
    $storage = $entity_type_manager
      ->getStorage($entity_type_id);
    if ($storage instanceof SqlEntityStorageInterface) {
      $tables = $storage
        ->getTableMapping()
        ->getTableNames();
      $db_schema = $this->container
        ->get('database')
        ->schema();
      foreach ($tables as $table) {
        $this
          ->assertTrue($db_schema
          ->tableExists($table), "The entity type table '{$table}' for the entity type '{$entity_type_id}' should exist.");
      }
    }
  }

  /**
   * Enables modules for this test.
   *
   * This method does not install modules fully. Services and hooks for the
   * module are available, but the install process is not performed.
   *
   * To install test modules outside of the testing environment, add
   * @code
   * $settings['extension_discovery_scan_tests'] = TRUE;
   * @endcode
   * to your settings.php.
   *
   * @param string[] $modules
   *   A list of modules to enable. Dependencies are not resolved; i.e.,
   *   multiple modules have to be specified individually. The modules are only
   *   added to the active module list and loaded; i.e., their database schema
   *   is not installed. hook_install() is not invoked. A custom module weight
   *   is not applied.
   *
   * @throws \LogicException
   *   If any module in $modules is already enabled.
   * @throws \RuntimeException
   *   If a module is not enabled after enabling it.
   */
  protected function enableModules(array $modules) {

    // Perform an ExtensionDiscovery scan as this function may receive a
    // profile that is not the current profile, and we don't yet have a cached
    // way to receive inactive profile information.
    // @todo Remove as part of https://www.drupal.org/node/2186491
    $listing = new ExtensionDiscovery($this->root);
    $module_list = $listing
      ->scan('module');

    // In ModuleHandlerTest we pass in a profile as if it were a module.
    $module_list += $listing
      ->scan('profile');

    // Set the list of modules in the extension handler.
    $module_handler = $this->container
      ->get('module_handler');

    // Write directly to active storage to avoid early instantiation of
    // the event dispatcher which can prevent modules from registering events.
    $active_storage = $this->container
      ->get('config.storage');
    $extension_config = $active_storage
      ->read('core.extension');
    foreach ($modules as $module) {
      if ($module_handler
        ->moduleExists($module)) {
        continue;
      }
      $module_handler
        ->addModule($module, $module_list[$module]
        ->getPath());

      // Maintain the list of enabled modules in configuration.
      $extension_config['module'][$module] = 0;
    }
    $active_storage
      ->write('core.extension', $extension_config);

    // Update the kernel to make their services available.
    $extensions = $module_handler
      ->getModuleList();
    $this->container
      ->get('kernel')
      ->updateModules($extensions, $extensions);

    // Ensure isLoaded() is TRUE in order to make
    // \Drupal\Core\Theme\ThemeManagerInterface::render() work.
    // Note that the kernel has rebuilt the container; this $module_handler is
    // no longer the $module_handler instance from above.
    $module_handler = $this->container
      ->get('module_handler');
    $module_handler
      ->reload();
    foreach ($modules as $module) {
      if (!$module_handler
        ->moduleExists($module)) {
        throw new \RuntimeException("{$module} module is not enabled after enabling it.");
      }
    }
  }

  /**
   * Disables modules for this test.
   *
   * @param string[] $modules
   *   A list of modules to disable. Dependencies are not resolved; i.e.,
   *   multiple modules have to be specified with dependent modules first.
   *   Code of previously enabled modules is still loaded. The modules are only
   *   removed from the active module list.
   *
   * @throws \LogicException
   *   If any module in $modules is already disabled.
   * @throws \RuntimeException
   *   If a module is not disabled after disabling it.
   */
  protected function disableModules(array $modules) {

    // Unset the list of modules in the extension handler.
    $module_handler = $this->container
      ->get('module_handler');
    $module_filenames = $module_handler
      ->getModuleList();
    $extension_config = $this
      ->config('core.extension');
    foreach ($modules as $module) {
      if (!$module_handler
        ->moduleExists($module)) {
        throw new \LogicException("{$module} module cannot be disabled because it is not enabled.");
      }
      unset($module_filenames[$module]);
      $extension_config
        ->clear('module.' . $module);
    }
    $extension_config
      ->save();
    $module_handler
      ->setModuleList($module_filenames);
    $module_handler
      ->resetImplementations();

    // Update the kernel to remove their services.
    $this->container
      ->get('kernel')
      ->updateModules($module_filenames, $module_filenames);

    // Ensure isLoaded() is TRUE in order to make
    // \Drupal\Core\Theme\ThemeManagerInterface::render() work.
    // Note that the kernel has rebuilt the container; this $module_handler is
    // no longer the $module_handler instance from above.
    $module_handler = $this->container
      ->get('module_handler');
    $module_handler
      ->reload();
    foreach ($modules as $module) {
      if ($module_handler
        ->moduleExists($module)) {
        throw new \RuntimeException("{$module} module is not disabled after disabling it.");
      }
    }
  }

  /**
   * Renders a render array.
   *
   * @param array $elements
   *   The elements to render.
   *
   * @return string
   *   The rendered string output (typically HTML).
   */
  protected function render(array &$elements) {

    // \Drupal\Core\Render\BareHtmlPageRenderer::renderBarePage calls out to
    // system_page_attachments() directly.
    if (!\Drupal::moduleHandler()
      ->moduleExists('system')) {
      throw new \Exception(__METHOD__ . ' requires system module to be installed.');
    }

    // Use the bare HTML page renderer to render our links.
    $renderer = $this->container
      ->get('bare_html_page_renderer');
    $response = $renderer
      ->renderBarePage($elements, '', 'maintenance_page');

    // Glean the content from the response object.
    $content = $response
      ->getContent();
    $this
      ->setRawContent($content);
    return $content;
  }

  /**
   * Sets an in-memory Settings variable.
   *
   * @param string $name
   *   The name of the setting to set.
   * @param bool|string|int|array|null $value
   *   The value to set. Note that array values are replaced entirely; use
   *   \Drupal\Core\Site\Settings::get() to perform custom merges.
   */
  protected function setSetting($name, $value) {
    $settings = Settings::getInstance() ? Settings::getAll() : [];
    $settings[$name] = $value;
    new Settings($settings);
  }

  /**
   * Sets the install profile and rebuilds the container to update it.
   *
   * @param string $profile
   *   The install profile to set.
   */
  protected function setInstallProfile($profile) {
    $this->container
      ->get('config.factory')
      ->getEditable('core.extension')
      ->set('profile', $profile)
      ->save();

    // The installation profile is provided by a container parameter. Saving
    // the configuration doesn't automatically trigger invalidation
    $this->container
      ->get('kernel')
      ->rebuildContainer();
  }

  /**
   * Stops test execution.
   */
  protected function stop() {
    $this
      ->getTestResultObject()
      ->stop();
  }

  /**
   * Dumps the current state of the virtual filesystem to STDOUT.
   */
  protected function vfsDump() {
    vfsStream::inspect(new vfsStreamPrintVisitor());
  }

  /**
   * Returns the modules to enable for this test.
   *
   * @param string $class
   *   The fully-qualified class name of this test.
   *
   * @return array
   */
  private static function getModulesToEnable($class) {
    $modules = [];
    while ($class) {
      if (property_exists($class, 'modules')) {

        // Only add the modules, if the $modules property was not inherited.
        $rp = new \ReflectionProperty($class, 'modules');
        if ($rp->class == $class) {
          $modules[$class] = $class::$modules;
        }
      }
      $class = get_parent_class($class);
    }

    // Modules have been collected in reverse class hierarchy order; modules
    // defined by base classes should be sorted first. Then, merge the results
    // together.
    $modules = array_values(array_reverse($modules));
    return call_user_func_array('array_merge_recursive', $modules);
  }

  /**
   * {@inheritdoc}
   */
  protected function prepareTemplate(\Text_Template $template) {
    $bootstrap_globals = '';

    // Fix missing bootstrap.php when $preserveGlobalState is FALSE.
    // @see https://github.com/sebastianbergmann/phpunit/pull/797
    $bootstrap_globals .= '$__PHPUNIT_BOOTSTRAP = ' . var_export($GLOBALS['__PHPUNIT_BOOTSTRAP'], TRUE) . ";\n";

    // Avoid repetitive test namespace discoveries to improve performance.
    // @see /core/tests/bootstrap.php
    $bootstrap_globals .= '$namespaces = ' . var_export($GLOBALS['namespaces'], TRUE) . ";\n";
    $template
      ->setVar([
      'constants' => '',
      'included_files' => '',
      'globals' => $bootstrap_globals,
    ]);
  }

  /**
   * Prevents serializing any properties.
   *
   * Kernel tests are run in a separate process. To do this PHPUnit creates a
   * script to run the test. If it fails, the test result object will contain a
   * stack trace which includes the test object. It will attempt to serialize
   * it. Returning an empty array prevents it from serializing anything it
   * should not.
   *
   * @return array
   *   An empty array.
   *
   * @see vendor/phpunit/phpunit/src/Util/PHP/Template/TestCaseMethod.tpl.dist
   */
  public function __sleep() {
    return [];
  }

}

Members

Name	Modifiers	Type	Description	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 the raw text IS NOT found escaped on the 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::getUrl	protected	function	Get the current URL from the cURL handler.	1
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.
AssertLegacyTrait::assert Deprecated	protected	function
AssertLegacyTrait::assertEqual Deprecated	protected	function
AssertLegacyTrait::assertIdentical Deprecated	protected	function
AssertLegacyTrait::assertIdenticalObject Deprecated	protected	function
AssertLegacyTrait::assertNotEqual Deprecated	protected	function
AssertLegacyTrait::assertNotIdentical Deprecated	protected	function
AssertLegacyTrait::pass Deprecated	protected	function
AssertLegacyTrait::verbose Deprecated	protected	function
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.
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.	7
KernelTestBase::$configSchemaCheckerExclusions	protected static	property	An array of config object names that are excluded from schema checking.
KernelTestBase::$container	protected	property
KernelTestBase::$databasePrefix	protected	property
KernelTestBase::$modules	protected static	property	Modules to enable.	457
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.	6
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	private	function	Bootstraps a kernel for a test.
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.
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.	3
KernelTestBase::getDatabasePrefix	public	function
KernelTestBase::getExtensionsForModules	private	function	Returns Extension objects for $modules to enable.
KernelTestBase::getModulesToEnable	private static	function	Returns the modules to enable 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::prepareTemplate	protected	function
KernelTestBase::register	public	function	Registers test-specific services. Overrides ServiceProviderInterface::register	24
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::setUp	protected	function		334
KernelTestBase::setUpBeforeClass	public static	function		1
KernelTestBase::setUpFilesystem	protected	function	Sets up the filesystem, so things like the file directory.	2
KernelTestBase::stop	protected	function	Stops test execution.
KernelTestBase::tearDown	protected	function		4
KernelTestBase::tearDownCloseDatabaseConnection	public	function	@after
KernelTestBase::vfsDump	protected	function	Dumps the current state of the virtual filesystem to STDOUT.
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::$randomGenerator	protected	property	The random generator.
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.	1
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	public	function	Callback for random string validation.
StorageCopyTrait::replaceStorageContents	protected static	function	Copy the configuration from one storage to another and remove stale items.
TestRequirementsTrait::checkModuleRequirements	private	function	Checks missing module requirements.
TestRequirementsTrait::checkRequirements	protected	function	Check module requirements for the Drupal use case.	1
TestRequirementsTrait::getDrupalRoot	protected static	function	Returns the Drupal root directory.