automatic_updates.services.yml

@@ -4,7 +4,7 @@ services:
     arguments: ['@keyvalue.expirable', '@datetime.time', 24]
   automatic_updates.updater:
     class: Drupal\automatic_updates\Updater
-    arguments: ['@state', '@string_translation','@automatic_updates.beginner', '@automatic_updates.stager', '@automatic_updates.cleaner', '@automatic_updates.committer', '@event_dispatcher', '@config.factory']
+    arguments: ['@state', '@string_translation','@automatic_updates.beginner', '@automatic_updates.stager', '@automatic_updates.cleaner', '@automatic_updates.committer', '@event_dispatcher', '@automatic_updates.path_locator']
   automatic_updates.beginner:
     class: PhpTuf\ComposerStager\Domain\Beginner
     arguments:
@@ -14,9 +14,11 @@ services:
     arguments:
       ['@automatic_updates.composer_runner', '@automatic_updates.file_system' ]
   automatic_updates.cleaner:
-    class: PhpTuf\ComposerStager\Domain\Cleaner
+    class: Drupal\automatic_updates\ComposerStager\Cleaner
     arguments:
-      ['@automatic_updates.file_system' ]
+      - '@automatic_updates.file_system'
+      - '%site.path%'
+      - '@automatic_updates.path_locator'
   automatic_updates.committer:
     class: PhpTuf\ComposerStager\Domain\Committer
     arguments:
@@ -73,7 +75,7 @@ services:
       - { name: event_subscriber }
   automatic_updates.staged_projects_validator:
     class: Drupal\automatic_updates\Validator\StagedProjectsValidator
-    arguments: [ '@string_translation', '@automatic_updates.updater' ]
+    arguments: ['@string_translation', '@automatic_updates.path_locator']
     tags:
       - { name: event_subscriber }
   automatic_updates.update_version_validator:
@@ -83,6 +85,11 @@ services:
       - { name: event_subscriber }
   automatic_updates.composer_executable_validator:
     class: Drupal\automatic_updates\Validator\ComposerExecutableValidator
-    arguments: ['@automatic_updates.exec_finder']
+    arguments: ['@automatic_updates.composer_runner']
     tags:
       - { name: event_subscriber }
+  automatic_updates.path_locator:
+    class: Drupal\automatic_updates\PathLocator
+    arguments:
+      - '@config.factory'
+      - '%app.root%'

src/ComposerStager/Cleaner.php

