automatic_updates.module

@@ -5,6 +5,7 @@
  * Contains hook implementations for Automatic Updates.
  */
 
+use Drupal\automatic_updates\BatchProcessor;
 use Drupal\Core\Routing\RouteMatchInterface;
 use Drupal\automatic_updates\CronUpdater;
 use Drupal\automatic_updates\UpdateRecommender;
@@ -12,6 +13,7 @@ use Drupal\automatic_updates\Validation\AdminReadinessMessages;
 use Drupal\Core\Extension\ExtensionVersion;
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Url;
+use Drupal\system\Controller\DbUpdateController;
 use Drupal\update\ProjectSecurityData;
 
 /**
@@ -200,3 +202,16 @@ function automatic_updates_local_tasks_alter(array &$local_tasks) {
     }
   }
 }
+
+/**
+ * Implements hook_batch_alter().
+ *
+ * @todo Remove this in https://www.drupal.org/i/3267817.
+ */
+function automatic_updates_batch_alter(array &$batch): void {
+  foreach ($batch['sets'] as &$batch_set) {
+    if (!empty($batch_set['finished']) && $batch_set['finished'] === [DbUpdateController::class, 'batchFinished']) {
+      $batch_set['finished'] = [BatchProcessor::class, 'dbUpdateBatchFinished'];
+    }
+  }
+}

package_manager/tests/modules/package_manager_test_fixture/package_manager_test_fixture.info.yml

+name: 'Package Manager Test Fixture'
+description: 'Provides a mechanism for functional tests to stage fixture files.'
+type: module
+package: Testing
+dependencies:
+  - automatic_updates:package_manager

package_manager/tests/modules/package_manager_test_fixture/package_manager_test_fixture.services.yml

+services:
+  package_manager_test_fixture.stager:
+    class: Drupal\package_manager_test_fixture\EventSubscriber\FixtureStager
+    arguments:
+      - '@state'
+      - '@package_manager.symfony_file_system'
+    tags:
+      - { name: event_subscriber }

package_manager/tests/modules/package_manager_test_fixture/src/EventSubscriber/FixtureStager.php

