class Fixtures in Drupal 10

Convenience class for creating fixtures.

Hierarchy

• class \Drupal\Tests\Composer\Plugin\Scaffold\Fixtures

7 files declare their use of Fixtures

AppendOpTest.php in core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Integration/AppendOpTest.php

ComposerHookTest.php in core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Functional/ComposerHookTest.php

ManageGitIgnoreTest.php in core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Functional/ManageGitIgnoreTest.php

ReplaceOpTest.php in core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Integration/ReplaceOpTest.php

ScaffoldFileCollectionTest.php in core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Integration/ScaffoldFileCollectionTest.php

... See full list

File

core/tests/Drupal/Tests/Composer/Plugin/Scaffold/Fixtures.php, line 20

Namespace

Drupal\Tests\Composer\Plugin\Scaffold

class Fixtures {

  /**
   * Keep a persistent prefix to help group our tmp directories together.
   *
   * @var string
   */
  protected static $randomPrefix = '';

  /**
   * Directories to delete when we are done.
   *
   * @var string[]
   */
  protected $tmpDirs = [];

  /**
   * A Composer IOInterface to write to.
   *
   * @var \Composer\IO\IOInterface
   */
  protected $io;

  /**
   * The composer object.
   *
   * @var \Composer\Composer
   */
  protected $composer;

  /**
   * Gets an IO fixture.
   *
   * @return \Composer\IO\IOInterface
   *   A Composer IOInterface to write to; output may be retrieved via
   *   Fixtures::getOutput().
   */
  public function io() {
    if (!$this->io) {
      $this->io = new BufferIO();
    }
    return $this->io;
  }

  /**
   * Gets the Composer object.
   *
   * @return \Composer\Composer
   *   The main Composer object, needed by the scaffold Handler, etc.
   */
  public function getComposer() {
    if (!$this->composer) {
      $this->composer = Factory::create($this
        ->io(), NULL, TRUE);
    }
    return $this->composer;
  }

  /**
   * Gets the output from the io() fixture.
   *
   * @return string
   *   Output captured from tests that write to Fixtures::io().
   */
  public function getOutput() {
    return $this
      ->io()
      ->getOutput();
  }

  /**
   * Gets the path to Scaffold component.
   *
   * Used to inject the component into composer.json files.
   *
   * @return string
   *   Path to the root of this project.
   */
  public function projectRoot() {
    return realpath(__DIR__) . '/../../../../../../../composer/Plugin/Scaffold';
  }

  /**
   * Gets the path to the project fixtures.
   *
   * @return string
   *   Path to project fixtures
   */
  public function allFixturesDir() {
    return realpath(__DIR__ . '/fixtures');
  }

  /**
   * Gets the path to one particular project fixture.
   *
   * @param string $project_name
   *   The project name to get the path for.
   *
   * @return string
   *   Path to project fixture.
   */
  public function projectFixtureDir($project_name) {
    $dir = $this
      ->allFixturesDir() . '/' . $project_name;
    if (!is_dir($dir)) {
      throw new \RuntimeException("Requested fixture project {$project_name} that does not exist.");
    }
    return $dir;
  }

  /**
   * Gets the path to one particular bin path.
   *
   * @param string $bin_name
   *   The bin name to get the path for.
   *
   * @return string
   *   Path to project fixture.
   */
  public function binFixtureDir($bin_name) {
    $dir = $this
      ->allFixturesDir() . '/scripts/' . $bin_name;
    if (!is_dir($dir)) {
      throw new \RuntimeException("Requested fixture bin dir {$bin_name} that does not exist.");
    }
    return $dir;
  }

  /**
   * Gets a path to a source scaffold fixture.
   *
   * Use in place of ScaffoldFilePath::sourcePath().
   *
   * @param string $project_name
   *   The name of the project to fetch; $package_name is
   *   "fixtures/$project_name".
   * @param string $source
   *   The name of the asset; path is "assets/$source".
   *
   * @return \Drupal\Composer\Plugin\Scaffold\ScaffoldFilePath
   *   The full and relative path to the desired asset
   *
   * @see \Drupal\Composer\Plugin\Scaffold\ScaffoldFilePath::sourcePath()
   */
  public function sourcePath($project_name, $source) {
    $package_name = "fixtures/{$project_name}";
    $source_rel_path = "assets/{$source}";
    $package_path = $this
      ->projectFixtureDir($project_name);
    return ScaffoldFilePath::sourcePath($package_name, $package_path, 'unknown', $source_rel_path);
  }