+<?php
+
+namespace Drupal\automatic_updates\ComposerStager;
+
+use Drupal\automatic_updates\PathLocator;
+use PhpTuf\ComposerStager\Domain\Cleaner as ComposerStagerCleaner;
+use PhpTuf\ComposerStager\Domain\CleanerInterface;
+use PhpTuf\ComposerStager\Domain\Output\ProcessOutputCallbackInterface;
+use PhpTuf\ComposerStager\Infrastructure\Filesystem\FilesystemInterface;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * Defines a cleaner service that makes the staged site directory writable.
+ */
+class Cleaner implements CleanerInterface {
+
+  /**
+   * The decorated cleaner service.
+   *
+   * @var \PhpTuf\ComposerStager\Domain\CleanerInterface
+   */
+  protected $decorated;
+
+  /**
+   * The current site path, without leading or trailing slashes.
+   *
+   * @var string
+   */
+  protected $sitePath;
+
+  /**
+   * The path locator service.
+   *
+   * @var \Drupal\automatic_updates\PathLocator
+   */
+  protected $pathLocator;
+
+  /**
+   * Constructs a Cleaner object.
+   *
+   * @param \PhpTuf\ComposerStager\Infrastructure\Filesystem\FilesystemInterface $file_system
+   *   The Composer Stager file system service.
+   * @param string $site_path
+   *   The current site path (e.g., 'sites/default'), without leading or
+   *   trailing slashes.
+   * @param \Drupal\automatic_updates\PathLocator $locator
+   *   The path locator service.
+   */
+  public function __construct(FilesystemInterface $file_system, string $site_path, PathLocator $locator) {
+    // @todo Inject the decorated cleaner once the Composer Stager wiring has
+    // been moved into a separate module.
+    $this->decorated = new ComposerStagerCleaner($file_system);
+    $this->sitePath = $site_path;
+    $this->pathLocator = $locator;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function clean(string $stagingDir, ?ProcessOutputCallbackInterface $callback = NULL, ?int $timeout = 120): void {
+    // Ensure that the staged site directory is writable so we can delete it.
+    $site_dir = implode(DIRECTORY_SEPARATOR, [
+      $stagingDir,
+      $this->pathLocator->getWebRoot() ?: '.',
+      $this->sitePath,
+    ]);
+
+    if ($this->directoryExists($site_dir)) {
+      (new Filesystem())->chmod($site_dir, 0777);
+    }
+    $this->decorated->clean($stagingDir, $callback, $timeout);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function directoryExists(string $stagingDir): bool {
+    return $this->decorated->directoryExists($stagingDir);
+  }
+
+}

src/PathLocator.php

+<?php
+
+namespace Drupal\automatic_updates;
+
+use Composer\Autoload\ClassLoader;
+use Drupal\Component\FileSystem\FileSystem;
+use Drupal\Core\Config\ConfigFactoryInterface;
+
+/**
+ * Computes file system paths that are needed for automatic updates.
+ */
+class PathLocator {
+
+  /**
+   * The config factory service.
+   *
+   * @var \Drupal\Core\Config\ConfigFactoryInterface
+   */
+  protected $configFactory;
+
+  /**
+   * The absolute path of the running Drupal code base.
+   *
+   * @var string
+   */
+  protected $appRoot;
+
+  /**
+   * Constructs a PathLocator object.
+   *
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
+   *   The config factory service.
+   * @param string $app_root
+   *   The absolute path of the running Drupal code base.
+   */
+  public function __construct(ConfigFactoryInterface $config_factory, string $app_root) {
+    $this->configFactory = $config_factory;
+    $this->appRoot = $app_root;
+  }
+
+  /**
+   * Returns the path of the active directory, which should be updated.
+   *
+   * @return string
+   *   The absolute path which should be updated.
+   */
+  public function getActiveDirectory(): string {
+    return $this->getProjectRoot();
+  }
+
+  /**
+   * Returns the path of the directory where updates should be staged.
+   *
+   * This directory may be made world-writeable for clean-up, so it should be
+   * somewhere that doesn't put the Drupal installation at risk.
+   *
+   * @return string
+   *   The absolute path of the directory where updates should be staged.
+   *
+   * @see \Drupal\automatic_updates\ComposerStager\Cleaner::clean()
+   */
+  public function getStageDirectory(): string {
+    // Append the site ID to the directory in order to support parallel test
+    // runs, or multiple sites hosted on the same server.
+    $site_id = $this->configFactory->get('system.site')->get('uuid');
+    return FileSystem::getOsTemporaryDirectory() . DIRECTORY_SEPARATOR . '.automatic_updates_stage_' . $site_id;
+  }
+
+  /**
+   * Returns the absolute path of the project root.
+   *
+   * This is where the project-level composer.json should normally be found, and
+   * may or may not be the same path as the Drupal code base.
+   *
+   * @return string
+   *   The absolute path of the project root.
+   */
+  public function getProjectRoot(): string {
+    // Assume that the vendor directory is immediately below the project root.
+    return realpath($this->getVendorDirectory() . DIRECTORY_SEPARATOR . '..');
+  }
+
+  /**
+   * Returns the absolute path of the vendor directory.
+   *
+   * @return string
+   *   The absolute path of the vendor directory.
+   */
+  public function getVendorDirectory(): string {
+    $reflector = new \ReflectionClass(ClassLoader::class);
+    return dirname($reflector->getFileName(), 2);
+  }
+
+  /**
+   * Returns the path of the Drupal installation, relative to the project root.
+   *
+   * @return string
+   *   The path of the Drupal installation, relative to the project root and
+   *   without leading or trailing slashes. Will return an empty string if the
+   *   project root and Drupal root are the same.
+   */
+  public function getWebRoot(): string {
+    $web_root = str_replace($this->getProjectRoot(), NULL, $this->appRoot);
+    return trim($web_root, DIRECTORY_SEPARATOR);
+  }
+
+}

src/Updater.php

@@ -2,14 +2,11 @@
 
 namespace Drupal\automatic_updates;
 
-use Composer\Autoload\ClassLoader;
 use Drupal\automatic_updates\Event\PreCommitEvent;
 use Drupal\automatic_updates\Event\PreStartEvent;
 use Drupal\automatic_updates\Event\UpdateEvent;
 use Drupal\automatic_updates\Exception\UpdateException;
-use Drupal\Component\FileSystem\FileSystem;
 use Drupal\Component\Serialization\Json;
-use Drupal\Core\Config\ConfigFactoryInterface;
 use Drupal\Core\State\StateInterface;
 use Drupal\Core\StringTranslation\StringTranslationTrait;
 use Drupal\Core\StringTranslation\TranslationInterface;
@@ -77,11 +74,11 @@ class Updater {
   protected $eventDispatcher;
 
   /**
-   * The config factory service.
+   * The path locator service.
    *
-   * @var \Drupal\Core\Config\ConfigFactoryInterface
+   * @var \Drupal\automatic_updates\PathLocator
    */
-  protected $configFactory;
+  protected $pathLocator;
 
   /**
    * Constructs an Updater object.
@@ -100,10 +97,10 @@ class Updater {
    *   The Composer Stager's committer service.
    * @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $event_dispatcher
    *   The event dispatcher service.
-   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
-   *   The config factory service.
+   * @param \Drupal\automatic_updates\PathLocator $path_locator
+   *   The path locator service.
    */
-  public function __construct(StateInterface $state, TranslationInterface $translation, BeginnerInterface $beginner, StagerInterface $stager, CleanerInterface $cleaner, CommitterInterface $committer, EventDispatcherInterface $event_dispatcher, ConfigFactoryInterface $config_factory) {
+  public function __construct(StateInterface $state, TranslationInterface $translation, BeginnerInterface $beginner, StagerInterface $stager, CleanerInterface $cleaner, CommitterInterface $committer, EventDispatcherInterface $event_dispatcher, PathLocator $path_locator) {
     $this->state = $state;
     $this->beginner = $beginner;
     $this->stager = $stager;
@@ -111,31 +108,7 @@ class Updater {
     $this->committer = $committer;
     $this->setStringTranslation($translation);
     $this->eventDispatcher = $event_dispatcher;
-    $this->configFactory = $config_factory;
-  }
-
-  /**
-   * Gets the vendor directory.
-   *
-   * @return string
-   *   The absolute path for vendor directory.
-   */
-  private static function getVendorDirectory(): string {
-    $class_loader_reflection = new \ReflectionClass(ClassLoader::class);
-    return dirname($class_loader_reflection->getFileName(), 2);
-  }
-
-  /**
-   * Gets the stage directory.
-   *
-   * @return string
-   *   The absolute path for stage directory.
-   */
-  public function getStageDirectory(): string {
-    // Append the site ID to the directory in order to support parallel test
-    // runs, or multiple sites hosted on the same server.
-    $site_id = $this->configFactory->get('system.site')->get('uuid');
-    return FileSystem::getOsTemporaryDirectory() . '/.automatic_updates_stage_' . $site_id;
+    $this->pathLocator = $path_locator;
   }
 
   /**
@@ -145,23 +118,13 @@ class Updater {
    *   TRUE if there is active update, otherwise FALSE.
    */
   public function hasActiveUpdate(): bool {
-    $staged_dir = $this->getStageDirectory();
+    $staged_dir = $this->pathLocator->getStageDirectory();
     if (is_dir($staged_dir) || $this->state->get(static::STATE_KEY)) {
       return TRUE;
     }
     return FALSE;
   }
 
-  /**
-   * Gets the active directory.
-   *
-   * @return string
-   *   The absolute path for active directory.
-   */
-  public function getActiveDirectory(): string {
-    return realpath(static::getVendorDirectory() . '/..');
-  }
-
   /**
    * Begins the update.
    *
@@ -184,7 +147,7 @@ class Updater {
     $stage_key = $this->createActiveStage($packages);
     /** @var \Drupal\automatic_updates\Event\PreStartEvent $event */
     $event = $this->dispatchUpdateEvent(new PreStartEvent($packages), AutomaticUpdatesEvents::PRE_START);
-    $this->beginner->begin(static::getActiveDirectory(), static::getStageDirectory(), $this->getExclusions($event));
+    $this->beginner->begin($this->pathLocator->getActiveDirectory(), $this->pathLocator->getStageDirectory(), $this->getExclusions($event));
     return $stage_key;
   }
 
@@ -210,7 +173,7 @@ class Updater {
    *   detecting the core package.
    */
   public function getCorePackageName(): string {
-    $composer = realpath(static::getVendorDirectory() . '/../composer.json');
+    $composer = realpath($this->pathLocator->getProjectRoot() . '/composer.json');
 
     if (empty($composer) || !file_exists($composer)) {
       throw new \RuntimeException("Could not find project-level composer.json");
@@ -239,7 +202,7 @@ class Updater {
    */
   private function getExclusions($event): array {
     $make_relative = function (string $path): string {
-      return str_replace($this->getActiveDirectory() . '/', '', $path);
+      return str_replace($this->pathLocator->getActiveDirectory() . '/', '', $path);
     };
     return array_map($make_relative, $event->getExcludedPaths());
   }
@@ -270,15 +233,16 @@ class Updater {
   public function commit(): void {
     /** @var \Drupal\automatic_updates\Event\PreCommitEvent $event */
     $event = $this->dispatchUpdateEvent(new PreCommitEvent(), AutomaticUpdatesEvents::PRE_COMMIT);
-    $this->committer->commit($this->getStageDirectory(), static::getActiveDirectory(), $this->getExclusions($event));
+    $this->committer->commit($this->pathLocator->getStageDirectory(), $this->pathLocator->getActiveDirectory(), $this->getExclusions($event));
   }
 
   /**
    * Cleans the current update.
    */
   public function clean(): void {
-    if (is_dir($this->getStageDirectory())) {
-      $this->cleaner->clean($this->getStageDirectory());
+    $stage_dir = $this->pathLocator->getStageDirectory();
+    if (is_dir($stage_dir)) {
+      $this->cleaner->clean($stage_dir);
     }
     $this->state->delete(static::STATE_KEY);
   }
@@ -293,7 +257,7 @@ class Updater {
    * @see \PhpTuf\ComposerStager\Domain\StagerInterface::stage()
    */
   protected function stageCommand(array $command): void {
-    $this->stager->stage($command, $this->getStageDirectory());
+    $this->stager->stage($command, $this->pathLocator->getStageDirectory());
   }
 
   /**

src/Validator/ComposerExecutableValidator.php

@@ -5,30 +5,42 @@ namespace Drupal\automatic_updates\Validator;
 use Drupal\automatic_updates\AutomaticUpdatesEvents;
 use Drupal\automatic_updates\Event\UpdateEvent;
 use Drupal\automatic_updates\Validation\ValidationResult;
-use PhpTuf\ComposerStager\Exception\IOException;
-use PhpTuf\ComposerStager\Infrastructure\Process\ExecutableFinderInterface;
+use Drupal\Core\Extension\ExtensionVersion;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use PhpTuf\ComposerStager\Domain\Output\ProcessOutputCallbackInterface;
+use PhpTuf\ComposerStager\Exception\ExceptionInterface;
+use PhpTuf\ComposerStager\Infrastructure\Process\Runner\ComposerRunnerInterface;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 
 /**
- * Validates that the Composer executable can be found.
+ * Validates that the Composer executable can be found in the correct version.
  */
-class ComposerExecutableValidator implements EventSubscriberInterface {
+class ComposerExecutableValidator implements EventSubscriberInterface, ProcessOutputCallbackInterface {
+
+  use StringTranslationTrait;
+
+  /**
+   * The Composer runner.
+   *
+   * @var \PhpTuf\ComposerStager\Infrastructure\Process\Runner\ComposerRunnerInterface
+   */
+  protected $composer;
 
   /**
-   * The executable finder service.
+   * The detected version of Composer.
    *
-   * @var \PhpTuf\ComposerStager\Infrastructure\Process\ExecutableFinderInterface
+   * @var string
    */
-  protected $executableFinder;
+  protected $version;
 
   /**
    * Constructs a ComposerExecutableValidator object.
    *
-   * @param \PhpTuf\ComposerStager\Infrastructure\Process\ExecutableFinderInterface $executable_finder
-   *   The executable finder service.
+   * @param \PhpTuf\ComposerStager\Infrastructure\Process\Runner\ComposerRunnerInterface $composer
+   *   The Composer runner.
    */
-  public function __construct(ExecutableFinderInterface $executable_finder) {
-    $this->executableFinder = $executable_finder;
+  public function __construct(ComposerRunnerInterface $composer) {
+    $this->composer = $composer;
   }
 
   /**
@@ -39,13 +51,34 @@ class ComposerExecutableValidator implements EventSubscriberInterface {
    */
   public function checkForComposerExecutable(UpdateEvent $event): void {
     try {
-      $this->executableFinder->find('composer');
+      $this->composer->run(['--version'], $this);
     }
-    catch (IOException $e) {
+    catch (ExceptionInterface $e) {
       $error = ValidationResult::createError([
         $e->getMessage(),
       ]);
       $event->addValidationResult($error);
+      return;
+    }
+
+    if ($this->version) {
+      $major_version = ExtensionVersion::createFromVersionString($this->version)
+        ->getMajorVersion();
+
+      if ($major_version < 2) {
+        $error = ValidationResult::createError([
+          $this->t('Composer 2 or later is required, but version @version was detected.', [
+            '@version' => $this->version,
+          ]),
+        ]);
+        $event->addValidationResult($error);
+      }
+    }
+    else {
+      $error = ValidationResult::createError([
+        $this->t('The Composer version could not be detected.'),
+      ]);
+      $event->addValidationResult($error);
     }
   }
 
@@ -58,4 +91,15 @@ class ComposerExecutableValidator implements EventSubscriberInterface {
     ];
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function __invoke(string $type, string $buffer): void {
+    $matched = [];
+    // Search for a semantic version number and optional stability flag.
+    if (preg_match('/([0-9]+\.?){3}-?((alpha|beta|rc)[0-9]*)?/i', $buffer, $matched)) {
+      $this->version = $matched[0];
+    }
+  }
+
 }

src/Validator/StagedProjectsValidator.php

@@ -5,7 +5,7 @@ namespace Drupal\automatic_updates\Validator;
 use Drupal\automatic_updates\AutomaticUpdatesEvents;
 use Drupal\automatic_updates\Event\UpdateEvent;
 use Drupal\automatic_updates\Exception\UpdateException;
-use Drupal\automatic_updates\Updater;
+use Drupal\automatic_updates\PathLocator;
 use Drupal\automatic_updates\Validation\ValidationResult;
 use Drupal\Component\Serialization\Json;
 use Drupal\Core\StringTranslation\StringTranslationTrait;
@@ -20,23 +20,23 @@ final class StagedProjectsValidator implements EventSubscriberInterface {
   use StringTranslationTrait;
 
   /**
-   * The updater service.
+   * The path locator service.
    *
-   * @var \Drupal\automatic_updates\Updater
+   * @var \Drupal\automatic_updates\PathLocator
    */
-  protected $updater;
+  protected $pathLocator;
 
   /**
    * Constructs a StagedProjectsValidation object.
    *
    * @param \Drupal\Core\StringTranslation\TranslationInterface $translation
    *   The translation service.
-   * @param \Drupal\automatic_updates\Updater $updater
-   *   The updater service.
+   * @param \Drupal\automatic_updates\PathLocator $path_locator
+   *   The path locator service.
    */
-  public function __construct(TranslationInterface $translation, Updater $updater) {
+  public function __construct(TranslationInterface $translation, PathLocator $path_locator) {
     $this->setStringTranslation($translation);
-    $this->updater = $updater;
+    $this->pathLocator = $path_locator;
   }
 
   /**
@@ -87,8 +87,8 @@ final class StagedProjectsValidator implements EventSubscriberInterface {
    */
   public function validateStagedProjects(UpdateEvent $event): void {
     try {
-      $active_packages = $this->getDrupalPackagesFromLockFile($this->updater->getActiveDirectory() . "/composer.lock");
-      $staged_packages = $this->getDrupalPackagesFromLockFile($this->updater->getStageDirectory() . "/composer.lock");
+      $active_packages = $this->getDrupalPackagesFromLockFile($this->pathLocator->getActiveDirectory() . "/composer.lock");
+      $staged_packages = $this->getDrupalPackagesFromLockFile($this->pathLocator->getStageDirectory() . "/composer.lock");
     }
     catch (UpdateException $e) {
       foreach ($e->getValidationResults() as $result) {

tests/modules/automatic_updates_test/src/AutomaticUpdatesTestServiceProvider.php

-<?php
-
-namespace Drupal\automatic_updates_test;
-
-use Drupal\Core\DependencyInjection\ContainerBuilder;
-use Drupal\Core\DependencyInjection\ServiceProviderBase;
-
-/**
- * Modifies service definitions for testing purposes.
- */
-class AutomaticUpdatesTestServiceProvider extends ServiceProviderBase {
-
-  /**
-   * {@inheritdoc}
-   */
-  public function alter(ContainerBuilder $container) {
-    parent::alter($container);
-
-    $service = 'automatic_updates.updater';
-    if ($container->hasDefinition($service)) {
-      $container->getDefinition($service)->setClass(TestUpdater::class);
-    }
-  }
-
-}

tests/modules/automatic_updates_test/src/TestUpdater.php

-<?php
-
-namespace Drupal\automatic_updates_test;
-
-use Drupal\automatic_updates\Updater;
-
-/**
- * A testing updater that allows arbitrary active and stage directories.
- */
-class TestUpdater extends Updater {
-
-  /**
-   * The active directory to use, if different from the default.
-   *
-   * @var string
-   */
-  public $activeDirectory;
-
-  /**
-   * The stage directory to use, if different from the default.
-   *
-   * @var string
-   */
-  public $stageDirectory;
-
-  /**
-   * {@inheritdoc}
-   */
-  public function getActiveDirectory(): string {
-    return $this->activeDirectory ?: parent::getActiveDirectory();
-  }
-
-  /**
-   * {@inheritdoc}
-   */
-  public function getStageDirectory(): string {
-    return $this->stageDirectory ?: parent::getStageDirectory();
-  }
-
-}

tests/src/Functional/ExclusionsTest.php

-<?php
-
-namespace Drupal\Tests\automatic_updates\Functional;
-
-use Drupal\Core\Site\Settings;
-use Drupal\Tests\BrowserTestBase;
-
-/**
- * Tests exclusion of certain files and directories from the staging area.
- *
- * @group automatic_updates
- */
-class ExclusionsTest extends BrowserTestBase {
-
-  /**
-   * {@inheritdoc}
-   */
-  protected static $modules = ['automatic_updates_test', 'update_test'];
-
-  /**
-   * {@inheritdoc}
-   */
-  protected $defaultTheme = 'stark';
-
-  /**
-   * Tests that certain files and directories are not staged.
-   *
-   * @covers \Drupal\automatic_updates\Updater::getExclusions
-   */
-  public function testExclusions(): void {
-    $stage_dir = "$this->siteDirectory/stage";
-
-    /** @var \Drupal\automatic_updates_test\TestUpdater $updater */
-    $updater = $this->container->get('automatic_updates.updater');
-    $updater->activeDirectory = __DIR__ . '/../../fixtures/fake-site';
-    $updater->stageDirectory = $stage_dir;
-
-    $settings = Settings::getAll();
-    $settings['file_public_path'] = 'files/public';
-    $settings['file_private_path'] = 'files/private';
-    new Settings($settings);
-
-    // Updater::begin() will trigger update validators, such as
-    // \Drupal\automatic_updates\Event\UpdateVersionSubscriber, that need to
-    // fetch release metadata. We need to ensure that those HTTP request(s)
-    // succeed, so set them up to point to our fake release metadata.
-    $this->config('update_test.settings')
-      ->set('xml_map', [
-        'drupal' => '0.0',
-      ])
-      ->save();
-    $this->config('update.settings')
-      ->set('fetch.url', $this->baseUrl . '/automatic-update-test')
-      ->save();
-    $this->config('update_test.settings')
-      ->set('system_info.#all.version', '9.8.0')
-      ->save();
-
-    $updater->begin(['drupal' => '9.8.1']);
-    $this->assertFileDoesNotExist("$stage_dir/sites/default/settings.php");
-    $this->assertFileDoesNotExist("$stage_dir/sites/default/settings.local.php");
-    $this->assertFileDoesNotExist("$stage_dir/sites/default/services.yml");
-    // A file in sites/default, that isn't one of the site-specific settings
-    // files, should be staged.
-    $this->assertFileExists("$stage_dir/sites/default/staged.txt");
-    $this->assertDirectoryDoesNotExist("$stage_dir/sites/simpletest");
-    $this->assertDirectoryDoesNotExist("$stage_dir/files/public");
-    $this->assertDirectoryDoesNotExist("$stage_dir/files/private");
-    // A file that's in the general files directory, but not in the public or
-    // private directories, should be staged.
-    $this->assertFileExists("$stage_dir/files/staged.txt");
-  }
-
-}

tests/src/Functional/FileSystemOperationsTest.php

+<?php
+
+namespace Drupal\Tests\automatic_updates\Functional;
+
+use Drupal\automatic_updates\ComposerStager\Cleaner;
+use Drupal\automatic_updates\PathLocator;
+use Drupal\automatic_updates\Updater;
+use Drupal\Core\Site\Settings;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests handling of files and directories during an update.
+ *
+ * @group automatic_updates
+ */
+class FileSystemOperationsTest extends BrowserTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['automatic_updates_test', 'update_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * The updater service under test.
+   *
+   * @var \Drupal\automatic_updates\Updater
+   */
+  private $updater;
+
+  /**
+   * The full path of the staging directory.
+   *
+   * @var string
+   */
+  protected $stageDir;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    // Create a mocked path locator that uses the fake site fixture as its
+    // active directory, and has a staging area within the site directory for
+    // this test.
+    $drupal_root = $this->getDrupalRoot();
+    /** @var \Drupal\automatic_updates\PathLocator|\Prophecy\Prophecy\ObjectProphecy $locator */
+    $locator = $this->prophesize(PathLocator::class);
+    $locator->getActiveDirectory()->willReturn(__DIR__ . '/../../fixtures/fake-site');
+    $this->stageDir = implode(DIRECTORY_SEPARATOR, [
+      $drupal_root,
+      $this->siteDirectory,
+      'stage',
+    ]);
+    $locator->getStageDirectory()->willReturn($this->stageDir);
+    $locator->getProjectRoot()->willReturn($drupal_root);
+    $locator->getWebRoot()->willReturn('');
+
+    // Create a cleaner that uses 'sites/default' as its site path, since it
+    // will otherwise default to the site path being used for the test site,
+    // which doesn't exist in the fake site fixture.
+    $cleaner = new Cleaner(
+      $this->container->get('automatic_updates.file_system'),
+      'sites/default',
+      $locator->reveal()
+    );
+
+    $this->updater = new Updater(
+      $this->container->get('state'),
+      $this->container->get('string_translation'),
+      $this->container->get('automatic_updates.beginner'),
+      $this->container->get('automatic_updates.stager'),
+      $cleaner,
+      $this->container->get('automatic_updates.committer'),
+      $this->container->get('event_dispatcher'),
+      $locator->reveal()
+    );
+
+    // Use the public and private files directories in the fake site fixture.
+    $settings = Settings::getAll();
+    $settings['file_public_path'] = 'files/public';
+    $settings['file_private_path'] = 'files/private';
+    new Settings($settings);
+
+    // Updater::begin() will trigger update validators, such as
+    // \Drupal\automatic_updates\Validator\UpdateVersionValidator, that need to
+    // fetch release metadata. We need to ensure that those HTTP request(s)
+    // succeed, so set them up to point to our fake release metadata.
+    $this->config('update_test.settings')
+      ->set('xml_map', [
+        'drupal' => '0.0',
+      ])
+      ->save();
+    $this->config('update.settings')
+      ->set('fetch.url', $this->baseUrl . '/automatic-update-test')
+      ->save();
+    $this->config('update_test.settings')
+      ->set('system_info.#all.version', '9.8.0')
+      ->save();
+  }
+
+  /**
+   * Tests that certain files and directories are not staged.
+   *
+   * @covers \Drupal\automatic_updates\Updater::getExclusions
+   */
+  public function testExclusions(): void {
+    $this->updater->begin(['drupal' => '9.8.1']);
+    $this->assertFileDoesNotExist("$this->stageDir/sites/default/settings.php");
+    $this->assertFileDoesNotExist("$this->stageDir/sites/default/settings.local.php");
+    $this->assertFileDoesNotExist("$this->stageDir/sites/default/services.yml");
+    // A file in sites/default, that isn't one of the site-specific settings
+    // files, should be staged.
+    $this->assertFileExists("$this->stageDir/sites/default/staged.txt");
+    $this->assertDirectoryDoesNotExist("$this->stageDir/sites/simpletest");
+    $this->assertDirectoryDoesNotExist("$this->stageDir/files/public");
+    $this->assertDirectoryDoesNotExist("$this->stageDir/files/private");
+    // A file that's in the general files directory, but not in the public or
+    // private directories, should be staged.
+    $this->assertFileExists("$this->stageDir/files/staged.txt");
+  }
+
+  /**
+   * Tests that the staging directory is properly cleaned up.
+   *
+   * @covers \Drupal\automatic_updates\Cleaner
+   */
+  public function testClean(): void {
+    $this->updater->begin(['drupal' => '9.8.1']);
+    // Make the staged site directory read-only, so we can test that it will be
+    // made writable on clean-up.
+    $this->assertTrue(chmod("$this->stageDir/sites/default", 0400));
+    $this->assertNotIsWritable("$this->stageDir/sites/default/staged.txt");
+    // If the site directory is not writable, this will throw an exception.
+    $this->updater->clean();
+    $this->assertDirectoryDoesNotExist($this->stageDir);
+  }
+
+}

tests/src/Kernel/ReadinessValidation/ComposerExecutableValidatorTest.php

@@ -3,10 +3,12 @@
 namespace Drupal\Tests\automatic_updates\Kernel\ReadinessValidation;
 
 use Drupal\automatic_updates\Validation\ValidationResult;
+use Drupal\automatic_updates\Validator\ComposerExecutableValidator;
 use Drupal\KernelTests\KernelTestBase;
 use Drupal\Tests\automatic_updates\Traits\ValidationTestTrait;
 use PhpTuf\ComposerStager\Exception\IOException;
 use PhpTuf\ComposerStager\Infrastructure\Process\ExecutableFinderInterface;
+use Prophecy\Argument;
 
 /**
  * @covers \Drupal\automatic_updates\Validator\ComposerExecutableValidator
@@ -46,4 +48,104 @@ class ComposerExecutableValidatorTest extends KernelTestBase {
     $this->assertValidationResultsEqual([$error], $results);
   }
 
+  /**
+   * Data provider for ::testComposerVersionValidation().
+   *
+   * @return array[]
+   *   Sets of arguments to pass to the test method.
+   */
+  public function providerComposerVersionValidation(): array {
+    // Invalid or undetectable Composer versions will always produce the same
+    // error.
+    $invalid_version = ValidationResult::createError(['The Composer version could not be detected.']);
+
+    // Unsupported Composer versions will report the detected version number
+    // in the validation result, so we need a function to churn out those fake
+    // results for the test method.
+    $unsupported_version = function (string $version): ValidationResult {
+      return ValidationResult::createError([
+        "Composer 2 or later is required, but version $version was detected.",
+      ]);
+    };
+
+    return [
+      // A valid 2.x version of Composer should not produce any errors.
+      [
+        '2.1.6',
+        [],
+      ],
+      [
+        '1.10.22',
+        [$unsupported_version('1.10.22')],
+      ],
+      [
+        '1.7.3',
+        [$unsupported_version('1.7.3')],
+      ],
+      [
+        '2.0.0-alpha3',
+        [],
+      ],
+      [
+        '2.1.0-RC1',
+        [],
+      ],
+      [
+        '1.0.0-RC',
+        [$unsupported_version('1.0.0-RC')],
+      ],
+      [
+        '1.0.0-beta1',
+        [$unsupported_version('1.0.0-beta1')],
+      ],
+      [
+        '1.9-dev',
+        [$invalid_version],
+      ],
+      [
+        '@package_version@',
+        [$invalid_version],
+      ],
+    ];
+  }
+
+  /**
+   * Tests validation of various Composer versions.
+   *
+   * @param string $reported_version
+   *   The version of Composer that `composer --version` should report.
+   * @param \Drupal\automatic_updates\Validation\ValidationResult[] $expected_results
+   *   The expected validation results.
+   *
+   * @dataProvider providerComposerVersionValidation
+   */
+  public function testComposerVersionValidation(string $reported_version, array $expected_results): void {
+    // Mock the output of `composer --version`, will be passed to the validator,
+    // which is itself a callback function that gets called repeatedly as
+    // Composer produces output.
+    /** @var \PhpTuf\ComposerStager\Infrastructure\Process\Runner\ComposerRunnerInterface|\Prophecy\Prophecy\ObjectProphecy $runner */
+    $runner = $this->prophesize('\PhpTuf\ComposerStager\Infrastructure\Process\Runner\ComposerRunnerInterface');
+
+    $runner->run(['--version'], Argument::type(ComposerExecutableValidator::class))
+      // Whatever is passed to ::run() will be passed to this mock callback in
+      // $arguments, and we know exactly what that will contain: an array of
+      // command arguments for Composer, and the validator object.
+      ->will(function (array $arguments) use ($reported_version) {
+        /** @var \Drupal\automatic_updates\Validator\ComposerExecutableValidator $validator */
+        $validator = $arguments[1];
+        // Invoke the validator (which, as mentioned, is a callback function),
+        // with fake output from `composer --version`. It should try to tease a
+        // recognized, supported version number out of this output.
+        $validator($validator::OUT, "Composer version $reported_version");
+      });
+    $this->container->set('automatic_updates.composer_runner', $runner->reveal());
+
+    // If the validator can't find a recognized, supported version of Composer,
+    // it should produce errors.
+    $actual_results = $this->container->get('automatic_updates.readiness_validation_manager')
+      ->run()
+      ->getResults();
+    $this->assertValidationResultsEqual($expected_results, $actual_results);
+  }
+
 }

tests/src/Unit/StagedProjectsValidatorTest.php

@@ -3,7 +3,7 @@
 namespace Drupal\Tests\automatic_updates\Unit;
 
 use Drupal\automatic_updates\Event\UpdateEvent;
-use Drupal\automatic_updates\Updater;
+use Drupal\automatic_updates\PathLocator;
 use Drupal\automatic_updates\Validator\StagedProjectsValidator;
 use Drupal\Component\FileSystem\FileSystem;
 use Drupal\Core\StringTranslation\PluralTranslatableMarkup;
@@ -26,10 +26,10 @@ class StagedProjectsValidatorTest extends UnitTestCase {
     $active_dir = uniqid($prefix);
     $stage_dir = uniqid($prefix);
 
-    $updater = $this->prophesize(Updater::class);
-    $updater->getActiveDirectory()->willReturn($active_dir);
-    $updater->getStageDirectory()->willReturn($stage_dir);
-    $validator = new StagedProjectsValidator(new TestTranslationManager(), $updater->reveal());
+    $locator = $this->prophesize(PathLocator::class);
+    $locator->getActiveDirectory()->willReturn($active_dir);
+    $locator->getStageDirectory()->willReturn($stage_dir);
+    $validator = new StagedProjectsValidator(new TestTranslationManager(), $locator->reveal());
 
     $event = new UpdateEvent();
     $validator->validateStagedProjects($event);
@@ -56,13 +56,13 @@ class StagedProjectsValidatorTest extends UnitTestCase {
    * @covers ::validateStagedProjects
    */
   public function testErrors(string $fixtures_dir, string $expected_summary, array $expected_messages): void {
-    $updater = $this->prophesize(Updater::class);
+    $locator = $this->prophesize(PathLocator::class);
     $this->assertNotEmpty($fixtures_dir);
     $this->assertDirectoryExists($fixtures_dir);
 
-    $updater->getActiveDirectory()->willReturn("$fixtures_dir/active");
-    $updater->getStageDirectory()->willReturn("$fixtures_dir/staged");
-    $validator = new StagedProjectsValidator(new TestTranslationManager(), $updater->reveal());
+    $locator->getActiveDirectory()->willReturn("$fixtures_dir/active");
+    $locator->getStageDirectory()->willReturn("$fixtures_dir/staged");
+    $validator = new StagedProjectsValidator(new TestTranslationManager(), $locator->reveal());
     $event = new UpdateEvent();
     $validator->validateStagedProjects($event);
     $results = $event->getResults();
@@ -121,10 +121,10 @@ class StagedProjectsValidatorTest extends UnitTestCase {
    */
   public function testNoErrors(): void {
     $fixtures_dir = realpath(__DIR__ . '/../../fixtures/project_staged_validation/no_errors');
-    $updater = $this->prophesize(Updater::class);
-    $updater->getActiveDirectory()->willReturn("$fixtures_dir/active");
-    $updater->getStageDirectory()->willReturn("$fixtures_dir/staged");
-    $validator = new StagedProjectsValidator(new TestTranslationManager(), $updater->reveal());
+    $locator = $this->prophesize(PathLocator::class);
+    $locator->getActiveDirectory()->willReturn("$fixtures_dir/active");
+    $locator->getStageDirectory()->willReturn("$fixtures_dir/staged");
+    $validator = new StagedProjectsValidator(new TestTranslationManager(), $locator->reveal());
     $event = new UpdateEvent();
     $validator->validateStagedProjects($event);
     $results = $event->getResults();
@@ -137,10 +137,10 @@ class StagedProjectsValidatorTest extends UnitTestCase {
    */
   public function testNoLockFile(): void {
     $fixtures_dir = realpath(__DIR__ . '/../../fixtures/project_staged_validation/no_errors');
-    $updater = $this->prophesize(Updater::class);
-    $updater->getActiveDirectory()->willReturn("$fixtures_dir/active");
-    $updater->getStageDirectory()->willReturn("$fixtures_dir");
-    $validator = new StagedProjectsValidator(new TestTranslationManager(), $updater->reveal());
+    $locator = $this->prophesize(PathLocator::class);
+    $locator->getActiveDirectory()->willReturn("$fixtures_dir/active");
+    $locator->getStageDirectory()->willReturn("$fixtures_dir");
+    $validator = new StagedProjectsValidator(new TestTranslationManager(), $locator->reveal());
     $event = new UpdateEvent();
     $validator->validateStagedProjects($event);
     $results = $event->getResults();