automatic_updates_extensions/tests/src/Build/ModuleUpdateTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Build;
+
+use Drupal\Tests\automatic_updates\Build\UpdateTestBase;
+use Drupal\Tests\automatic_updates_extensions\Traits\FormTestTrait;
+use Symfony\Component\Filesystem\Filesystem as SymfonyFilesystem;
+
+/**
+ * Tests updating modules in a stage directory.
+ *
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class ModuleUpdateTest extends UpdateTestBase {
+
+  use FormTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createTestProject(string $template): void {
+    parent::createTestProject($template);
+    $this->setReleaseMetadata([
+      'drupal' => __DIR__ . '/../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml',
+      'alpha'  => __DIR__ . '/../../fixtures/release-history/alpha.1.1.0.xml',
+      'new_module' => __DIR__ . '/../../fixtures/release-history/new_module.1.1.0.xml',
+    ]);
+
+    // Set 'version' and 'project' for the 'alpha' and 'new_module' module to
+    // enable the Update to determine the update status.
+    $system_info = [
+      'alpha' => ['version' => '1.0.0', 'project' => 'alpha'],
+      'new_module' => ['version' => '1.0.0', 'project' => 'new_module'],
+    ];
+    $system_info = var_export($system_info, TRUE);
+    $code = <<<END
+\$config['update_test.settings']['system_info'] = $system_info;
+END;
+    $this->writeSettings($code);
+    $alpha_repo_path = $this->copyFixtureToTempDirectory(__DIR__ . '/../../../../package_manager/tests/fixtures/build_test_projects/alpha/1.0.0');
+    $this->addRepository('alpha', $alpha_repo_path);
+    $this->runComposer('composer require drupal/alpha --update-with-all-dependencies', 'project');
+    $this->assertModuleVersion('alpha', '1.0.0');
+    $fs = new SymfonyFilesystem();
+    $fs->mirror($this->copyFixtureToTempDirectory(__DIR__ . '/../../fixtures/new_module'), $this->getWorkspaceDirectory() . '/project/web/modules');
+    $this->installModules([
+      'automatic_updates_extensions_test_api',
+      'alpha',
+      'new_module',
+    ]);
+
+    // Change the module's upstream version.
+    static::copyFixtureFilesTo(__DIR__ . '/../../../../package_manager/tests/fixtures/build_test_projects/alpha/1.1.0', $alpha_repo_path);
+
+    // Ensure that none of the above changes have caused any status check or
+    // other errors on the status report.
+    $this->checkForUpdates();
+    $this->assertStatusReportChecksSuccessful();
+  }
+
+  /**
+   * Tests updating a module in a stage directory via the API.
+   */
+  public function testApi(): void {
+    $this->createTestProject('RecommendedProject');
+    // Use the API endpoint to create a stage and update the 'new_module' module
+    // to 1.1.0.
+    // @see \Drupal\automatic_updates_extensions_test_api\ApiController::run()
+    $query = http_build_query([
+      'projects' => [
+        'new_module' => '1.1.0',
+      ],
+    ]);
+    $this->visit("/automatic-updates-extensions-test-api?$query");
+    $mink = $this->getMink();
+    $mink->assertSession()->statusCodeEquals(500);
+    $page_text = $mink->getSession()->getPage()->getText();
+    $this->assertStringContainsString('The project new_module is not a Drupal project known to Composer and cannot be updated.', $page_text);
+    $this->assertStringContainsString('new_module', $page_text);
+    // Use the API endpoint to create a stage and update the 'alpha' module to
+    // 1.1.0.
+    $this->makePackageManagerTestApiRequest(
+      '/automatic-updates-extensions-test-api',
+      [
+        'projects' => [
+          'alpha' => '1.1.0',
+        ],
+      ]
+    );
+
+    $updated_composer_json = $this->getWebRoot() . 'modules/contrib/alpha/composer.json';
+    // Assert the module was updated.
+    $this->assertFileEquals(
+      __DIR__ . '/../../../../package_manager/tests/fixtures/build_test_projects/alpha/1.1.0/composer.json',
+      $updated_composer_json,
+    );
+    $this->assertRequestedChangesWereLogged(['Update drupal/alpha from 1.0.0 to 1.1.0']);
+    $this->assertAppliedChangesWereLogged(['Updated drupal/alpha from 1.0.0 to 1.1.0']);
+  }
+
+  /**
+   * Tests updating a module in a stage directory via the UI.
+   */
+  public function testUi(): void {
+    $this->createTestProject('RecommendedProject');
+
+    $mink = $this->getMink();
+    $session = $mink->getSession();
+    $page = $session->getPage();
+    $assert_session = $mink->assertSession();
+
+    $this->visit('/admin/reports/updates');
+    // Confirm that 'New Module' project, which is not installed via Composer,
+    // has a 1.1.0 update release on the 'Available Updates' page.
+    $this->assertReportProjectUpdateVersion('New Module', '1.1.0');
+    $page->clickLink('Update Extensions');
+    $this->assertUpdateTableRow($assert_session, 'Alpha', '1.0.0', '1.1.0', 1);
+    // Confirm that a 'New Module' project does not appear on the form.
+    $assert_session->pageTextContains('Other updates were found, but they must be performed manually.');
+    $assert_session->fieldNotExists('projects[new_module]');
+    // Ensure test failures provide helpful debug output when failing readiness
+    // checks prevent updates.
+    // @see \Drupal\Tests\WebAssert::buildStatusMessageSelector()
+    if ($error_message = $session->getPage()->find('xpath', '//div[@data-drupal-messages]//div[@aria-label="Error message"]')) {
+      /** @var \Behat\Mink\Element\NodeElement $error_message */
+      $this->assertSame('', $error_message->getText());
+    }
+    $page->checkField('projects[alpha]');
+    $page->pressButton('Update');
+    $this->waitForBatchJob();
+    $assert_session->pageTextContains('Ready to update');
+    $page->checkField('backup');
+    $page->pressButton('Continue');
+    $this->waitForBatchJob();
+    $assert_session->pageTextContains('Update complete!');
+    $this->assertModuleVersion('alpha', '1.1.0');
+    $this->assertRequestedChangesWereLogged(['Update drupal/alpha from 1.0.0 to 1.1.0']);
+    $this->assertAppliedChangesWereLogged(['Updated drupal/alpha from 1.0.0 to 1.1.0']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function copyCodebase(\Iterator $iterator = NULL, $working_dir = NULL): void {
+    parent::copyCodebase($iterator, $working_dir);
+
+    // Ensure that we will install Drupal 9.8.0 (a fake version that should
+    // never exist in real life) initially.
+    $this->setUpstreamCoreVersion('9.8.0');
+  }
+
+  /**
+   * Assert a project version is on the Available Updates page.
+   *
+   * @param string $project_title
+   *   The project title.
+   * @param string $expected_version
+   *   The expected version.
+   */
+  protected function assertReportProjectUpdateVersion(string $project_title, string $expected_version): void {
+    $mink = $this->getMink();
+    $session = $mink->getSession();
+    $title_element = $session->getPage()
+      ->find('css', ".project-update__title:contains(\"$project_title\")");
+    $this->assertNotNull($title_element, "Title element found for $project_title");
+    $version_element = $title_element->getParent()->find('css', '.project-update__version-details');
+    $this->assertStringContainsString($expected_version, $version_element->getText());
+  }
+
+  /**
+   * Asserts a module is a specified version.
+   *
+   * @param string $module_name
+   *   The module name.
+   * @param string $version
+   *   The expected version.
+   */
+  private function assertModuleVersion(string $module_name, string $version): void {
+    $web_root = $this->getWebRoot();
+    $composer_json = file_get_contents("$web_root/modules/contrib/$module_name/composer.json");
+    $data = json_decode($composer_json, TRUE);
+    $this->assertSame($version, $data['version']);
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/ComposerStagerOperationFailureTest.php

+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\package_manager_bypass\LoggingBeginner;
+use Drupal\package_manager_bypass\LoggingCommitter;
+use Drupal\package_manager_bypass\NoOpStager;
+use PhpTuf\ComposerStager\API\Exception\InvalidArgumentException;
+use PhpTuf\ComposerStager\API\Exception\LogicException;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+class ComposerStagerOperationFailureTest extends UpdaterFormTestBase {
+
+  /**
+   * Tests Composer operation failure is handled properly.
+   *
+   * @param string $exception_class
+   *   The exception class.
+   * @param string $service_class
+   *   The Composer Stager service which should throw an exception.
+   *
+   * @dataProvider providerComposerOperationFailure
+   */
+  public function testComposerOperationFailure(string $exception_class, string $service_class): void {
+    $page = $this->getSession()->getPage();
+    $assert_session = $this->assertSession();
+    $this->setReleaseMetadata(__DIR__ . '/../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml');
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    // Navigate to the update form.
+    $this->drupalGet('/admin/reports/updates');
+    $this->clickLink('Update Extensions');
+    $this->assertTableShowsUpdates(
+      'Semver Test',
+      '8.1.0',
+      '8.1.1',
+    );
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $page->checkField('projects[semver_test]');
+
+    // Make the specified Composer Stager operation class throw an exception.
+    $message = $this->createComposeStagerMessage("Failure from inside $service_class");
+    $exception = new $exception_class($message);
+    call_user_func([$service_class, 'setException'], $exception);
+
+    // Start the update.
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    // We can't continue the update after an error in the committer.
+    if ($service_class === LoggingCommitter::class) {
+      $this->acceptWarningAndUpdate();
+      $this->clickLink('the error page');
+      $assert_session->statusCodeEquals(200);
+      $assert_session->statusMessageContains('Automatic updates failed to apply, and the site is in an indeterminate state. Consider restoring the code and database from a backup.');
+      return;
+    }
+    $this->clickLink('the error page');
+    $assert_session->statusMessageContains($exception->getMessage());
+
+    // Make the same Composer Stager operation class NOT throw an exception.
+    call_user_func([$service_class, 'setException'], NULL);
+
+    // Stage should be automatically deleted when an error occurs.
+    $assert_session->buttonNotExists('Delete existing update');
+    // This ensures that we can still update after the exception no longer
+    // exists.
+    $page->checkField('projects[semver_test]');
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->acceptWarningAndUpdate();
+    $assert_session->statusMessageContains('Update complete!');
+  }
+
+  /**
+   * Data provider for testComposerOperationFailure().
+   *
+   * @return string[][]
+   *   The test cases.
+   */
+  public function providerComposerOperationFailure(): array {
+    return [
+      'LogicException from Beginner' => [LogicException::class, LoggingBeginner::class],
+      'LogicException from Stager' => [LogicException::class, NoOpStager::class],
+      'InvalidArgumentException from Stager' => [InvalidArgumentException::class, NoOpStager::class],
+      'LogicException from Committer' => [LogicException::class, LoggingCommitter::class],
+    ];
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/DisplayUpdatesTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class DisplayUpdatesTest extends UpdaterFormTestBase {
+
+  /**
+   * Data provider for testDisplayUpdates().
+   *
+   * @return array[]
+   *   The test cases.
+   */
+  public function providerDisplayUpdates(): array {
+    return [
+      'with unrequested updates' => [TRUE],
+      'without unrequested updates' => [FALSE],
+    ];
+  }
+
+  /**
+   * Tests the form displays the correct projects which will be updated.
+   *
+   * @param bool $unrequested_updates
+   *   Whether unrequested updates are present during update.
+   *
+   * @dataProvider providerDisplayUpdates
+   */
+  public function testDisplayUpdates(bool $unrequested_updates): void {
+    $this->container->get('theme_installer')->install(['automatic_updates_theme_with_updates']);
+    $this->setReleaseMetadata(__DIR__ . '/../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml');
+    $this->setReleaseMetadata(__DIR__ . "/../../fixtures/release-history/semver_test.1.1.xml");
+    $this->setReleaseMetadata(__DIR__ . "/../../../../package_manager/tests/fixtures/release-history/aaa_update_test.1.1.xml");
+    $this->setProjectInstalledVersion([
+      'semver_test' => '8.1.0',
+      'aaa_update_test' => '8.x-2.0',
+    ]);
+    $this->checkForUpdates();
+    $state = $this->container->get('state');
+    $page = $this->getSession()->getPage();
+
+    // Navigate to the automatic updates form.
+    $this->drupalGet('/admin/reports/updates');
+    $this->clickLink('Update Extensions');
+    $this->assertTableShowsUpdates(
+      'AAA Update test',
+      '8.x-2.0',
+      '8.x-2.1',
+    );
+    $this->assertTableShowsUpdates(
+      'Semver Test',
+      '8.1.0',
+      '8.1.1',
+      2
+    );
+    // User will choose both the projects to update and there will be no
+    // unrequested updates.
+    if ($unrequested_updates === FALSE) {
+      $page->checkField('projects[aaa_update_test]');
+    }
+    $page->checkField('projects[semver_test]');
+    $this->getStageFixtureManipulator()
+      ->setVersion('drupal/aaa_update_test', '2.1.0')
+      ->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->assertUpdateStagedTimes(1);
+    $assert_session = $this->assertSession();
+    // Both projects will be shown as requested updates if there are no
+    // unrequested updates, otherwise one project which user chose will be shown
+    // as requested update and other one will be shown as unrequested update.
+    if ($unrequested_updates === FALSE) {
+      $assert_session->pageTextNotContains('The following dependencies will also be updated:');
+    }
+    else {
+      $assert_session->pageTextContains('The following dependencies will also be updated:');
+    }
+    $assert_session->pageTextContains('The following projects will be updated:');
+    $assert_session->pageTextContains('Semver Test from 8.1.0 to 8.1.1');
+    $assert_session->pageTextContains('AAA Update test from 2.0.0 to 2.1.0');
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/PreUpdateTest.php

+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\fixture_manipulator\ActiveFixtureManipulator;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class PreUpdateTest extends UpdaterFormTestBase {
+
+  /**
+   * Tests the form when modules requiring an update not installed via composer.
+   */
+  public function testNonComposerProjects(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../../../package_manager/tests/fixtures/release-history/aaa_update_test.1.1.xml');
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $this->config('update.settings')
+      ->set('fetch.url', $this->baseUrl . '/test-release-history')
+      ->save();
+    $this->setProjectInstalledVersion(
+      [
+        'aaa_update_test' => '8.x-2.0',
+        'semver_test' => '8.1.0',
+      ]
+    );
+    // One module not installed through composer.
+    (new ActiveFixtureManipulator())
+      ->removePackage('drupal/aaa_update_test')
+      ->commitChanges();
+    $assert = $this->assertSession();
+    $user = $this->createUser(
+      [
+        'administer site configuration',
+        'administer software updates',
+      ]
+    );
+    $this->drupalLogin($user);
+    $this->checkForUpdates();
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $assert->pageTextContains('Other updates were found, but they must be performed manually. See the list of available updates for more information.');
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->assertUpdatesCount(1);
+
+    // Both of the modules not installed through composer.
+    (new ActiveFixtureManipulator())
+      ->removePackage('drupal/semver_test_package_name')
+      ->commitChanges();
+    $this->getSession()->reload();
+    $assert->pageTextContains('Updates were found, but they must be performed manually. See the list of available updates for more information.');
+    $this->assertNoUpdates();
+  }
+
+  /**
+   * Tests the form when a module requires an update.
+   */
+  public function testHasUpdate(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $assert = $this->assertSession();
+    $user = $this->createUser(['administer site configuration']);
+    $this->drupalLogin($user);
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $assert->pageTextContains('Access Denied');
+    $assert->pageTextNotContains('Automatic Updates Form');
+    $user = $this->createUser(['administer software updates', 'administer site configuration']);
+    $this->drupalLogin($user);
+    $this->checkForUpdates();
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $assert->pageTextContains('Automatic Updates Form');
+    $assert->buttonExists('Update');
+  }
+
+  /**
+   * Tests the form when there are no available updates.
+   */
+  public function testNoUpdate(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $user = $this->createUser([
+      'administer site configuration',
+      'administer software updates',
+    ]);
+    $this->drupalLogin($user);
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.1']);
+    $this->checkForUpdates();
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $this->assertNoUpdates();
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/StatusCheckerRunAfterUpdateTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\automatic_updates_test\EventSubscriber\TestSubscriber1;
+use Drupal\package_manager\Event\StatusCheckEvent;
+use Drupal\package_manager\ValidationResult;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class StatusCheckerRunAfterUpdateTest extends UpdaterFormTestBase {
+
+  /**
+   * Data provider for testStatusCheckerRunAfterUpdate().
+   *
+   * @return bool[][]
+   *   The test cases.
+   */
+  public function providerStatusCheckerRunAfterUpdate(): array {
+    return [
+      'has database updates' => [TRUE],
+      'does not have database updates' => [FALSE],
+    ];
+  }
+
+  /**
+   * Tests status checks are run after an update.
+   *
+   * @param bool $has_database_updates
+   *   Whether the site has database updates or not.
+   *
+   * @dataProvider providerStatusCheckerRunAfterUpdate
+   */
+  public function testStatusCheckerRunAfterUpdate(bool $has_database_updates): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    $page = $this->getSession()->getPage();
+    // Navigate to the automatic updates form.
+    $this->drupalGet('/admin/modules/automatic-update-extensions');
+    $assert_session = $this->assertSession();
+    $assert_session->pageTextNotContains(static::$errorsExplanation);
+    $assert_session->pageTextNotContains(static::$warningsExplanation);
+
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $page->checkField('projects[semver_test]');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->assertUpdateStagedTimes(1);
+    // Set an error before completing the update. This error should be visible
+    // on admin pages after completing the update without having to explicitly
+    // run the status checks.
+    TestSubscriber1::setTestResult([ValidationResult::createError([t('Error before continue.')])], StatusCheckEvent::class);
+    if ($has_database_updates) {
+      // 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);
+      $this->acceptWarningAndUpdate();
+      $assert_session->pageTextContainsOnce('An error has occurred.');
+      $assert_session->pageTextContainsOnce('Continue to the error page');
+      $page->clickLink('the error page');
+      $assert_session->pageTextContains('Some modules have database schema updates to install. You should run the database update script immediately.');
+      $assert_session->linkExists('database update script');
+      $assert_session->linkByHrefExists('/update.php');
+      $page->clickLink('database update script');
+      $this->assertSession()->addressEquals('/update.php');
+      $assert_session->pageTextNotContains('Possible database updates have been detected in the following extension');
+      $page->clickLink('Continue');
+      // @see automatic_updates_update_1191934()
+      $assert_session->pageTextContains('Dynamic automatic_updates_update_1191934');
+      $page->clickLink('Apply pending updates');
+      $this->checkForMetaRefresh();
+      $assert_session->pageTextContains('Updates were attempted.');
+    }
+    else {
+      $this->acceptWarningAndUpdate();
+      $assert_session->addressEquals('/admin/reports/updates');
+      $assert_session->pageTextContainsOnce('Update complete!');
+    }
+    // Status checks should display errors on admin page.
+    $this->drupalGet('/admin');
+    // Confirm that the status checks were run and the new error is displayed.
+    $assert_session->statusMessageContains('Error before continue.', 'error');
+    $assert_session->statusMessageContains('Your site does not pass some readiness checks for automatic updates. It cannot be automatically updated until further action is performed.', 'error');
+    $assert_session->pageTextNotContains('Your site has not recently run an update readiness check. Rerun readiness checks now.');
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/SuccessfulUpdateTest.php

+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\package_manager\Event\PreApplyEvent;
+use Drupal\package_manager\LegacyVersionUtility;
+use Drupal\package_manager_test_validation\StagedDatabaseUpdateValidator;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class SuccessfulUpdateTest extends UpdaterFormTestBase {
+
+  /**
+   * Data provider for testSuccessfulUpdate().
+   *
+   * @return mixed[][]
+   *   The test cases.
+   */
+  public function providerSuccessfulUpdate(): array {
+    return [
+      'maintenance mode on, semver module' => [
+        TRUE, 'semver_test', 'drupal/semver_test_package_name', 'Semver Test', '8.1.0', '8.1.1',
+      ],
+      'maintenance mode off, legacy module' => [
+        FALSE, 'aaa_update_test', 'drupal/aaa_update_test', 'AAA Update test', '8.x-2.0', '8.x-2.1',
+      ],
+      'maintenance mode off, legacy theme' => [
+        FALSE, 'automatic_updates_extensions_test_theme', 'drupal/automatic_updates_extensions_test_theme', 'Automatic Updates Extensions Test Theme', '8.x-2.0', '8.x-2.1',
+      ],
+    ];
+  }
+
+  /**
+   * Tests an update that has no errors or special conditions.
+   *
+   * @param bool $maintenance_mode_on
+   *   Whether maintenance should be on at the beginning of the update.
+   * @param string $project_name
+   *   The project name.
+   * @param string $package_name
+   *   The package name.
+   * @param string $project_title
+   *   The project title.
+   * @param string $installed_version
+   *   The installed version.
+   * @param string $target_version
+   *   The target version.
+   *
+   * @dataProvider providerSuccessfulUpdate
+   */
+  public function testSuccessfulUpdate(bool $maintenance_mode_on, string $project_name, string $package_name, string $project_title, string $installed_version, string $target_version): void {
+    $this->container->get('theme_installer')->install(['automatic_updates_theme_with_updates']);
+    // By default, the Update module only checks for updates of installed
+    // modules and themes. The two modules we're testing here (semver_test and
+    // aaa_update_test) are already installed by static::$modules.
+    $this->container->get('theme_installer')->install(['automatic_updates_extensions_test_theme']);
+    $this->setReleaseMetadata(__DIR__ . '/../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml');
+    $path_to_fixtures_folder = $project_name === 'aaa_update_test' ? '/../../../../package_manager/tests' : '/../..';
+    $this->setReleaseMetadata(__DIR__ . $path_to_fixtures_folder . '/fixtures/release-history/' . $project_name . '.1.1.xml');
+    $this->setProjectInstalledVersion([$project_name => $installed_version]);
+    $this->getStageFixtureManipulator()->setVersion($package_name, LegacyVersionUtility::convertToSemanticVersion($target_version));
+    $this->checkForUpdates();
+    $state = $this->container->get('state');
+    $state->set('system.maintenance_mode', $maintenance_mode_on);
+    StagedDatabaseUpdateValidator::setExtensionsWithUpdates([
+      'system',
+      'automatic_updates_theme_with_updates',
+    ]);
+
+    $page = $this->getSession()->getPage();
+    // Navigate to the automatic updates form.
+    $this->drupalGet('/admin/reports/updates');
+    $this->clickLink('Update Extensions');
+    $this->assertTableShowsUpdates(
+      $project_title,
+      $installed_version,
+      $target_version
+    );
+    $assert_session = $this->assertSession();
+    $this->assertUpdatesCount(1);
+
+    // Submit without selecting a project.
+    $page->pressButton('Update');
+    $assert_session->pageTextContains('Select one or more projects.');
+
+    // Submit with a project selected.
+    $page->checkField('projects[' . $project_name . ']');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->assertUpdateStagedTimes(1);
+    // Confirm that the site was put into maintenance mode if needed.
+    $this->assertSame($state->get('system.maintenance_mode'), $maintenance_mode_on);
+
+    $assert_session->pageTextNotContains('The following dependencies will also be updated:');
+    // Ensure that a list of pending database updates is visible, along with a
+    // short explanation, in the warning messages.
+    $warning_messages = $assert_session->elementExists('xpath', '//div[@data-drupal-messages]//div[@aria-label="Warning message"]');
+    $this->assertStringContainsString('Database updates have been detected in the following extensions.<ul><li>System</li><li>Automatic Updates Theme With Updates</li></ul>', $warning_messages->getHtml());
+
+    $this->acceptWarningAndUpdate();
+    $assert_session->addressEquals('/admin/reports/updates');
+    // 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);
+    // Confirm that the apply and post-apply operations happened in
+    // separate requests.
+    // @see \Drupal\automatic_updates_test\EventSubscriber\RequestTimeRecorder
+    $pre_apply_time = $state->get('Drupal\package_manager\Event\PreApplyEvent time');
+    $post_apply_time = $state->get('Drupal\package_manager\Event\PostApplyEvent time');
+    $this->assertNotEmpty($pre_apply_time);
+    $this->assertNotEmpty($post_apply_time);
+    $this->assertNotSame($pre_apply_time, $post_apply_time);
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/UnsuccessfulUpdateTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\automatic_updates_test\EventSubscriber\TestSubscriber1;
+use Drupal\package_manager\Event\StatusCheckEvent;
+use Drupal\package_manager\ValidationResult;
+use Drupal\package_manager_test_validation\EventSubscriber\TestSubscriber;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class UnsuccessfulUpdateTest extends UpdaterFormTestBase {
+
+  /**
+   * Test the form for warning messages.
+   */
+  public function testWarnings(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $assert = $this->assertSession();
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    $message = t("Warning! Updating this module may cause an error.");
+    $warning = ValidationResult::createWarning([$message]);
+    TestSubscriber1::setTestResult([$warning], StatusCheckEvent::class);
+    // Navigate to the automatic updates form.
+    $this->drupalGet('/admin/reports/updates');
+    $this->clickLink('Update Extensions');
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $this->checkForMetaRefresh();
+    $assert->pageTextNotContains(static::$errorsExplanation);
+    $assert->elementExists('css', '#edit-projects-semver-test')->check();
+    $assert->checkboxChecked('edit-projects-semver-test');
+    // No explanation is given for warnings.
+    $assert->pageTextNotContains(static::$warningsExplanation);
+    $assert->buttonExists('Update');
+
+    // Add warnings from StatusCheckEvent.
+    $summary_status_check_event = t('Some summary');
+    $messages_status_check_event = [
+      t("The only thing we're allowed to do is to"),
+      t("believe that we won't regret the choice"),
+      t("we made."),
+    ];
+    $warning_status_check_event = ValidationResult::createWarning($messages_status_check_event, $summary_status_check_event);
+    TestSubscriber::setTestResult([$warning_status_check_event], StatusCheckEvent::class);
+    $this->getSession()->getPage()->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $assert->buttonExists('Continue');
+    $assert->pageTextContains((string) $summary_status_check_event);
+    foreach ($messages_status_check_event as $message) {
+      $assert->pageTextContains((string) $message);
+    }
+  }
+
+  /**
+   * Tests the form when an uninstallable module requires an update.
+   */
+  public function testUninstallableRelease(): void {
+    $this->container->get('state')->set('testUninstallableRelease', TRUE);
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $user = $this->createUser(['administer software updates', 'administer site configuration']);
+    $this->drupalLogin($user);
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $this->checkForUpdates();
+    $this->assertNoUpdates();
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/UpdateErrorTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\automatic_updates_test\EventSubscriber\TestSubscriber1;
+use Drupal\package_manager\Event\StatusCheckEvent;
+use Drupal\package_manager\ValidationResult;
+use Drupal\package_manager_bypass\LoggingCommitter;
+use Drupal\package_manager_test_validation\EventSubscriber\TestSubscriber;
+
+/**
+ * @covers \Drupal\automatic_updates_extensions\Form\UpdaterForm
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class UpdateErrorTest extends UpdaterFormTestBase {
+
+  /**
+   * Tests that an exception is thrown if a previous apply failed.
+   */
+  public function testMarkerFileFailure(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    $page = $this->getSession()->getPage();
+    // Navigate to the automatic updates form.
+    $this->drupalGet('/admin/modules/automatic-update-extensions');
+    $assert_session = $this->assertSession();
+    $assert_session->pageTextNotContains(static::$errorsExplanation);
+    $assert_session->pageTextNotContains(static::$warningsExplanation);
+
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test_package_name', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $page->checkField('projects[semver_test]');
+    $page->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $this->assertUpdateStagedTimes(1);
+    $assert_session->pageTextNotContains('The following dependencies will also be updated:');
+    LoggingCommitter::setException(new \Exception('failed at committer'));
+    $this->acceptWarningAndUpdate();
+    $failure_message = 'Automatic updates failed to apply, and the site is in an indeterminate state. Consider restoring the code and database from a backup.';
+    $assert_session->pageTextContainsOnce('An error has occurred.');
+    $assert_session->pageTextContains($failure_message);
+    $page->clickLink('the error page');
+
+    // We should be on the form (i.e., 200 response code), but unable to
+    // continue the update.
+    $assert_session->statusCodeEquals(200);
+    $assert_session->pageTextContains($failure_message);
+    $assert_session->buttonNotExists('Continue');
+    // The same thing should be true if we try to start from the beginning.
+    $this->drupalGet('/admin/modules/automatic-update-extensions');
+    $assert_session->statusCodeEquals(200);
+    $assert_session->pageTextContains($failure_message);
+    $assert_session->buttonNotExists('Update');
+  }
+
+  /**
+   * Test the form for errors.
+   */
+  public function testErrors(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $assert = $this->assertSession();
+    $user = $this->createUser([
+      'administer site configuration',
+      'administer software updates',
+    ]);
+    $this->drupalLogin($user);
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $message = t("You've not experienced Shakespeare until you have read him in the original Klingon.");
+    $error = ValidationResult::createError([$message]);
+    TestSubscriber1::setTestResult([$error], StatusCheckEvent::class);
+    $this->getSession()->reload();
+    $assert->pageTextContains((string) $message);
+    $assert->pageTextContains(static::$errorsExplanation);
+    $assert->pageTextNotContains(static::$warningsExplanation);
+    $assert->buttonNotExists('Update');
+  }
+
+  /**
+   * Tests that messages from StatusCheckEvent are shown on the confirmation form.
+   */
+  public function testStatusErrorMessages(): void {
+    $this->setReleaseMetadata(__DIR__ . '/../../fixtures/release-history/semver_test.1.1.xml');
+    $assert = $this->assertSession();
+    $this->setProjectInstalledVersion(['semver_test' => '8.1.0']);
+    $this->checkForUpdates();
+    $this->drupalGet('admin/reports/updates/automatic-update-extensions');
+    $this->assertTableShowsUpdates('Semver Test', '8.1.0', '8.1.1');
+    $this->assertUpdatesCount(1);
+    $this->getSession()->reload();
+    $assert->elementExists('css', '#edit-projects-semver-test')->check();
+    $assert->checkboxChecked('edit-projects-semver-test');
+    $assert->buttonExists('Update');
+    $messages = [
+      t("The only thing we're allowed to do is to"),
+      t("believe that we won't regret the choice"),
+      t("we made."),
+    ];
+    $summary = t('Some summary');
+    $error = ValidationResult::createError($messages, $summary);
+    TestSubscriber::setTestResult([$error], StatusCheckEvent::class);
+    $this->getSession()->getPage()->pressButton('Update');
+    $this->checkForMetaRefresh();
+    $assert->pageTextContains(static::$errorsExplanation);
+    $assert->pageTextNotContains(static::$warningsExplanation);
+    $assert->pageTextContains((string) $summary);
+    foreach ($messages as $message) {
+      $assert->pageTextContains((string) $message);
+    }
+    $assert->buttonNotExists('Continue');
+  }
+
+}

automatic_updates_extensions/tests/src/Functional/UpdaterFormTestBase.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Functional;
+
+use Drupal\fixture_manipulator\ActiveFixtureManipulator;
+use Drupal\package_manager\PathLocator;
+use Drupal\Tests\automatic_updates_extensions\Traits\FormTestTrait;
+use Drupal\Tests\automatic_updates\Functional\UpdaterFormTestBase as UpdaterFormFunctionalTestBase;
+
+/**
+ * Base class for functional tests of updater form.
+ *
+ * @internal
+ *   This class is an internal part of the module's testing infrastructure and
+ *   should not be used by external code.
+ */
+abstract class UpdaterFormTestBase extends UpdaterFormFunctionalTestBase {
+
+  use FormTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $errorsExplanation = 'Your site cannot be automatically updated until further action is performed.';
+
+  /**
+   * The path of the test project's active directory.
+   *
+   * @var string
+   */
+  private $activeDir;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'automatic_updates_extensions',
+    'semver_test',
+    'aaa_update_test',
+    'automatic_updates_extensions_test',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->activeDir = $this->container->get(PathLocator::class)->getProjectRoot();
+    (new ActiveFixtureManipulator())
+      // Add a package where the Composer package name,
+      // drupal/semver_test_package_name, does not match the project name,
+      // semver_test.
+      ->addPackage(
+        [
+          'name' => 'drupal/semver_test_package_name',
+          'version' => '8.1.0',
+          'type' => 'drupal-module',
+        ],
+        extra_files: [
+          'semver_test.info.yml' => '{name: "Semver Test", project: "semver_test", type: "module"}',
+        ]
+      )
+      ->addPackage([
+        'name' => 'drupal/aaa_update_test',
+        'version' => '2.0.0',
+        'type' => 'drupal-module',
+      ])
+      ->addPackage([
+        'name' => 'drupal/automatic_updates_extensions_test_theme',
+        'version' => '2.0.0',
+        'type' => 'drupal-theme',
+      ])
+      ->commitChanges();
+    $this->drupalPlaceBlock('local_tasks_block', ['primary' => TRUE]);
+  }
+
+  /**
+   * Sets installed project version.
+   *
+   * @todo Remove this function with use of the trait from the Update module in
+   *   https://drupal.org/i/3348234.
+   */
+  protected function setProjectInstalledVersion($project_versions): void {
+    $this->config('update.settings')
+      ->set('fetch.url', $this->baseUrl . '/test-release-history')
+      ->save();
+    $system_info = [];
+    foreach ($project_versions as $project_name => $version) {
+      $system_info[$project_name] = [
+        'project' => $project_name,
+        'version' => $version,
+        'hidden' => FALSE,
+      ];
+    }
+    $system_info['drupal'] = [
+      'project' => 'drupal',
+      'version' => '8.0.0',
+      'hidden' => FALSE,
+    ];
+    $this->config('update_test.settings')
+      ->set('system_info', $system_info)
+      ->save();
+  }
+
+  /**
+   * Asserts the table shows the updates.
+   *
+   * @param string $expected_project_title
+   *   The expected project title.
+   * @param string $expected_installed_version
+   *   The expected installed version.
+   * @param string $expected_target_version
+   *   The expected target version.
+   * @param int $row
+   *   The row number.
+   */
+  protected function assertTableShowsUpdates(string $expected_project_title, string $expected_installed_version, string $expected_target_version, int $row = 1): void {
+    $this->assertUpdateTableRow($this->assertSession(), $expected_project_title, $expected_installed_version, $expected_target_version, $row);
+  }
+
+  /**
+   * Asserts the form shows no updates.
+   */
+  protected function assertNoUpdates(): void {
+    $assert = $this->assertSession();
+    $assert->buttonNotExists('Update');
+    $assert->pageTextContains('There are no available updates.');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function checkForUpdates(): void {
+    $this->drupalGet('/admin/modules/automatic-update-extensions');
+    $this->clickLink('Check manually');
+    $this->checkForMetaRefresh();
+  }
+
+  /**
+   * Continue the update after checking the backup warning checkbox.
+   */
+  protected function acceptWarningAndUpdate(): void {
+    $page = $this->getSession()->getPage();
+    $page->pressButton('Continue');
+    $this->assertSession()->statusMessageContains('Warning: Updating contributed modules or themes may leave your site inoperable or looking wrong. field is required.', 'error');
+    $page->checkField('backup');
+    $page->pressButton('Continue');
+    $this->checkForMetaRefresh();
+  }
+
+}

automatic_updates_extensions/tests/src/Kernel/AutomaticUpdatesExtensionsKernelTestBase.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Kernel;
+
+use Drupal\automatic_updates_extensions\ExtensionUpdateStage;
+use Drupal\fixture_manipulator\ActiveFixtureManipulator;
+use Drupal\package_manager\Event\PreOperationStageEvent;
+use Drupal\package_manager\Exception\StageEventException;
+use Drupal\package_manager\Validator\ComposerValidator;
+use Drupal\Tests\automatic_updates\Kernel\AutomaticUpdatesKernelTestBase;
+
+/**
+ * Base class for kernel tests of the Automatic Updates Extensions module.
+ *
+ * @internal
+ *   This class is an internal part of the module's testing infrastructure and
+ *   should not be used by external code.
+ */
+abstract class AutomaticUpdatesExtensionsKernelTestBase extends AutomaticUpdatesKernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'automatic_updates_extensions',
+    'package_manager_test_release_history',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    // Disable the Composer executable validator, since it may cause the tests
+    // to fail if a supported version of Composer is unavailable to the web
+    // server. This should be okay in most situations because, apart from the
+    // validator, only Composer Stager needs run Composer, and
+    // package_manager_bypass is disabling those operations.
+    $this->disableValidators[] = ComposerValidator::class;
+    parent::setUp();
+    // Install additional packages that will be needed in tests.
+    (new ActiveFixtureManipulator())
+      ->addPackage([
+        "name" => "drupal/my_module",
+        "version" => "9.8.0",
+        "type" => "drupal-module",
+      ])
+      ->addPackage([
+        "name" => "drupal/contrib_profile1",
+        "version" => "1.0.0",
+        "type" => "drupal-profile",
+      ])
+      ->addPackage([
+        "name" => "drupal/my_dev_module",
+        "version" => "9.8.1",
+        "type" => "drupal-module",
+      ], TRUE)
+      ->addPackage([
+        "name" => "drupal/semver_test",
+        "version" => "8.1.0",
+        "type" => "drupal-module",
+      ])
+      ->addPackage([
+        "name" => "drupal/aaa_update_test",
+        "version" => "1.0.0",
+        "type" => "drupal-module",
+      ])
+      ->addPackage([
+        "name" => "drupal/package_manager_test_update",
+        "version" => "1.0.0",
+        "type" => "drupal-module",
+      ])->commitChanges();
+  }
+
+  /**
+   * Asserts validation results are returned from a stage life cycle event.
+   *
+   * @param string[] $project_versions
+   *   The project versions.
+   * @param \Drupal\package_manager\ValidationResult[] $expected_results
+   *   The expected validation results.
+   * @param string|null $event_class
+   *   (optional) The class of the event which should return the results. Must
+   *   be passed if $expected_results is not empty.
+   */
+  protected function assertUpdateResults(array $project_versions, array $expected_results, string $event_class = NULL): void {
+    $stage = $this->container->get(ExtensionUpdateStage::class);
+
+    try {
+      $stage->begin($project_versions);
+      $stage->stage();
+      $stage->apply();
+      $stage->postApply();
+      $stage->destroy();
+
+      // If we did not get an exception, ensure we didn't expect any results.
+      $this->assertEmpty($expected_results);
+    }
+    catch (StageEventException $e) {
+      $this->assertNotEmpty($expected_results);
+      $exception_event = $e->event;
+      $this->assertInstanceOf($event_class, $exception_event);
+      $this->assertInstanceOf(PreOperationStageEvent::class, $exception_event);
+      $this->assertValidationResultsEqual($expected_results, $e->event->getResults());
+    }
+  }
+
+}

automatic_updates_extensions/tests/src/Kernel/ExtensionUpdateStageTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Kernel;
+
+use Drupal\automatic_updates_extensions\ExtensionUpdateStage;
+use Drupal\automatic_updates_extensions\Validator\UpdateReleaseValidator;
+use Drupal\Tests\user\Traits\UserCreationTrait;
+use PhpTuf\ComposerStager\API\Core\StagerInterface;
+
+/**
+ * @coversDefaultClass \Drupal\automatic_updates_extensions\ExtensionUpdateStage
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class ExtensionUpdateStageTest extends AutomaticUpdatesExtensionsKernelTestBase {
+
+  use UserCreationTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'automatic_updates',
+    'automatic_updates_test',
+    'automatic_updates_extensions',
+    'user',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    // This test doesn't need to validate that the test projects used are in the
+    // codebase. Therefore, we need to disable the following validators that
+    // require real Drupal projects.
+    $this->disableValidators[] = UpdateReleaseValidator::class;
+    parent::setUp();
+    $this->installEntitySchema('user');
+
+    // Create a user who will own the stage even after the container is rebuilt.
+    $user = $this->createUser([], NULL, TRUE, ['uid' => 2]);
+    $this->setCurrentUser($user);
+  }
+
+  /**
+   * Tests that correct versions are staged after calling ::begin().
+   */
+  public function testCorrectVersionsStaged(): void {
+    $id = $this->container->get(ExtensionUpdateStage::class)->begin([
+      'my_module' => '9.8.1',
+      // Use a legacy version number to ensure they are converted to semantic
+      // version numbers which will work with the drupal.org Composer facade.
+      'my_dev_module' => '8.x-1.2-alpha1@alpha',
+    ]);
+    $user = $this->container->get('current_user')->getAccount();
+    // Rebuild the container to ensure the package versions are persisted.
+    /** @var \Drupal\Core\DrupalKernel $kernel */
+    $kernel = $this->container->get('kernel');
+    $kernel->rebuildContainer();
+    $this->container = $kernel->getContainer();
+    // Keep using the user account we created.
+    $this->setCurrentUser($user);
+
+    $stage = $this->container->get(ExtensionUpdateStage::class);
+
+    // Ensure that the target package versions are what we expect.
+    $expected_versions = [
+      'production' => [
+        'drupal/my_module' => '9.8.1',
+      ],
+      'dev' => [
+        'drupal/my_dev_module' => '1.2.0-alpha1@alpha',
+      ],
+    ];
+    $this->assertSame($expected_versions, $stage->claim($id)->getPackageVersions());
+
+    // When we call ExtensionUpdateStage::stage(), the stored project versions
+    // should be read from state and passed to Composer Stager's Stager service,
+    // in the form of a Composer command. This is done using
+    // package_manager_bypass's invocation recorder, rather than a regular mock,
+    // in order to test that the invocation recorder itself works. The
+    // production requirements are changed first, followed by the dev
+    // requirements. Then the installed packages are updated. This is tested
+    // functionally in Package Manager.
+    // @see \Drupal\Tests\package_manager\Build\StagedUpdateTest
+    $expected_arguments = [
+      [
+        'require',
+        '--no-update',
+        'drupal/my_module:9.8.1',
+      ],
+      [
+        'require',
+        '--dev',
+        '--no-update',
+        'drupal/my_dev_module:1.2.0-alpha1@alpha',
+      ],
+      [
+        'update',
+        '--with-all-dependencies',
+        '--optimize-autoloader',
+        'drupal/my_module:9.8.1',
+        'drupal/my_dev_module:1.2.0-alpha1@alpha',
+      ],
+    ];
+    $stage->stage();
+
+    $actual_arguments = $this->container->get(StagerInterface::class)
+      ->getInvocationArguments();
+
+    $this->assertCount(count($expected_arguments), $actual_arguments);
+    foreach ($actual_arguments as $i => [$arguments]) {
+      $this->assertSame($expected_arguments[$i], $arguments);
+    }
+  }
+
+  /**
+   * Tests that attempting to update an install profile throws an exception.
+   */
+  public function testUpdatingInstallProfile(): void {
+    $this->expectException(\InvalidArgumentException::class);
+    $this->expectExceptionMessage("The project contrib_profile1 cannot be updated because updating install profiles is not supported.");
+
+    $this->container->get(ExtensionUpdateStage::class)
+      ->begin([
+        'contrib_profile1' => '1.1.0',
+      ]);
+  }
+
+  /**
+   * Tests that an exception is thrown when calling begin() with no projects.
+   */
+  public function testNoProjectsInBegin(): void {
+    $this->expectException(\InvalidArgumentException::class);
+    $this->expectExceptionMessage('No projects to begin the update');
+    $this->container->get(ExtensionUpdateStage::class)->begin([]);
+  }
+
+  /**
+   * Tests exception if a Drupal project unknown to composer sent to ::begin().
+   */
+  public function testUnknownDrupalProject(): void {
+    $this->expectException(\InvalidArgumentException::class);
+    $this->expectExceptionMessage("The project my_module_unknown is not a Drupal project known to Composer and cannot be updated.");
+    $this->container->get(ExtensionUpdateStage::class)->begin([
+      'my_module_unknown' => '9.8.1',
+    ]);
+  }
+
+}

automatic_updates_extensions/tests/src/Kernel/Validator/ForbidCoreChangesValidatorTest.php

+<?php
+
+namespace Drupal\Tests\automatic_updates_extensions\Kernel\Validator;
+
+use Drupal\automatic_updates_extensions\ExtensionUpdateStage;
+use Drupal\package_manager\Exception\StageEventException;
+use Drupal\package_manager\ValidationResult;
+use Drupal\Tests\automatic_updates_extensions\Kernel\AutomaticUpdatesExtensionsKernelTestBase;
+
+/**
+ * @coversDefaultClass \Drupal\automatic_updates_extensions\Validator\ForbidCoreChangesValidator
+ * @group automatic_updates_extensions
+ * @internal
+ */
+class ForbidCoreChangesValidatorTest extends AutomaticUpdatesExtensionsKernelTestBase {
+
+  /**
+   * Tests error messages if requested updates were not staged.
+   *
+   * @param array $staged_versions
+   *   An array of the staged versions where the keys are the package names and
+   *   the values are the package versions or NULL if the package should be
+   *   removed in the stage.
+   * @param string[][] $new_packages
+   *   An array of the new packages to add to the stage.
+   * @param \Drupal\package_manager\ValidationResult[] $expected_results
+   *   The expected validation results.
+   *
+   * @dataProvider providerTestErrorMessage
+   */
+  public function testErrorMessages(array $staged_versions, array $new_packages, array $expected_results): void {
+    $this->setReleaseMetadata([
+      'semver_test' => __DIR__ . '/../../../fixtures/release-history/semver_test.1.1.xml',
+      'drupal' => __DIR__ . '/../../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml',
+    ]);
+    $this->getStageFixtureManipulator()->addPackage([
+      'name' => 'drupal/non-core',
+      'version' => '1.0.0',
+      'type' => 'package',
+    ]);
+
+    foreach ($staged_versions as $package => $version) {
+      if ($version === NULL) {
+        $this->getStageFixtureManipulator()->removePackage($package);
+        continue;
+      }
+      $this->getStageFixtureManipulator()->setVersion($package, $version);
+    }
+    foreach ($new_packages as $package) {
+      $this->getStageFixtureManipulator()->addPackage($package);
+    }
+    $this->getStageFixtureManipulator()->setVersion('drupal/semver_test', '8.1.1');
+
+    $stage = $this->container->get(ExtensionUpdateStage::class);
+    $stage->begin([
+      'semver_test' => '8.1.1',
+    ]);
+    $stage->stage();
+    $this->assertStatusCheckResults($expected_results, $stage);
+    try {
+      $stage->apply();
+      $this->fail('Expecting an exception.');
+    }
+    catch (StageEventException $exception) {
+      $this->assertExpectedResultsFromException($expected_results, $exception);
+    }
+  }
+
+  /**
+   * Data provider for testErrorMessage().
+   *
+   * @return mixed[]
+   *   The test cases.
+   */
+  public function providerTestErrorMessage(): array {
+    $summary = t('Updating Drupal Core while updating extensions is currently not supported. Use <a href="/admin/reports/updates/update">this form</a> to update Drupal core. The following changes were made to the Drupal core packages:');
+    return [
+      'drupal/core updated, non-core updated' => [
+        [
+          'drupal/core' => '9.8.1',
+          'drupal/non-core' => '1.0.1',
+        ],
+        [],
+        [ValidationResult::createError([t("'drupal/core' version changed from 9.8.0 to 9.8.1.")], $summary)],
+      ],
+      'drupal/core-recommended and drupal/core updated, non-core package installed' => [
+        [
+          'drupal/core-recommended' => '9.8.1',
+          'drupal/core' => '9.8.1',
+        ],
+        [
+          [
+            'name' => 'other-org/other-package',
+            'type' => 'package',
+          ],
+        ],
+        [
+          ValidationResult::createError(
+            [
+              t("'drupal/core-recommended' version changed from 9.8.0 to 9.8.1."),
+              t("'drupal/core' version changed from 9.8.0 to 9.8.1."),
+            ],
+            $summary
+          ),
+        ],
+      ],
+      'drupal/core-recommended removed, drupal/core updated, drupal/core-composer-scaffold installed, non-core package removed' => [
+        [
+          'drupal/core-recommended' => NULL,
+          'drupal/core' => '9.8.1',
+          'drupal/non-core' => NULL,
+        ],
+        [
+          [
+            'name' => 'drupal/core-composer-scaffold',
+            'type' => 'package',
+          ],
+        ],
+        [
+          ValidationResult::createError(
+            [
+              t("'drupal/core-composer-scaffold' installed."),
+              t("'drupal/core-recommended' removed."),
+              t("'drupal/core' version changed from 9.8.0 to 9.8.1."),
+            ],
+            $summary
+          ),
+        ],
+      ],
+    ];
+  }
+
+}

automatic_updates_extensions/tests/src/Kernel/Validator/RequestedUpdateValidatorTest.php

+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Kernel\Validator;
+
+use Drupal\automatic_updates_extensions\ExtensionUpdateStage;
+use Drupal\fixture_manipulator\ActiveFixtureManipulator;
+use Drupal\package_manager\Exception\StageEventException;
+use Drupal\package_manager\ValidationResult;
+use Drupal\Tests\automatic_updates_extensions\Kernel\AutomaticUpdatesExtensionsKernelTestBase;
+
+/**
+ * @coversDefaultClass \Drupal\automatic_updates_extensions\Validator\RequestedUpdateValidator
+ * @group automatic_updates_extensions
+ * @internal
+ */
+class RequestedUpdateValidatorTest extends AutomaticUpdatesExtensionsKernelTestBase {
+
+  /**
+   * Tests error messages if requested updates were not staged.
+   *
+   * @param array $staged_versions
+   *   An array of the staged versions where the keys are the package names and
+   *   the values are the package versions.
+   * @param array $expected_results
+   *   The expected validation results.
+   *
+   * @dataProvider providerTestErrorMessage
+   */
+  public function testErrorMessage(array $staged_versions, array $expected_results): void {
+    if ($staged_versions) {
+      // If we are going to stage updates to Drupal packages also update a
+      // non-Drupal. The validator should ignore the non-Drupal packages.
+      (new ActiveFixtureManipulator())
+        ->addPackage([
+          "name" => 'vendor/non-drupal-package',
+          "version" => "1.0.0",
+          "type" => "drupal-module",
+        ])
+        ->commitChanges();
+      $this->getStageFixtureManipulator()->setVersion('vendor/non-drupal-package', '1.0.1');
+      foreach ($staged_versions as $package => $version) {
+        $this->getStageFixtureManipulator()->setVersion($package, $version);
+      }
+    }
+
+    $this->setReleaseMetadata([
+      'semver_test' => __DIR__ . '/../../../fixtures/release-history/semver_test.1.1.xml',
+      'drupal' => __DIR__ . '/../../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml',
+      'aaa_update_test' => __DIR__ . "/../../../../../package_manager/tests/fixtures/release-history/aaa_update_test.1.1.xml",
+    ]);
+    // Set the project version to '8.0.1' so that there 2 versions of above this
+    // that will be in the list of supported releases, 8.1.0 and 8.1.1.
+    (new ActiveFixtureManipulator())
+      ->setVersion('drupal/semver_test', '8.0.1')
+      ->commitChanges();
+    // @todo Replace with use of the trait from the Update module in https://drupal.org/i/3348234.
+    $module_info = ['version' => '8.0.1', 'project' => 'semver_test'];
+    $this->config('update_test.settings')
+      ->set("system_info.semver_test", $module_info)
+      ->save();
+
+    $stage = $this->container->get(ExtensionUpdateStage::class);
+    $stage->begin([
+      'semver_test' => '8.1.1',
+      'aaa_update_test' => '8.x-1.1',
+    ]);
+    $stage->stage();
+    $this->assertStatusCheckResults($expected_results, $stage);
+    try {
+      $stage->apply();
+      $this->fail('Expecting an exception.');
+    }
+    catch (StageEventException $exception) {
+      $this->assertExpectedResultsFromException($expected_results, $exception);
+    }
+  }
+
+  /**
+   * Data provider for testErrorMessage().
+   *
+   * @return mixed[]
+   *   The test cases.
+   */
+  public function providerTestErrorMessage() {
+    return [
+      'no updates' => [
+        [],
+        [
+          ValidationResult::createError([t('No updates detected in the staging area.')]),
+        ],
+      ],
+      '1 project not updated' => [
+        [
+          'drupal/aaa_update_test' => '1.1.0',
+        ],
+        [
+          ValidationResult::createError([t("The requested update to 'drupal/semver_test' to version '8.1.1' was not performed.")]),
+        ],
+      ],
+      'project updated to wrong version' => [
+        [
+          'drupal/semver_test' => '8.1.0',
+          'drupal/aaa_update_test' => '1.1.0',
+        ],
+        [
+          ValidationResult::createError([t("The requested update to 'drupal/semver_test' to version '8.1.1' does not match the actual staged update to '8.1.0'.")]),
+        ],
+      ],
+    ];
+  }
+
+}

automatic_updates_extensions/tests/src/Kernel/Validator/UpdateReleaseValidatorTest.php

+<?php
+
+declare(strict_types = 1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Kernel\Validator;
+
+use Drupal\package_manager\LegacyVersionUtility;
+use Drupal\package_manager\Event\PreCreateEvent;
+use Drupal\package_manager\ValidationResult;
+use Drupal\Tests\automatic_updates_extensions\Kernel\AutomaticUpdatesExtensionsKernelTestBase;
+
+/**
+ * @coversDefaultClass \Drupal\automatic_updates_extensions\Validator\UpdateReleaseValidator
+ * @group automatic_updates_extensions
+ * @internal
+ */
+final class UpdateReleaseValidatorTest extends AutomaticUpdatesExtensionsKernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['automatic_updates'];
+
+  /**
+   * Data provider for testPreCreateException().
+   *
+   * @return mixed[][]
+   *   The test cases.
+   */
+  public function providerTestPreCreateException(): array {
+    return [
+      'semver, supported update' => ['semver_test', '8.1.0', '8.1.1', FALSE],
+      'semver, update to unsupported branch' => ['semver_test', '8.1.0', '8.2.0', TRUE],
+      'legacy, supported update' => ['aaa_update_test', '8.x-2.0', '8.x-2.1', FALSE],
+      'legacy, update to unsupported branch' => ['aaa_update_test', '8.x-2.0', '8.x-3.0', TRUE],
+    ];
+  }
+
+  /**
+   * Tests updating to a release during pre-create.
+   *
+   * @param string $project
+   *   The project to update.
+   * @param string $installed_version
+   *   The installed version of the project.
+   * @param string $target_version
+   *   The target version.
+   * @param bool $error_expected
+   *   Whether an error is expected in the update.
+   *
+   * @dataProvider providerTestPreCreateException
+   */
+  public function testPreCreateException(string $project, string $installed_version, string $target_version, bool $error_expected): void {
+    $this->enableModules([$project]);
+
+    // @todo Replace with use of the trait from the Update module in https://drupal.org/i/3348234.
+    $module_info = ['version' => $installed_version, 'project' => $project];
+    $this->config('update_test.settings')
+      ->set("system_info.$project", $module_info)
+      ->save();
+
+    $path_to_fixtures_folder = $project === 'aaa_update_test' ? '/../../../../../package_manager/tests/' : '/../../../';
+    $this->setReleaseMetadata([
+      $project => __DIR__ . $path_to_fixtures_folder . "fixtures/release-history/$project.1.1.xml",
+      'drupal' => __DIR__ . '/../../../../../package_manager/tests/fixtures/release-history/drupal.9.8.2.xml',
+    ]);
+
+    if ($error_expected) {
+      $expected_results = [
+        ValidationResult::createError(
+          [
+            t('Project @project to version @target_version', [
+              '@project' => $project,
+              '@target_version' => LegacyVersionUtility::convertToSemanticVersion($target_version),
+            ]),
+          ],
+          t('Cannot update because the following project version is not in the list of installable releases.')
+        ),
+      ];
+    }
+    else {
+      // Ensure the correct version of the package is staged because the update
+      // is expected to succeed.
+      $this->getStageFixtureManipulator()->setVersion("drupal/$project", LegacyVersionUtility::convertToSemanticVersion($target_version));
+      $expected_results = [];
+    }
+
+    $this->assertUpdateResults([$project => $target_version], $expected_results, PreCreateEvent::class);
+  }
+
+}

automatic_updates_extensions/tests/src/Traits/FormTestTrait.php

+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\automatic_updates_extensions\Traits;
+
+use Behat\Mink\WebAssert;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Common methods for testing the update form.
+ *
+ * @internal
+ *   This class is an internal part of the module's testing infrastructure and
+ *   should not be used by external code.
+ */
+trait FormTestTrait {
+
+  /**
+   * Asserts the table shows the updates.
+   *
+   * @param \Behat\Mink\WebAssert $assert
+   *   The web assert tool.
+   * @param string $expected_project_title
+   *   The expected project title.
+   * @param string $expected_installed_version
+   *   The expected installed version.
+   * @param string $expected_target_version
+   *   The expected target version.
+   * @param int $row
+   *   The row number.
+   */
+  private function assertUpdateTableRow(WebAssert $assert, string $expected_project_title, string $expected_installed_version, string $expected_target_version, int $row = 1): void {
+    $row_selector = ".update-recommended tr:nth-of-type($row)";
+    $assert->elementTextContains('css', $row_selector . ' td:nth-of-type(2)', $expected_project_title);
+    $assert->elementTextContains('css', $row_selector . ' td:nth-of-type(3)', $expected_installed_version);
+    $target_selector = $row_selector . ' td:nth-of-type(4)';
+    $cell = $assert->elementExists('css', $target_selector);
+    $link_url = $assert->elementExists('named', ['link', 'Release notes'], $cell)->getAttribute('href');
+    $this->assertStringContainsString(str_replace('.', '-', $expected_target_version) . '-release', $link_url);
+  }
+
+  /**
+   * Asserts the table shows the expected number of updates.
+   *
+   * @param int $expected_update_count
+   *   The no of rows in table.
+   */
+  protected function assertUpdatesCount(int $expected_update_count): void {
+    assert($this instanceof BrowserTestBase);
+    $this->assertSession()->elementsCount('css', '.update-recommended tbody tr', $expected_update_count);
+  }
+
+}

automatic_updates_extensions/tests/themes/automatic_updates_extensions_test_theme/automatic_updates_extensions_test_theme.info.yml

+name: Test theme
+type: theme
+package: Testing
+description: 'A test theme.'
+core_version_requirement: ^8 || ^9
+base theme: false
+regions:
+  header: 'Header'
+  content: 'Content'
+  sidebar_first: 'Sidebar first'
+  footer: 'Footer'

composer.json

 {
-  "name": "drupal/automatic_updates",
-  "type": "drupal-module",
-  "description": "Drupal Automatic Updates",
-  "keywords": ["Drupal"],
-  "license": "GPL-2.0-or-later",
-  "homepage": "https://www.drupal.org/project/automatic_updates",
-  "minimum-stability": "dev",
-  "support": {
-    "issues": "https://www.drupal.org/project/issues/automatic_updates",
-    "source": "http://cgit.drupalcode.org/automatic_updates"
-  },
-  "require": {
-    "ext-json": "*",
-    "ext-zip": "*",
-    "drupal/php-signify": "^1.0@dev"
-  },
-  "config": {
-    "platform": {
-      "php": "5.6.0"
-    }
-  }
+    "name": "drupal/automatic_updates",
+    "type": "drupal-module",
+    "description": "Drupal Automatic Updates",
+    "keywords": [
+        "Drupal"
+    ],
+    "license": "GPL-2.0-or-later",
+    "homepage": "https://www.drupal.org/project/automatic_updates",
+    "minimum-stability": "dev",
+    "support": {
+        "issues": "https://www.drupal.org/project/issues/automatic_updates",
+        "source": "http://cgit.drupalcode.org/automatic_updates"
+    },
+    "require": {
+        "ext-json": "*",
+        "php-tuf/composer-stager": "2.0-beta3",
+        "composer-runtime-api": "^2.1",
+        "symfony/console": "^6.2"
+    },
+    "require-dev": {
+        "colinodell/psr-testlogger": "^1.2",
+        "symfony/config": "^6.2"
+    },
+    "scripts": {
+        "phpcbf": "scripts/phpcbf.sh",
+        "phpcs": "scripts/phpcs.sh",
+        "test": [
+            "Composer\\Config::disableProcessTimeout",
+            "scripts/phpunit.sh"
+        ],
+        "core-convert": "Drupal\\automatic_updates\\Development\\ConverterCommand",
+        "core-commit": "Drupal\\automatic_updates\\Development\\ConverterCommand::makeCommit"
+    },
+    "scripts-descriptions": {
+        "phpcbf": "Automatically fixes standards violations where possible.",
+        "phpcs": "Checks code for standards compliance.",
+        "test": "Runs PHPUnit tests.",
+        "core-convert": "Converts this module to a core merge request. For arguments and options see \\Drupal\\automatic_updates\\Development\\ConverterCommand::configure().",
+        "core-commit": "Converts this module to a core merge request. Excepts 1 arguments. The core clone directory."
+    },
+    "autoload": {
+        "psr-4": {
+            "Drupal\\automatic_updates\\Development\\": "scripts/src"
+        }
+    },
+    "bin": ["auto-update"]
 }

config/install/automatic_updates.settings.yml

-psa_endpoint: 'https://updates.drupal.org/psa.json'
-enable_psa: true
-notify: true
-check_frequency: 43200
-enable_readiness_checks: true
-hashes_uri: 'https://updates.drupal.org/release-hashes'
-ignored_paths: "modules/*\nthemes/*\nprofiles/*"
-download_uri: 'https://www.drupal.org/in-place-updates'
-enable_cron_updates: false
-enable_cron_security_updates: false
+unattended:
+  method: web
+  level: disable
+allow_core_minor_updates: false
+status_check_mail: errors_only