+<?php
+
+namespace Drupal\package_manager_test_fixture\EventSubscriber;
+
+use Drupal\Core\State\StateInterface;
+use Drupal\package_manager\Event\PostRequireEvent;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * Defines an event subscriber which copies certain files into the staging area.
+ *
+ * This is most useful in conjunction with package_manager_bypass, which quietly
+ * turns all Composer Stager operations into no-ops. In such cases, no staging
+ * area will be physically created, but if a test needs to simulate certain
+ * conditions in a staging area without actually staging the active code base,
+ * this event subscriber is the way to do it.
+ */
+class FixtureStager implements EventSubscriberInterface {
+
+  /**
+   * The state service.
+   *
+   * @var \Drupal\Core\State\StateInterface
+   */
+  protected $state;
+
+  /**
+   * The Symfony file system service.
+   *
+   * @var \Symfony\Component\Filesystem\Filesystem
+   */
+  protected $fileSystem;
+
+  /**
+   * Constructs a FixtureStager.
+   *
+   * @param \Drupal\Core\State\StateInterface $state
+   *   The state service.
+   * @param \Symfony\Component\Filesystem\Filesystem $file_system
+   *   The Symfony file system service.
+   */
+  public function __construct(StateInterface $state, Filesystem $file_system) {
+    $this->state = $state;
+    $this->fileSystem = $file_system;
+  }
+
+  /**
+   * Copies files from a fixture into the staging area.
+   *
+   * Tests which use this functionality are responsible for cleaning up the
+   * staging area.
+   *
+   * @param \Drupal\package_manager\Event\PostRequireEvent $event
+   *   The event object.
+   *
+   * @see \Drupal\Tests\automatic_updates\Functional\AutomaticUpdatesFunctionalTestBase::tearDown()
+   */
+  public function copyFilesFromFixture(PostRequireEvent $event): void {
+    $fixturePath = $this->state->get(static::class);
+    if ($fixturePath && is_dir($fixturePath)) {
+      $this->fileSystem->mirror($fixturePath, $event->getStage()->getStageDirectory(), NULL, [
+        'override' => TRUE,
+        'delete' => TRUE,
+      ]);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getSubscribedEvents() {
+    return [
+      PostRequireEvent::class => 'copyFilesFromFixture',
+    ];
+  }
+
+  /**
+   * Sets the path of the fixture to copy into the staging area.
+   *
+   * @param string $path
+   *   The path of the fixture to copy into the staging area.
+   */
+  public static function setFixturePath(string $path): void {
+    \Drupal::state()->set(static::class, $path);
+  }
+
+}

package_manager/tests/modules/package_manager_test_validation/src/EventSubscriber/TestSubscriber.php

@@ -112,6 +112,9 @@ class TestSubscriber implements EventSubscriberInterface {
   public function handleEvent(StageEvent $event): void {
     $results = $this->state->get(static::STATE_KEY . '.' . get_class($event), []);
 
+    // Record that value of maintenance mode for each event.
+    $this->state->set(get_class($event) . '.' . 'system.maintenance_mode', $this->state->get('system.maintenance_mode'));
+
     if ($results instanceof \Throwable) {
       throw $results;
     }

src/BatchProcessor.php

@@ -4,6 +4,7 @@ namespace Drupal\automatic_updates;
 
 use Drupal\Core\Url;
 use Drupal\package_manager\Exception\StageValidationException;
+use Drupal\system\Controller\DbUpdateController;
 use Symfony\Component\HttpFoundation\RedirectResponse;
 
 /**
@@ -18,6 +19,13 @@ class BatchProcessor {
    */
   public const STAGE_ID_SESSION_KEY = '_automatic_updates_stage_id';
 
+  /**
+   * The session key which indicates if the update is done in maintenance mode.
+   *
+   * @var string
+   */
+  public const MAINTENANCE_MODE_SESSION_KEY = '_automatic_updates_maintenance_mode';
+
   /**
    * Gets the updater service.
    *
@@ -200,4 +208,39 @@ class BatchProcessor {
     }
   }
 
+  /**
+   * Reset maintenance mode after update.php.
+   *
+   * This wraps \Drupal\system\Controller\DbUpdateController::batchFinished()
+   * because that function would leave the site in maintenance mode if we
+   * redirected the user to update.php already in maintenance mode. We need to
+   * take the site out of maintenance mode, if it was not enabled before they
+   * submitted our confirmation form.
+   *
+   * @param bool $success
+   *   Whether the batch API tasks were all completed successfully.
+   * @param array $results
+   *   An array of all the results.
+   * @param array $operations
+   *   A list of the operations that had not been completed by the batch API.
+   *
+   * @todo Remove the need for this workaround in
+   *    https://www.drupal.org/i/3267817.
+   *
+   * @see \Drupal\update\Form\UpdateReady::submitForm()
+   * @see automatic_updates_batch_alter()
+   */
+  public static function dbUpdateBatchFinished(bool $success, array $results, array $operations) {
+    DbUpdateController::batchFinished($success, $results, $operations);
+    // Now that the update is done, we can put the site back online if it was
+    // previously not in maintenance mode.
+    // \Drupal\system\Controller\DbUpdateController::batchFinished() will not
+    // unset maintenance mode if the site was in maintenance mode when the user
+    // was redirected to update.php by
+    // \Drupal\automatic_updates\Controller\UpdateController::onFinish().
+    if (!\Drupal::request()->getSession()->remove(static::MAINTENANCE_MODE_SESSION_KEY)) {
+      \Drupal::state()->set('system.maintenance_mode', FALSE);
+    }
+  }
+
 }

src/Controller/UpdateController.php

@@ -2,11 +2,14 @@
 
 namespace Drupal\automatic_updates\Controller;
 
+use Drupal\automatic_updates\BatchProcessor;
 use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\State\StateInterface;
 use Drupal\Core\Url;
 use Drupal\package_manager\Validator\PendingUpdatesValidator;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\Request;
 
 /**
  * Defines a controller to handle various stages of an automatic update.
@@ -28,9 +31,12 @@ class UpdateController extends ControllerBase {
    *
    * @param \Drupal\package_manager\Validator\PendingUpdatesValidator $pending_updates_validator
    *   The pending updates validator.
+   * @param \Drupal\Core\State\StateInterface $state
+   *   The state service.
    */
-  public function __construct(PendingUpdatesValidator $pending_updates_validator) {
+  public function __construct(PendingUpdatesValidator $pending_updates_validator, StateInterface $state) {
     $this->pendingUpdatesValidator = $pending_updates_validator;
+    $this->stateService = $state;
   }
 
   /**
@@ -38,7 +44,8 @@ class UpdateController extends ControllerBase {
    */
   public static function create(ContainerInterface $container) {
     return new static(
-      $container->get('package_manager.validator.pending_updates')
+      $container->get('package_manager.validator.pending_updates'),
+      $container->get('state')
     );
   }
 
@@ -49,10 +56,13 @@ class UpdateController extends ControllerBase {
    * update.php to run those. Otherwise, they are redirected to the status
    * report.
    *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   The current request object.
+   *
    * @return \Symfony\Component\HttpFoundation\RedirectResponse
    *   A redirect to the appropriate destination.
    */
-  public function onFinish(): RedirectResponse {
+  public function onFinish(Request $request): RedirectResponse {
     if ($this->pendingUpdatesValidator->updatesExist()) {
       $message = $this->t('Please apply database updates to complete the update process.');
       $url = Url::fromRoute('system.db_update');
@@ -60,6 +70,11 @@ class UpdateController extends ControllerBase {
     else {
       $message = $this->t('Update complete!');
       $url = Url::fromRoute('update.status');
+      // Now that the update is done, we can put the site back online if it was
+      // previously not in maintenance mode.
+      if (!$request->getSession()->remove(BatchProcessor::MAINTENANCE_MODE_SESSION_KEY)) {
+        $this->state()->set('system.maintenance_mode', FALSE);
+      }
     }
     $this->messenger()->addStatus($message);
     return new RedirectResponse($url->setAbsolute()->toString());

src/Form/UpdateReady.php

@@ -105,46 +105,71 @@ class UpdateReady extends FormBase {
       return $form;
     }
 
-    // Don't check for pending database updates if the form has been submitted,
-    // because we don't want to store the warning in the messenger during form
-    // submit.
+    $messages = [];
+
+    // If there are any installed modules with database updates in the staging
+    // area, warn the user that they might be sent to update.php once the
+    // staged changes have been applied.
+    $pending_updates = $this->getModulesWithStagedDatabaseUpdates();
+    if ($pending_updates) {
+      $messages[MessengerInterface::TYPE_WARNING][] = $this->t('Possible database updates were detected in the following modules; you may be redirected to the database update page in order to complete the update process.');
+      foreach ($pending_updates as $info) {
+        $messages[MessengerInterface::TYPE_WARNING][] = $info['name'];
+      }
+    }
+
+    try {
+      $staged_core_packages = $this->updater->getStageComposer()
+        ->getCorePackages();
+    }
+    catch (\Throwable $exception) {
+      $messages[MessengerInterface::TYPE_ERROR][] = $this->t('There was an error loading the pending update. Press the <em>Cancel update</em> button to start over.');
+    }
+
+    // Don't set any messages if the form has been submitted, because we don't
+    // want them to be set during form submit.
     if (!$form_state->getUserInput()) {
-      // If there are any installed modules with database updates in the staging
-      // area, warn the user that they might be sent to update.php once the
-      // staged changes have been applied.
-      $pending_updates = $this->getModulesWithStagedDatabaseUpdates();
-
-      if ($pending_updates) {
-        $this->messenger()->addWarning($this->t('Possible database updates were detected in the following modules; you may be redirected to the database update page in order to complete the update process.'));
-        foreach ($pending_updates as $info) {
-          $this->messenger()->addWarning($info['name']);
+      foreach ($messages as $type => $messages_of_type) {
+        foreach ($messages_of_type as $message) {
+          $this->messenger()->addMessage($message, $type);
         }
       }
     }
 
+    $form['actions'] = [
+      'cancel' => [
+        '#type' => 'submit',
+        '#value' => $this->t('Cancel update'),
+        '#submit' => ['::cancel'],
+      ],
+      '#type' => 'actions',
+    ];
     $form['stage_id'] = [
       '#type' => 'value',
       '#value' => $stage_id,
     ];
 
+    if (empty($staged_core_packages)) {
+      return $form;
+    }
+
+    $form['update_version'] = [
+      '#type' => 'html_tag',
+      '#tag' => 'p',
+      '#value' => $this->t('Drupal core will be updated to %version', [
+        '%version' => reset($staged_core_packages)->getPrettyVersion(),
+      ]),
+    ];
     $form['backup'] = [
       '#prefix' => '<strong>',
       '#markup' => $this->t('Back up your database and site before you continue. <a href=":backup_url">Learn how</a>.', [':backup_url' => 'https://www.drupal.org/node/22281']),
       '#suffix' => '</strong>',
     ];
-
     $form['maintenance_mode'] = [
       '#title' => $this->t('Perform updates with site in maintenance mode (strongly recommended)'),
       '#type' => 'checkbox',
       '#default_value' => TRUE,
     ];
-
-    $form['actions'] = ['#type' => 'actions'];
-    $form['actions']['cancel'] = [
-      '#type' => 'submit',
-      '#value' => $this->t('Cancel update'),
-      '#submit' => ['::cancel'],
-    ];
     $form['actions']['submit'] = [
       '#type' => 'submit',
       '#value' => $this->t('Continue'),
@@ -171,12 +196,13 @@ class UpdateReady extends FormBase {
    * {@inheritdoc}
    */
   public function submitForm(array &$form, FormStateInterface $form_state) {
-    $session = $this->getRequest()->getSession();
     // Store maintenance_mode setting so we can restore it when done.
-    $session->set('maintenance_mode', $this->state->get('system.maintenance_mode'));
+    $this->getRequest()
+      ->getSession()
+      ->set(BatchProcessor::MAINTENANCE_MODE_SESSION_KEY, $this->state->get('system.maintenance_mode'));
+
     if ($form_state->getValue('maintenance_mode')) {
       $this->state->set('system.maintenance_mode', TRUE);
-      // @todo unset after updater. After db update?
     }
     $stage_id = $form_state->getValue('stage_id');
     $batch = (new BatchBuilder())

tests/fixtures/staged/9.8.1/composer.json

+{
+  "extra": {
+    "_readme": [
+      "This fixture simulates a staging area in which, according to Composer, Drupal core 9.8.1 is installed."
+    ]
+  }
+}

tests/fixtures/staged/9.8.1/vendor/composer/installed.json

+{
+  "packages": [
+    {
+      "name": "drupal/core",
+      "version": "9.8.1",
+      "type": "drupal-core"
+    }
+  ]
+}

tests/src/Functional/AutomaticUpdatesFunctionalTestBase.php

@@ -50,6 +50,19 @@ abstract class AutomaticUpdatesFunctionalTestBase extends BrowserTestBase {
     $this->disableValidators($this->disableValidators);
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  protected function tearDown(): void {
+    // If automatic_updates is installed, ensure any staging area created during
+    // the test is cleaned up.
+    $service_id = 'automatic_updates.updater';
+    if ($this->container->has($service_id)) {
+      $this->container->get($service_id)->destroy(TRUE);
+    }
+    parent::tearDown();
+  }
+
   /**
    * Disables validators in the test site's settings.
    *
@@ -124,10 +137,14 @@ abstract class AutomaticUpdatesFunctionalTestBase extends BrowserTestBase {
 
   /**
    * Asserts that we are on the "update ready" form.
+   *
+   * @param string $update_version
+   *   The version of Drupal core that we are updating to.
    */
-  protected function assertUpdateReady(): void {
-    $this->assertSession()
-      ->addressMatches('/\/admin\/automatic-update-ready\/[a-zA-Z0-9_\-]+$/');
+  protected function assertUpdateReady(string $update_version): void {
+    $assert_session = $this->assertSession();
+    $assert_session->addressMatches('/\/admin\/automatic-update-ready\/[a-zA-Z0-9_\-]+$/');
+    $assert_session->pageTextContainsOnce('Drupal core will be updated to ' . $update_version);
   }
 
 }

tests/src/Functional/ReadinessValidationTest.php

@@ -8,6 +8,7 @@ use Drupal\automatic_updates_test\Datetime\TestTime;
 use Drupal\automatic_updates_test\EventSubscriber\TestSubscriber1;
 use Drupal\automatic_updates_test2\EventSubscriber\TestSubscriber2;
 use Drupal\Core\Url;
+use Drupal\package_manager_test_fixture\EventSubscriber\FixtureStager;
 use Drupal\system\SystemManager;
 use Drupal\Tests\automatic_updates\Traits\ValidationTestTrait;
 use Drupal\Tests\Traits\Core\CronRunTrait;
@@ -398,6 +399,7 @@ class ReadinessValidationTest extends AutomaticUpdatesFunctionalTestBase {
     $this->container->get('module_installer')->install([
       'automatic_updates',
       'automatic_updates_test',
+      'package_manager_test_fixture',
     ]);
     // Because all actual staging operations are bypassed by
     // package_manager_bypass (enabled by the parent class), disable this
@@ -418,6 +420,7 @@ class ReadinessValidationTest extends AutomaticUpdatesFunctionalTestBase {
     // readiness check (without storing the results), and the checker is no
     // longer raising an error.
     $this->drupalGet('/admin/modules/automatic-update');
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
     $assert_session->buttonExists('Update');
     // Ensure that the previous results are still displayed on another admin
     // page, to confirm that the updater form is not discarding the previous
@@ -428,7 +431,7 @@ class ReadinessValidationTest extends AutomaticUpdatesFunctionalTestBase {
     $this->drupalGet('/admin/modules/automatic-update');
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     $page->pressButton('Continue');
     $this->checkForMetaRefresh();
     $assert_session->pageTextContains('Update complete!');

tests/src/Functional/UpdateLockTest.php

@@ -2,6 +2,8 @@
 
 namespace Drupal\Tests\automatic_updates\Functional;
 
+use Drupal\package_manager_test_fixture\EventSubscriber\FixtureStager;
+
 /**
  * Tests that only one Automatic Update operation can be performed at a time.
  *
@@ -20,6 +22,7 @@ class UpdateLockTest extends AutomaticUpdatesFunctionalTestBase {
   protected static $modules = [
     'automatic_updates',
     'automatic_updates_test',
+    'package_manager_test_fixture',
   ];
 
   /**
@@ -48,9 +51,10 @@ class UpdateLockTest extends AutomaticUpdatesFunctionalTestBase {
     // We should be able to get partway through an update without issue.
     $this->drupalLogin($user_1);
     $this->drupalGet('/admin/modules/automatic-update');
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     $assert_session->buttonExists('Continue');
     $url = parse_url($this->getSession()->getCurrentUrl(), PHP_URL_PATH);
 

tests/src/Functional/UpdaterFormTest.php

@@ -4,11 +4,13 @@ namespace Drupal\Tests\automatic_updates\Functional;
 
 use Drupal\automatic_updates\Event\ReadinessCheckEvent;
 use Drupal\automatic_updates_test\Datetime\TestTime;
+use Drupal\Component\FileSystem\FileSystem;
 use Drupal\package_manager\Event\PostRequireEvent;
 use Drupal\package_manager\Event\PreApplyEvent;
 use Drupal\package_manager\Event\PreCreateEvent;
 use Drupal\package_manager\ValidationResult;
 use Drupal\automatic_updates_test\EventSubscriber\TestSubscriber1;
+use Drupal\package_manager_test_fixture\EventSubscriber\FixtureStager;
 use Drupal\Tests\automatic_updates\Traits\ValidationTestTrait;
 use Drupal\Tests\package_manager\Traits\PackageManagerBypassTestTrait;
 
@@ -34,6 +36,7 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     'block',
     'automatic_updates',
     'automatic_updates_test',
+    'package_manager_test_fixture',
   ];
 
   /**
@@ -250,18 +253,19 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     $this->checkForUpdates();
 
     $this->drupalGet('/admin/modules/automatic-update');
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
     $this->assertUpdateStagedTimes(1);
 
     // Confirm we are on the confirmation page.
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     $assert_session->buttonExists('Continue');
 
     // If we try to return to the start page, we should be redirected back to
     // the confirmation page.
     $this->drupalGet('/admin/modules/automatic-update');
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
 
     // Delete the existing update.
     $page->pressButton('Cancel update');
@@ -273,7 +277,7 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     $this->checkForMetaRefresh();
 
     // Confirm we are on the confirmation page.
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     $this->assertUpdateStagedTimes(2);
     $assert_session->buttonExists('Continue');
 
@@ -290,7 +294,7 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     $assert_session->pageTextNotContains($conflict_message);
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
 
     // Stop execution during pre-apply. This should make Package Manager think
     // the staged changes are being applied and raise an error if we try to
@@ -332,7 +336,7 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     TestSubscriber1::setTestResult($results, PreApplyEvent::class);
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     $page->pressButton('Continue');
     $this->checkForMetaRefresh();
     $page->clickLink('the error page');
@@ -340,13 +344,35 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     $assert_session->pageTextContains($cancelled_message);
   }
 
+  /**
+   * Data provider for testStagedDatabaseUpdates().
+   *
+   * @return bool[][]
+   *   The test cases.
+   */
+  public function providerStagedDatabaseUpdates() {
+    return [
+      'maintenance mode on' => [TRUE],
+      'maintenance mode off' => [FALSE],
+    ];
+  }
+
   /**
    * Tests the update form when staged modules have database updates.
+   *
+   * @param bool $maintenance_mode_on
+   *   Whether the site should be in maintenance mode at the beginning of the
+   *   update process.
+   *
+   * @dataProvider providerStagedDatabaseUpdates
    */
-  public function testStagedDatabaseUpdates(): void {
+  public function testStagedDatabaseUpdates(bool $maintenance_mode_on): void {
     $this->setCoreVersion('9.8.0');
     $this->checkForUpdates();
 
+    $state = $this->container->get('state');
+    $state->set('system.maintenance_mode', $maintenance_mode_on);
+
     // Flag a warning, which will not block the update but should be displayed
     // on the updater form.
     $this->createTestValidationResults();
@@ -356,17 +382,18 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
 
     $page = $this->getSession()->getPage();
     $this->drupalGet('/admin/modules/automatic-update');
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
     // The warning should be visible.
     $assert_session = $this->assertSession();
     $assert_session->pageTextContains(reset($messages));
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
     $this->assertUpdateStagedTimes(1);
-    $this->assertUpdateReady();
+    $this->assertUpdateReady('9.8.1');
     // Simulate a staged database update in the automatic_updates_test module.
     // We must do this after the update has started, because the pending updates
     // validator will prevent an update from starting.
-    $this->container->get('state')->set('automatic_updates_test.new_update', TRUE);
+    $state->set('automatic_updates_test.new_update', TRUE);
     // The warning from the updater form should be not be repeated, but we
     // should see a warning about pending database updates, and once the staged
     // changes have been applied, we should be redirected to update.php, where
@@ -375,12 +402,55 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
     $possible_update_message = 'Possible database updates were detected in the following modules; you may be redirected to the database update page in order to complete the update process.';
     $assert_session->pageTextContains($possible_update_message);
     $assert_session->pageTextContains('System');
+    $assert_session->checkboxChecked('maintenance_mode');
     $page->pressButton('Continue');
     $this->checkForMetaRefresh();
+    // Confirm that the site was in maintenance before the update was applied.
+    // @see \Drupal\package_manager_test_validation\EventSubscriber\TestSubscriber::handleEvent()
+    $this->assertTrue($state->get(PreApplyEvent::class . '.system.maintenance_mode'));
+    // Confirm the site remains in maintenance more when redirected to
+    // update.php.
+    $this->assertTrue($state->get('system.maintenance_mode'));
     $assert_session->addressEquals('/update.php');
     $assert_session->pageTextNotContains(reset($messages));
     $assert_session->pageTextNotContains($possible_update_message);
     $assert_session->pageTextContainsOnce('Please apply database updates to complete the update process.');
+    $this->assertTrue($state->get('system.maintenance_mode'));
+    $page->clickLink('Continue');
+    // @see automatic_updates_update_9001()
+    $assert_session->pageTextContains('Dynamic automatic_updates_update_9001');
+    $page->clickLink('Apply pending updates');
+    $this->checkForMetaRefresh();
+    $assert_session->pageTextContains('Updates were attempted.');
+    // Confirm the site was returned to the original maintenance module state.
+    $this->assertSame($state->get('system.maintenance_mode'), $maintenance_mode_on);
+  }
+
+  /**
+   * Data provider for testSuccessfulUpdate().
+   *
+   * @return string[][]
+   *   Test case parameters.
+   */
+  public function providerSuccessfulUpdate(): array {
+    return [
+      'Modules page, maintenance mode on' => [
+        '/admin/modules/automatic-update',
+        TRUE,
+      ],
+      'Modules page, maintenance mode off' => [
+        '/admin/modules/automatic-update',
+        FALSE,
+      ],
+      'Reports page, maintenance mode on' => [
+        '/admin/reports/updates/automatic-update',
+        TRUE,
+      ],
+      'Reports page, maintenance mode off' => [
+        '/admin/reports/updates/automatic-update',
+        FALSE,
+      ],
+    ];
   }
 
   /**
@@ -388,30 +458,69 @@ class UpdaterFormTest extends AutomaticUpdatesFunctionalTestBase {
    *
    * @param string $update_form_url
    *   The URL of the update form to visit.
+   * @param bool $maintenance_mode_on
+   *   Whether maintenance should be on at the beginning of the update.
    *
-   * @dataProvider providerUpdateFormReferringUrl
+   * @dataProvider providerSuccessfulUpdate
    */
-  public function testSuccessfulUpdate(string $update_form_url): void {
+  public function testSuccessfulUpdate(string $update_form_url, bool $maintenance_mode_on): void {
     $this->setCoreVersion('9.8.0');
     $this->checkForUpdates();
+    $state = $this->container->get('state');
+    $state->set('system.maintenance_mode', $maintenance_mode_on);
 
     $page = $this->getSession()->getPage();
     $this->drupalGet($update_form_url);
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
     $page->pressButton('Update');
     $this->checkForMetaRefresh();
     $this->assertUpdateStagedTimes(1);
-    $this->assertUpdateReady();
-    $this->assertNotTrue($this->container->get('state')->get('system.maintenance_mode'));
+    $this->assertUpdateReady('9.8.1');
+    // Confirm that the site was put into maintenance mode if needed.
+    $this->assertSame($state->get('system.maintenance_mode'), $maintenance_mode_on);
     $page->pressButton('Continue');
     $this->checkForMetaRefresh();
     $assert_session = $this->assertSession();
     $assert_session->addressEquals('/admin/reports/updates');
-    // Assert that the site was put into maintenance mode.
-    // @todo Add test coverage to ensure that site is taken back out of
-    //   maintenance if it was not originally in maintenance mode when the
-    //   update started in https://www.drupal.org/i/3265057.
-    $this->assertTrue($this->container->get('state')->get('system.maintenance_mode'));
+    // Confirm that the site was in maintenance before the update was applied.
+    // @see \Drupal\package_manager_test_validation\EventSubscriber\TestSubscriber::handleEvent()
+    $this->assertTrue($state->get(PreApplyEvent::class . '.system.maintenance_mode'));
     $assert_session->pageTextContainsOnce('Update complete!');
+    // Confirm the site was returned to the original maintenance mode state.
+    $this->assertSame($state->get('system.maintenance_mode'), $maintenance_mode_on);
+  }
+
+  /**
+   * Tests what happens when a staged update is deleted without being destroyed.
+   */
+  public function testStagedUpdateDeletedImproperly(): void {
+    $this->setCoreVersion('9.8.0');
+    $this->checkForUpdates();
+
+    $page = $this->getSession()->getPage();
+    $this->drupalGet('/admin/modules/automatic-update');
+    FixtureStager::setFixturePath(__DIR__ . '/../../fixtures/staged/9.8.1');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->assertUpdateStagedTimes(1);
+    $this->assertUpdateReady('9.8.1');
+    // Confirm if the staged directory is deleted without using destroy(), then
+    // an error message will be displayed on the page.
+    // @see \Drupal\package_manager\Stage::getStagingRoot()
+    $dir = FileSystem::getOsTemporaryDirectory() . '/.package_manager' . $this->config('system.site')->get('uuid');
+    $this->assertDirectoryExists($dir);
+    $this->container->get('file_system')->deleteRecursive($dir);
+    $this->getSession()->reload();
+    $assert_session = $this->assertSession();
+    $error_message = 'There was an error loading the pending update. Press the Cancel update button to start over.';
+    $assert_session->pageTextContainsOnce($error_message);
+    // We should be able to start over without any problems, and the error
+    // message should not be seen on the updater form.
+    $page->pressButton('Cancel update');
+    $assert_session->addressEquals('/admin/reports/updates/automatic-update');
+    $assert_session->pageTextNotContains($error_message);
+    $assert_session->pageTextContains('The update was successfully cancelled.');
+    $assert_session->buttonExists('Update');
   }
 
   /**