  /**
   * Gets an Interpolator with 'web-root' and 'package-name' set.
   *
   * Use in place of ManageOptions::getLocationReplacements().
   *
   * @return \Drupal\Composer\Plugin\Scaffold\Interpolator
   *   An interpolator with location replacements, including 'web-root'.
   *
   * @see \Drupal\Composer\Plugin\Scaffold\ManageOptions::getLocationReplacements()
   */
  public function getLocationReplacements() {
    $destinationTmpDir = $this
      ->mkTmpDir('location-replacements');
    $interpolator = new Interpolator();
    $interpolator
      ->setData([
      'web-root' => $destinationTmpDir,
      'package-name' => 'fixtures/tmp-destination',
    ]);
    return $interpolator;
  }

  /**
   * Creates a ReplaceOp fixture.
   *
   * @param string $project_name
   *   The name of the project to fetch; $package_name is
   *   "fixtures/$project_name".
   * @param string $source
   *   The name of the asset; path is "assets/$source".
   *
   * @return \Drupal\Composer\Plugin\Scaffold\Operations\ReplaceOp
   *   A replace operation object.
   */
  public function replaceOp($project_name, $source) {
    $source_path = $this
      ->sourcePath($project_name, $source);
    return new ReplaceOp($source_path, TRUE);
  }

  /**
   * Creates an AppendOp fixture.
   *
   * @param string $project_name
   *   The name of the project to fetch; $package_name is
   *   "fixtures/$project_name".
   * @param string $source
   *   The name of the asset; path is "assets/$source".
   *
   * @return \Drupal\Composer\Plugin\Scaffold\Operations\AppendOp
   *   An append operation object.
   */
  public function appendOp($project_name, $source) {
    $source_path = $this
      ->sourcePath($project_name, $source);
    return new AppendOp(NULL, $source_path);
  }

  /**
   * Gets a destination path in a tmp dir.
   *
   * Use in place of ScaffoldFilePath::destinationPath().
   *
   * @param string $destination
   *   Destination path; should be in the form '[web-root]/robots.txt', where
   *   '[web-root]' is always literally '[web-root]', with any arbitrarily
   *   desired filename following.
   * @param \Drupal\Composer\Plugin\Scaffold\Interpolator $interpolator
   *   Location replacements. Obtain via Fixtures::getLocationReplacements()
   *   when creating multiple scaffold destinations.
   * @param string $package_name
   *   (optional) The name of the fixture package that this path came from.
   *   Taken from interpolator if not provided.
   *
   * @return \Drupal\Composer\Plugin\Scaffold\ScaffoldFilePath
   *   A destination scaffold file backed by temporary storage.
   *
   * @see \Drupal\Composer\Plugin\Scaffold\ScaffoldFilePath::destinationPath()
   */
  public function destinationPath($destination, Interpolator $interpolator = NULL, $package_name = NULL) {
    $interpolator = $interpolator ?: $this
      ->getLocationReplacements();
    $package_name = $package_name ?: $interpolator
      ->interpolate('[package-name]');
    return ScaffoldFilePath::destinationPath($package_name, $destination, $interpolator);
  }

  /**
   * Generates a path to a temporary location, but do not create the directory.
   *
   * @param string $prefix
   *   A prefix for the temporary directory name.
   *
   * @return string
   *   Path to temporary directory
   */
  public function tmpDir($prefix) {
    $prefix .= static::persistentPrefix();
    $tmpDir = sys_get_temp_dir() . '/scaffold-' . $prefix . uniqid(md5($prefix . microtime()), TRUE);
    $this->tmpDirs[] = $tmpDir;
    return $tmpDir;
  }

  /**
   * Generates a persistent prefix to use with all of our temporary directories.
   *
   * The presumption is that this should reduce collisions in highly-parallel
   * tests. We prepend the process id to play nicely with phpunit process
   * isolation.
   *
   * @return string
   *   A random string that will remain the same for the entire process run.
   */
  protected static function persistentPrefix() {
    if (empty(static::$randomPrefix)) {
      static::$randomPrefix = getmypid() . md5(microtime());
    }
    return static::$randomPrefix;
  }

