function ComposerProjectTemplatesTest::testTemplateCreateProject

@dataProvider provideTemplateCreateProject

File

core/tests/Drupal/BuildTests/Composer/Template/ComposerProjectTemplatesTest.php, line 177

Class

ComposerProjectTemplatesTest

Demonstrate that Composer project templates can be built as patched.

Namespace

Code

public function testTemplateCreateProject($project, $package_dir, $docroot_dir) : void {
  // Make a working COMPOSER_HOME directory for setting global composer config
  $composer_home = $this->getWorkspaceDirectory() . '/composer-home';
  mkdir($composer_home);
  // Create an empty global composer.json file, just to avoid warnings.
  file_put_contents("{$composer_home}/composer.json", '{}');
  // Disable packagist globally (but only in our own custom COMPOSER_HOME).
  // It is necessary to do this globally rather than in our SUT composer.json
  // in order to ensure that Packagist is disabled during the
  // `composer create-project` command.
  $this->executeCommand("COMPOSER_HOME={$composer_home} composer config --no-interaction --global repo.packagist false");
  $this->assertCommandSuccessful();
  // Create a "Composer"-type repository containing one entry for every
  // package in the vendor directory.
  $vendor_packages_path = $this->getWorkspaceDirectory() . '/vendor_packages/packages.json';
  $this->makeVendorPackage($vendor_packages_path);
  // Make a copy of the code to alter in the workspace directory.
  $this->copyCodebase();
  // Tests are typically run on "-dev" versions, but we want to simulate
  // running them on a tagged release at the same stability as specified in
  // static::MINIMUM_STABILITY, in order to verify that everything will work
  // if/when we make such a release.
  $simulated_core_version = \Drupal::VERSION;
  $simulated_core_version_suffix = static::MINIMUM_STABILITY === 'stable' ? '' : '-' . static::MINIMUM_STABILITY . '99';
  $simulated_core_version = str_replace('-dev', $simulated_core_version_suffix, $simulated_core_version);
  Composer::setDrupalVersion($this->getWorkspaceDirectory(), $simulated_core_version);
  $this->assertDrupalVersion($simulated_core_version, $this->getWorkspaceDirectory());
  // Remove the packages.drupal.org entry (and any other custom repository)
  // from the SUT's repositories section. There is no way to do this via
  // `composer config --unset`, so we read and rewrite composer.json.
  $composer_json_path = $this->getWorkspaceDirectory() . "/{$package_dir}/composer.json";
  $composer_json = json_decode(file_get_contents($composer_json_path), TRUE);
  unset($composer_json['repositories']);
  $json = json_encode($composer_json, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
  file_put_contents($composer_json_path, $json);
  // Set up the template to use our path repos. Inclusion of metapackages is
  // reported differently, so we load up a separate set for them.
  $metapackage_path_repos = $this->getPathReposForType($this->getWorkspaceDirectory(), 'Metapackage');
  $this->assertArrayHasKey('drupal/core-recommended', $metapackage_path_repos);
  $path_repos = array_merge($metapackage_path_repos, $this->getPathReposForType($this->getWorkspaceDirectory(), 'Plugin'));
  // Always add drupal/core as a path repo.
  $path_repos['drupal/core'] = $this->getWorkspaceDirectory() . '/core';
  foreach ($path_repos as $name => $path) {
    $this->executeCommand("composer config --no-interaction repositories.{$name} path {$path}", $package_dir);
    $this->assertCommandSuccessful();
  }
  // Change drupal/core-recommended to require the simulated version of
  // drupal/core.
  $core_recommended_dir = 'composer/Metapackage/CoreRecommended';
  $this->executeCommand("composer remove --no-interaction drupal/core --no-update", $core_recommended_dir);
  $this->assertCommandSuccessful();
  $this->executeCommand("composer require --no-interaction drupal/core:^{$simulated_core_version} --no-update", $core_recommended_dir);
  $this->assertCommandSuccessful();
  // Add our vendor package repository to our SUT's repositories section.
  // Call it "local" (although the name does not matter).
  $this->executeCommand("composer config --no-interaction repositories.local composer file://" . $vendor_packages_path, $package_dir);
  $this->assertCommandSuccessful();
  $repository_path = $this->getWorkspaceDirectory() . '/test_repository/packages.json';
  $this->makeTestPackage($repository_path, $simulated_core_version);
  $installed_composer_json = $this->getWorkspaceDirectory() . '/test_project/composer.json';
  $autoloader = $this->getWorkspaceDirectory() . '/test_project' . $docroot_dir . '/autoload.php';
  $this->assertFileDoesNotExist($autoloader);
  $this->executeCommand("COMPOSER_HOME={$composer_home} COMPOSER_ROOT_VERSION={$simulated_core_version} composer create-project --no-ansi {$project} test_project {$simulated_core_version} -vvv --repository {$repository_path}");
  $this->assertCommandSuccessful();
  // Check the output of the project creation for the absence of warnings
  // about any non-allowed composer plugins.
  // Note: There are different warnings for disallowed composer plugins
  // depending on running in non-interactive mode or not. It seems the Drupal
  // CI environment always forces composer commands to run in the
  // non-interactive mode. The only thing these messages have in common is the
  // following string.
  $this->assertErrorOutputNotContains('See https://getcomposer.org/allow-plugins');
  // Ensure we used the project from our codebase.
  $this->assertErrorOutputContains("Installing {$project} ({$simulated_core_version}): Symlinking from {$package_dir}");
  // Ensure that we used drupal/core from our codebase. This probably means
  // that drupal/core-recommended was added successfully by the project.
  $this->assertErrorOutputContains("Installing drupal/core ({$simulated_core_version}): Symlinking from");
  // Verify that there is an autoloader. This is written by the scaffold
  // plugin, so its existence assures us that scaffolding happened.
  $this->assertFileExists($autoloader);
  // Verify that the minimum stability in the installed composer.json file
  // matches the stability of the simulated core version.
  $this->assertFileExists($installed_composer_json);
  $composer_json_contents = file_get_contents($installed_composer_json);
  $this->assertStringContainsString('"minimum-stability": "' . static::MINIMUM_STABILITY . '"', $composer_json_contents);
  // In order to verify that Composer used the path repos for our project, we
  // have to get the requirements from the project composer.json so we can
  // reconcile our expectations.
  $template_json_file = $this->getWorkspaceDirectory() . '/' . $package_dir . '/composer.json';
  $this->assertFileExists($template_json_file);
  $json_file = new JsonFile($template_json_file);
  $template_json = $json_file->read();
  // Get the require and require-dev information, and ensure that our
  // requirements are not erroneously empty.
  $this->assertNotEmpty($require = array_merge($template_json['require'] ?? [], $template_json['require-dev'] ?? []));
  // Verify that path repo packages were installed.
  $path_repos = array_keys($path_repos);
  foreach (array_keys($require) as $package_name) {
    if (in_array($package_name, $path_repos)) {
      // Metapackages do not report that they were installed as symlinks, but
      // we still must check that their installed version matches
      // COMPOSER_CORE_VERSION.
      if (array_key_exists($package_name, $metapackage_path_repos)) {
        $this->assertErrorOutputContains("Installing {$package_name} ({$simulated_core_version})");
      }
      else {
        $this->assertErrorOutputContains("Installing {$package_name} ({$simulated_core_version}): Symlinking from");
      }
    }
  }
}