  /**
   * Creates a temporary directory.
   *
   * @param string $prefix
   *   A prefix for the temporary directory name.
   *
   * @return string
   *   Path to temporary directory
   */
  public function mkTmpDir($prefix) {
    $tmpDir = $this
      ->tmpDir($prefix);
    $filesystem = new Filesystem();
    $filesystem
      ->ensureDirectoryExists($tmpDir);
    return $tmpDir;
  }

  /**
   * Create an isolated cache directory for Composer.
   */
  public function createIsolatedComposerCacheDir() {
    $cacheDir = $this
      ->mkTmpDir('composer-cache');
    putenv("COMPOSER_CACHE_DIR={$cacheDir}");
  }

  /**
   * Calls 'tearDown' in any test that copies fixtures to transient locations.
   */
  public function tearDown() {

    // Remove any temporary directories that were created.
    $filesystem = new Filesystem();
    foreach ($this->tmpDirs as $dir) {
      $filesystem
        ->remove($dir);
    }

    // Clear out variables from the previous pass.
    $this->tmpDirs = [];
    $this->io = NULL;

    // Clear the composer cache dir, if it was set
    putenv('COMPOSER_CACHE_DIR=');
  }

  /**
   * Creates a temporary copy of all of the fixtures projects into a temp dir.
   *
   * The fixtures remain dirty if they already exist. Individual tests should
   * first delete any fixture directory that needs to remain pristine. Since all
   * temporary directories are removed in tearDown, this is only an issue when
   * a) the FIXTURE_DIR environment variable has been set, or b) tests are
   * calling cloneFixtureProjects more than once per test method.
   *
   * @param string $fixturesDir
   *   The directory to place fixtures in.
   * @param array $replacements
   *   Key : value mappings for placeholders to replace in composer.json
   *   templates.
   */
  public function cloneFixtureProjects($fixturesDir, array $replacements = []) {
    $filesystem = new Filesystem();

    // We will replace 'SYMLINK' with the string 'true' in our composer.json
    // fixture.
    $replacements += [
      'SYMLINK' => 'true',
    ];
    $interpolator = new Interpolator('__', '__');
    $interpolator
      ->setData($replacements);
    $filesystem
      ->copy($this
      ->allFixturesDir(), $fixturesDir);
    $composer_json_templates = glob($fixturesDir . "/*/composer.json.tmpl");
    foreach ($composer_json_templates as $composer_json_tmpl) {

      // Inject replacements into composer.json.
      if (file_exists($composer_json_tmpl)) {
        $composer_json_contents = file_get_contents($composer_json_tmpl);
        $composer_json_contents = $interpolator
          ->interpolate($composer_json_contents, [], FALSE);
        file_put_contents(dirname($composer_json_tmpl) . "/composer.json", $composer_json_contents);
        @unlink($composer_json_tmpl);
      }
    }
  }

  /**
   * Runs the scaffold operation.
   *
   * This is equivalent to running `composer composer-scaffold`, but we do the
   * equivalent operation by instantiating a Handler object in order to continue
   * running in the same process, so that coverage may be calculated for the
   * code executed by these tests.
   *
   * @param string $cwd
   *   The working directory to run the scaffold command in.
   *
   * @return string
   *   Output captured from tests that write to Fixtures::io().
   */
  public function runScaffold($cwd) {
    chdir($cwd);
    $handler = new Handler($this
      ->getComposer(), $this
      ->io());
    $handler
      ->scaffold();
    return $this
      ->getOutput();
  }

  /**
   * Runs a `composer` command.
   *
   * @param string $cmd
   *   The Composer command to execute (escaped as required)
   * @param string $cwd
   *   The current working directory to run the command from.
   *
   * @return string
   *   Standard output and standard error from the command.
   */
  public function runComposer($cmd, $cwd) {
    chdir($cwd);
    $input = new StringInput($cmd);
    $output = new BufferedOutput();
    $application = new Application();
    $application
      ->setAutoExit(FALSE);
    $exitCode = $application
      ->run($input, $output);
    $output = $output
      ->fetch();
    if ($exitCode != 0) {
      throw new \Exception("Fixtures::runComposer failed to set up fixtures.\n\nCommand: '{$cmd}'\nExit code: {$exitCode}\nOutput: \n\n{$output}");
    }
    return $output;
  }

}