Initial Drupal 11 with DDEV setup

web/core/modules/page_cache/page_cache.info.yml

@@ -0,0 +1,5 @@
+name: 'Internal Page Cache'
+type: module
+description: 'Caches pages for anonymous users and can be used when external page cache is not available.'
+package: Core
+version: VERSION

web/core/modules/page_cache/page_cache.services.yml

@@ -0,0 +1,15 @@
+services:
+  _defaults:
+    autoconfigure: true
+  http_middleware.page_cache:
+    class: Drupal\page_cache\StackMiddleware\PageCache
+    arguments: ['@cache.page', '@page_cache_request_policy', '@page_cache_response_policy']
+    tags:
+      - { name: http_middleware, priority: 200, responder: true }
+
+  cache.page:
+    class: Drupal\Core\Cache\CacheBackendInterface
+    tags:
+      - { name: cache.bin }
+    factory: ['@cache_factory', 'get']
+    arguments: [page]

web/core/modules/page_cache/src/Hook/PageCacheHooks.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Drupal\page_cache\Hook;
+
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\Core\Url;
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\Core\Hook\Attribute\Hook;
+
+/**
+ * Hook implementations for page_cache.
+ */
+class PageCacheHooks {
+
+  use StringTranslationTrait;
+
+  /**
+   * Implements hook_help().
+   */
+  #[Hook('help')]
+  public function help($route_name, RouteMatchInterface $route_match): ?string {
+    switch ($route_name) {
+      case 'help.page.page_cache':
+        $output = '<h2>' . $this->t('About') . '</h2>';
+        $output .= '<p>' . $this->t('The Internal Page Cache module caches pages for anonymous users in the database. For more information, see the <a href=":pagecache-documentation">online documentation for the Internal Page Cache module</a>.', [
+          ':pagecache-documentation' => 'https://www.drupal.org/documentation/modules/internal_page_cache',
+        ]) . '</p>';
+        $output .= '<h2>' . $this->t('Uses') . '</h2>';
+        $output .= '<dl>';
+        $output .= '<dt>' . $this->t('Speeding up your site') . '</dt>';
+        $output .= '<dd>' . $this->t('Pages requested by anonymous users are stored the first time they are requested and then are reused. Depending on your site configuration and the amount of your web traffic tied to anonymous visitors, the caching system may significantly increase the speed of your site.') . '</dd>';
+        $output .= '<dd>' . $this->t('Pages are usually identical for all anonymous users, while they can be personalized for each authenticated user. This is why entire pages can be cached for anonymous users, whereas they will have to be rebuilt for every authenticated user.') . '</dd>';
+        $output .= '<dd>' . $this->t('To speed up your site for authenticated users, see the <a href=":dynamic_page_cache-help">Dynamic Page Cache module</a>.', [
+          ':dynamic_page_cache-help' => \Drupal::moduleHandler()->moduleExists('dynamic_page_cache') ? Url::fromRoute('help.page', [
+            'name' => 'dynamic_page_cache',
+          ])->toString() : '#',
+        ]) . '</p>';
+        $output .= '<dt>' . $this->t('Configuring the internal page cache') . '</dt>';
+        $output .= '<dd>' . $this->t('On the <a href=":cache-settings">Performance page</a>, you can configure how long browsers and proxies may cache pages based on the Cache-Control header; this setting is ignored by the Internal Page Cache module, which caches pages permanently until invalidation, unless they carry an Expires header. There is no other configuration.', [
+          ':cache-settings' => Url::fromRoute('system.performance_settings')->toString(),
+        ]) . '</dd>';
+        $output .= '</dl>';
+        return $output;
+    }
+    return NULL;
+  }
+
+}

web/core/modules/page_cache/src/StackMiddleware/PageCache.php

@@ -0,0 +1,378 @@
+<?php
+
+namespace Drupal\page_cache\StackMiddleware;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheableResponseInterface;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\PageCache\RequestPolicyInterface;
+use Drupal\Core\PageCache\ResponsePolicyInterface;
+use Drupal\Core\Site\Settings;
+use Symfony\Component\HttpFoundation\BinaryFileResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+/**
+ * Executes the page caching before the main kernel takes over the request.
+ */
+class PageCache implements HttpKernelInterface {
+
+  /**
+   * Name of Page Cache's response header.
+   */
+  const HEADER = 'X-Drupal-Cache';
+
+  /**
+   * The wrapped HTTP kernel.
+   *
+   * @var \Symfony\Component\HttpKernel\HttpKernelInterface
+   */
+  protected $httpKernel;
+
+  /**
+   * The cache bin.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $cache;
+
+  /**
+   * A policy rule determining the cacheability of a request.
+   *
+   * @var \Drupal\Core\PageCache\RequestPolicyInterface
+   */
+  protected $requestPolicy;
+
+  /**
+   * A policy rule determining the cacheability of the response.
+   *
+   * @var \Drupal\Core\PageCache\ResponsePolicyInterface
+   */
+  protected $responsePolicy;
+
+  /**
+   * The cache ID for the (master) request.
+   *
+   * @var string
+   */
+  protected $cid;
+
+  /**
+   * Constructs a PageCache object.
+   *
+   * @param \Symfony\Component\HttpKernel\HttpKernelInterface $http_kernel
+   *   The decorated kernel.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache
+   *   The cache bin.
+   * @param \Drupal\Core\PageCache\RequestPolicyInterface $request_policy
+   *   A policy rule determining the cacheability of a request.
+   * @param \Drupal\Core\PageCache\ResponsePolicyInterface $response_policy
+   *   A policy rule determining the cacheability of the response.
+   */
+  public function __construct(HttpKernelInterface $http_kernel, CacheBackendInterface $cache, RequestPolicyInterface $request_policy, ResponsePolicyInterface $response_policy) {
+    $this->httpKernel = $http_kernel;
+    $this->cache = $cache;
+    $this->requestPolicy = $request_policy;
+    $this->responsePolicy = $response_policy;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function handle(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE): Response {
+    // Only allow page caching on master request.
+    if ($type === static::MAIN_REQUEST && $this->requestPolicy->check($request) === RequestPolicyInterface::ALLOW) {
+      $response = $this->lookup($request, $type, $catch);
+    }
+    else {
+      $response = $this->pass($request, $type, $catch);
+      // Don't indicate non-cacheability on responses to uncacheable requests.
+      // @see https://tools.ietf.org/html/rfc7231#section-4.2.3
+      if ($request->isMethodCacheable()) {
+        $response->headers->set(static::HEADER, 'UNCACHEABLE (request policy)');
+      }
+    }
+
+    return $response;
+  }
+
+  /**
+   * Sidesteps the page cache and directly forwards a request to the backend.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param int $type
+   *   The type of the request (one of HttpKernelInterface::MAIN_REQUEST or
+   *   HttpKernelInterface::SUB_REQUEST)
+   * @param bool $catch
+   *   Whether to catch exceptions or not.
+   *
+   * @return \Symfony\Component\HttpFoundation\Response
+   *   A response object.
+   */
+  protected function pass(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE) {
+    return $this->httpKernel->handle($request, $type, $catch);
+  }
+
+  /**
+   * Retrieves a response from the cache or fetches it from the backend.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param int $type
+   *   The type of the request (one of HttpKernelInterface::MAIN_REQUEST or
+   *   HttpKernelInterface::SUB_REQUEST)
+   * @param bool $catch
+   *   Whether to catch exceptions or not.
+   *
+   * @return \Symfony\Component\HttpFoundation\Response
+   *   A response object.
+   */
+  protected function lookup(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE) {
+    if ($response = $this->get($request)) {
+      $response->headers->set(static::HEADER, 'HIT');
+    }
+    else {
+      $response = $this->fetch($request, $type, $catch);
+    }
+
+    // Only allow caching in the browser and prevent that the response is stored
+    // by an external proxy server when the following conditions apply:
+    // 1. There is a session cookie on the request.
+    // 2. The Vary: Cookie header is on the response.
+    // 3. The Cache-Control header does not contain the no-cache directive.
+    if ($request->cookies->has(session_name()) &&
+      in_array('Cookie', $response->getVary()) &&
+      !$response->headers->hasCacheControlDirective('no-cache')) {
+
+      $response->setPrivate();
+    }
+
+    // Perform HTTP revalidation.
+    // @todo Use Response::isNotModified() as
+    //   per https://www.drupal.org/node/2259489.
+    $last_modified = $response->getLastModified();
+    if ($last_modified) {
+      // See if the client has provided the required HTTP headers.
+      $if_modified_since = $request->server->has('HTTP_IF_MODIFIED_SINCE') ? strtotime($request->server->get('HTTP_IF_MODIFIED_SINCE')) : FALSE;
+      $if_none_match = $request->server->has('HTTP_IF_NONE_MATCH') ? stripslashes($request->server->get('HTTP_IF_NONE_MATCH')) : FALSE;
+
+      if ($if_modified_since && $if_none_match
+        // ETag must match.
+        && $if_none_match == $response->getEtag()
+        // if-modified-since must match.
+        && $if_modified_since == $last_modified->getTimestamp()) {
+        $response->setStatusCode(304);
+        $response->setContent(NULL);
+
+        // In the case of a 304 response, certain headers must be sent, and the
+        // remaining may not (see RFC 2616, section 10.3.5).
+        foreach (array_keys($response->headers->all()) as $name) {
+          if (!in_array($name, ['content-location', 'expires', 'cache-control', 'vary'])) {
+            $response->headers->remove($name);
+          }
+        }
+      }
+    }
+
+    return $response;
+  }
+
+  /**
+   * Fetches a response from the backend and stores it in the cache.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param int $type
+   *   The type of the request (one of HttpKernelInterface::MAIN_REQUEST or
+   *   HttpKernelInterface::SUB_REQUEST)
+   * @param bool $catch
+   *   Whether to catch exceptions or not.
+   *
+   * @return \Symfony\Component\HttpFoundation\Response
+   *   A response object.
+   *
+   * @see drupal_page_header()
+   */
+  protected function fetch(Request $request, $type = self::MAIN_REQUEST, $catch = TRUE) {
+    /** @var \Symfony\Component\HttpFoundation\Response $response */
+    $response = $this->httpKernel->handle($request, $type, $catch);
+
+    // Only set the 'X-Drupal-Cache' header if caching is allowed for this
+    // response.
+    if ($this->storeResponse($request, $response)) {
+      $response->headers->set(static::HEADER, 'MISS');
+    }
+
+    return $response;
+  }
+
+  /**
+   * Stores a response in the page cache.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param \Symfony\Component\HttpFoundation\Response $response
+   *   A response object that should be stored in the page cache.
+   *
+   * @return bool
+   *   TRUE if the response has been stored successfully, FALSE otherwise.
+   */
+  protected function storeResponse(Request $request, Response $response) {
+    // Drupal's primary cache invalidation architecture is cache tags: any
+    // response that varies by a configuration value or data in a content
+    // entity should have cache tags, to allow for instant cache invalidation
+    // when that data is updated. However, HTTP does not standardize how to
+    // encode cache tags in a response. Different CDNs implement their own
+    // approaches, and configurable reverse proxies (e.g., Varnish) allow for
+    // custom implementations. To keep Drupal's internal page cache simple, we
+    // only cache CacheableResponseInterface responses, since those provide a
+    // defined API for retrieving cache tags. For responses that do not
+    // implement CacheableResponseInterface, there's no easy way to distinguish
+    // responses that truly don't depend on any site data from responses that
+    // contain invalidation information customized to a particular proxy or
+    // CDN.
+    // - Drupal modules are encouraged to use CacheableResponseInterface
+    //   responses where possible and to leave the encoding of that information
+    //   into response headers to the corresponding proxy/CDN integration
+    //   modules.
+    // - Custom applications that wish to provide internal page cache support
+    //   for responses that do not implement CacheableResponseInterface may do
+    //   so by replacing/extending this middleware service or adding another
+    //   one.
+    if (!$response instanceof CacheableResponseInterface) {
+      $response->headers->set(static::HEADER, 'UNCACHEABLE (no cacheability)');
+      return FALSE;
+    }
+
+    // Currently it is not possible to cache binary file or streamed responses:
+    // https://github.com/symfony/symfony/issues/9128#issuecomment-25088678.
+    // Therefore exclude them, even for subclasses that implement
+    // CacheableResponseInterface.
+    if ($response instanceof BinaryFileResponse || $response instanceof StreamedResponse) {
+      return FALSE;
+    }
+
+    // Allow policy rules to further restrict which responses to cache.
+    if ($this->responsePolicy->check($response, $request) === ResponsePolicyInterface::DENY) {
+      $response->headers->set(static::HEADER, 'UNCACHEABLE (response policy)');
+      return FALSE;
+    }
+
+    $request_time = $request->server->get('REQUEST_TIME');
+    // The response passes all of the above checks, so cache it. Page cache
+    // entries default to Cache::PERMANENT since they will be expired via cache
+    // tags locally. Because of this, page cache ignores max age.
+    // - Get the tags from CacheableResponseInterface per the earlier comments.
+    // - Get the time expiration from the Expires header, rather than the
+    //   interface, but see https://www.drupal.org/node/2352009 about possibly
+    //   changing that.
+    $expire = 0;
+    // 403 and 404 responses can fill non-LRU cache backends and generally are
+    // likely to have a low cache hit rate. So do not cache them permanently.
+    if ($response->isClientError()) {
+      // Cache for an hour by default. If the 'cache_ttl_4xx' setting is
+      // set to 0 then do not cache the response.
+      $cache_ttl_4xx = Settings::get('cache_ttl_4xx', 3600);
+      if ($cache_ttl_4xx > 0) {
+        $expire = $request_time + $cache_ttl_4xx;
+      }
+    }
+    // The getExpires method could return NULL if Expires header is not set, so
+    // the returned value needs to be checked before calling getTimestamp.
+    elseif ($expires = $response->getExpires()) {
+      $date = $expires->getTimestamp();
+      $expire = ($date > $request_time) ? $date : Cache::PERMANENT;
+    }
+    else {
+      $expire = Cache::PERMANENT;
+    }
+
+    if ($expire === Cache::PERMANENT || $expire > $request_time) {
+      $tags = $response->getCacheableMetadata()->getCacheTags();
+      $this->set($request, $response, $expire, $tags);
+    }
+
+    return TRUE;
+  }
+
+  /**
+   * Returns a response object from the page cache.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param bool $allow_invalid
+   *   (optional) If TRUE, a cache item may be returned even if it is expired or
+   *   has been invalidated. Such items may sometimes be preferred, if the
+   *   alternative is recalculating the value stored in the cache, especially
+   *   if another concurrent request is already recalculating the same value.
+   *   The "valid" property of the returned object indicates whether the item is
+   *   valid or not. Defaults to FALSE.
+   *
+   * @return \Symfony\Component\HttpFoundation\Response|false
+   *   The cached response or FALSE on failure.
+   */
+  protected function get(Request $request, $allow_invalid = FALSE) {
+    $cid = $this->getCacheId($request);
+    if ($cache = $this->cache->get($cid, $allow_invalid)) {
+      return $cache->data;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Stores a response object in the page cache.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   * @param \Symfony\Component\HttpFoundation\Response $response
+   *   The response to store in the cache.
+   * @param int $expire
+   *   One of the following values:
+   *   - CacheBackendInterface::CACHE_PERMANENT: Indicates that the item should
+   *     not be removed unless it is deleted explicitly.
+   *   - A Unix timestamp: Indicates that the item will be considered invalid
+   *     after this time, i.e. it will not be returned by get() unless
+   *     $allow_invalid has been set to TRUE. When the item has expired, it may
+   *     be permanently deleted by the garbage collector at any time.
+   * @param array $tags
+   *   An array of tags to be stored with the cache item. These should normally
+   *   identify objects used to build the cache item, which should trigger
+   *   cache invalidation when updated. For example if a cached item represents
+   *   a node, both the node ID and the author's user ID might be passed in as
+   *   tags. For example, ['node' => [123], 'user' => [92]].
+   */
+  protected function set(Request $request, Response $response, $expire, array $tags) {
+    $cid = $this->getCacheId($request);
+    $this->cache->set($cid, $response, $expire, $tags);
+  }
+
+  /**
+   * Gets the page cache ID for this request.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   A request object.
+   *
+   * @return string
+   *   The cache ID for this request.
+   */
+  protected function getCacheId(Request $request) {
+    // Once a cache ID is determined for the request, reuse it for the duration
+    // of the request. This ensures that when the cache is written, it is only
+    // keyed on request data that was available when it was read. For example,
+    // the request format might be NULL during cache lookup and then set during
+    // routing, in which case we want to key on NULL during writing, since that
+    // will be the value during lookups for subsequent requests.
+    if (!isset($this->cid)) {
+      $cid_parts = [
+        $request->getSchemeAndHttpHost() . $request->getRequestUri(),
+        $request->getRequestFormat(NULL),
+      ];
+      $this->cid = implode(':', $cid_parts);
+    }
+    return $this->cid;
+  }
+
+}

web/core/modules/page_cache/tests/src/Functional/GenericTest.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\page_cache\Functional;
+
+use Drupal\Tests\system\Functional\Module\GenericModuleTestBase;
+
+/**
+ * Generic module test for page_cache.
+ *
+ * @group page_cache
+ */
+class GenericTest extends GenericModuleTestBase {}

web/core/modules/page_cache/tests/src/Functional/PageCacheTagsIntegrationTest.php

@@ -0,0 +1,217 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\page_cache\Functional;
+
+use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\Core\EventSubscriber\MainContentViewSubscriber;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\filter\Entity\FilterFormat;
+use Drupal\language\Plugin\LanguageNegotiation\LanguageNegotiationContentEntity;
+use Drupal\language\Plugin\LanguageNegotiation\LanguageNegotiationUrl;
+use Drupal\node\NodeInterface;
+use Drupal\Tests\system\Functional\Cache\AssertPageCacheContextsAndTagsTrait;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\user\Entity\Role;
+use Drupal\user\RoleInterface;
+use Symfony\Component\Yaml\Yaml;
+
+/**
+ * Enables the page cache and tests its cache tags in various scenarios.
+ *
+ * @group Cache
+ * @see \Drupal\Tests\page_cache\Functional\PageCacheTest
+ */
+class PageCacheTagsIntegrationTest extends BrowserTestBase {
+
+  use AssertPageCacheContextsAndTagsTrait;
+  use CommentTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'olivero';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'big_pipe',
+    'block',
+    'comment',
+    'editor',
+    'filter',
+    'language',
+    'help',
+    'node',
+    'search',
+    'views',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->enablePageCaching();
+  }
+
+  /**
+   * Tests that cache tags are properly bubbled up to the page level.
+   */
+  public function testPageCacheTags(): void {
+    $config = $this->config('language.types');
+    $config->set('configurable', [LanguageInterface::TYPE_INTERFACE, LanguageInterface::TYPE_CONTENT]);
+    $config->set('negotiation.language_content.enabled', [
+      LanguageNegotiationUrl::METHOD_ID => 0,
+      LanguageNegotiationContentEntity::METHOD_ID => 1,
+    ]);
+    $config->save();
+
+    // Create two filters.
+    FilterFormat::create(
+      Yaml::parseFile('core/profiles/standard/config/install/filter.format.basic_html.yml')
+    )->save();
+    FilterFormat::create(
+      Yaml::parseFile('core/profiles/standard/config/install/filter.format.full_html.yml')
+    )->save();
+
+    $this->drupalCreateContentType(['type' => 'page', 'title' => 'Basic page']);
+    $this->addDefaultCommentField('node', 'page');
+
+    // To generate search and comment tags.
+    $anonymous = Role::load(RoleInterface::ANONYMOUS_ID);
+    $anonymous
+      ->grantPermission('search content')
+      ->grantPermission('access comments');
+    $anonymous->save();
+
+    // Create two nodes.
+    $author_1 = $this->drupalCreateUser();
+    $node_1 = $this->drupalCreateNode([
+      'uid' => $author_1->id(),
+      'title' => 'Node 1',
+      'body' => [
+        0 => ['value' => 'Body 1', 'format' => 'basic_html'],
+      ],
+      'promote' => NodeInterface::PROMOTED,
+    ]);
+    $author_2 = $this->drupalCreateUser();
+    $node_2 = $this->drupalCreateNode([
+      'uid' => $author_2->id(),
+      'title' => 'Node 2',
+      'body' => [
+        0 => ['value' => 'Body 2', 'format' => 'full_html'],
+      ],
+      'promote' => NodeInterface::PROMOTED,
+    ]);
+
+    // Place a block, but only make it visible on full node page 2.
+    $block = $this->drupalPlaceBlock('views_block:comments_recent-block_1', [
+      'visibility' => [
+        'request_path' => [
+          'pages' => '/node/' . $node_2->id(),
+        ],
+      ],
+    ]);
+
+    $cache_contexts = [
+      'languages:' . LanguageInterface::TYPE_INTERFACE,
+      'route',
+      'theme',
+      'timezone',
+      // The placed block is only visible on certain URLs through a visibility
+      // condition.
+      'url.path',
+      'url.query_args:' . MainContentViewSubscriber::WRAPPER_FORMAT,
+      // rel=canonical links and friends have absolute URLs as their values.
+      'url.site',
+      // These two cache contexts are added by BigPipe.
+      'cookies:big_pipe_nojs',
+      'session.exists',
+      'user.permissions',
+      'user.roles',
+    ];
+
+    // Full node page 1.
+    $this->assertPageCacheContextsAndTags($node_1->toUrl(), $cache_contexts, [
+      'http_response',
+      'rendered',
+      'block_view',
+      'local_task',
+      'config:block_list',
+      'config:block.block.olivero_site_branding',
+      'config:block.block.olivero_breadcrumbs',
+      'config:block.block.olivero_content',
+      'config:block.block.olivero_help',
+      'config:block.block.olivero_search_form_narrow',
+      'config:block.block.olivero_search_form_wide',
+      'config:block.block.' . $block->id(),
+      'config:block.block.olivero_powered',
+      'config:block.block.olivero_main_menu',
+      'config:block.block.olivero_account_menu',
+      'config:block.block.olivero_messages',
+      'config:block.block.olivero_primary_local_tasks',
+      'config:block.block.olivero_secondary_local_tasks',
+      'config:block.block.olivero_primary_admin_actions',
+      'config:block.block.olivero_page_title',
+      'node_view',
+      'CACHE_MISS_IF_UNCACHEABLE_HTTP_METHOD:form',
+      'node:' . $node_1->id(),
+      'user:' . $author_1->id(),
+      'config:filter.format.basic_html',
+      'config:search.settings',
+      'config:system.menu.account',
+      'config:system.menu.main',
+      'config:system.site',
+      // FinishResponseSubscriber adds this cache tag to responses that have the
+      // 'user.permissions' cache context for anonymous users.
+      'config:user.role.anonymous',
+    ]);
+
+    // Render the view block adds the languages cache context.
+    $cache_contexts[] = 'languages:' . LanguageInterface::TYPE_CONTENT;
+
+    // Full node page 2.
+    $this->assertPageCacheContextsAndTags($node_2->toUrl(), $cache_contexts, [
+      'http_response',
+      'rendered',
+      'block_view',
+      'local_task',
+      'config:block_list',
+      'config:block.block.olivero_site_branding',
+      'config:block.block.olivero_breadcrumbs',
+      'config:block.block.olivero_content',
+      'config:block.block.olivero_help',
+      'config:block.block.olivero_search_form_narrow',
+      'config:block.block.olivero_search_form_wide',
+      'config:block.block.' . $block->id(),
+      'config:block.block.olivero_powered',
+      'config:block.block.olivero_main_menu',
+      'config:block.block.olivero_account_menu',
+      'config:block.block.olivero_messages',
+      'config:block.block.olivero_primary_local_tasks',
+      'config:block.block.olivero_secondary_local_tasks',
+      'config:block.block.olivero_primary_admin_actions',
+      'config:block.block.olivero_page_title',
+      'node_view',
+      'CACHE_MISS_IF_UNCACHEABLE_HTTP_METHOD:form',
+      'node:' . $node_2->id(),
+      'user:' . $author_2->id(),
+      'config:filter.format.full_html',
+      'config:search.settings',
+      'config:system.menu.account',
+      'config:system.menu.main',
+      'config:system.site',
+      'comment_list',
+      'node_list',
+      'config:views.view.comments_recent',
+      // FinishResponseSubscriber adds this cache tag to responses that have the
+      // 'user.permissions' cache context for anonymous users.
+      'config:user.role.anonymous',
+    ]);
+  }
+
+}

web/core/modules/page_cache/tests/src/Functional/PageCacheTest.php

@@ -0,0 +1,641 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\page_cache\Functional;
+
+use Drupal\Component\Datetime\DateTimePlus;
+use Drupal\Core\Site\Settings;
+use Drupal\Core\Url;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\Core\Cache\Cache;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\system\Functional\Cache\AssertPageCacheContextsAndTagsTrait;
+use Drupal\user\RoleInterface;
+
+// cspell:ignore curlopt returntransfer
+
+/**
+ * Enables the page cache and tests it with various HTTP requests.
+ *
+ * @group page_cache
+ * @group #slow
+ */
+class PageCacheTest extends BrowserTestBase {
+
+  use AssertPageCacheContextsAndTagsTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['test_page_test', 'system_test', 'entity_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->config('system.site')
+      ->set('name', 'Drupal')
+      ->set('page.front', '/test-page')
+      ->save();
+  }
+
+  /**
+   * Tests that cache tags are properly persisted.
+   *
+   * Since tag based invalidation works, we know that our tag properly
+   * persisted.
+   */
+  protected function testPageCacheTags(): void {
+    $this->enablePageCaching();
+
+    $path = 'system-test/cache_tags_page';
+    $tags = ['system_test_cache_tags_page'];
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+
+    // Verify a cache hit, but also the presence of the correct cache tags.
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $cid_parts = [Url::fromRoute('system_test.cache_tags_page', [], ['absolute' => TRUE])->toString(), ''];
+    $cid = implode(':', $cid_parts);
+    $cache_entry = \Drupal::cache('page')->get($cid);
+    sort($cache_entry->tags);
+    $expected_tags = [
+      'config:user.role.anonymous',
+      'http_response',
+      'pre_render',
+      'rendered',
+      'system_test_cache_tags_page',
+    ];
+    $this->assertSame($expected_tags, $cache_entry->tags);
+
+    Cache::invalidateTags($tags);
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+  }
+
+  /**
+   * Tests that the page cache doesn't depend on cacheability headers.
+   */
+  protected function testPageCacheTagsIndependentFromCacheabilityHeaders(): void {
+    // Disable the cacheability headers.
+    $this->setContainerParameter('http.response.debug_cacheability_headers', FALSE);
+    $this->rebuildContainer();
+    $this->resetAll();
+
+    $path = 'system-test/cache_tags_page';
+    $tags = ['system_test_cache_tags_page'];
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+
+    // Verify a cache hit, but also the presence of the correct cache tags.
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $cid_parts = [Url::fromRoute('system_test.cache_tags_page', [], ['absolute' => TRUE])->toString(), ''];
+    $cid = implode(':', $cid_parts);
+    $cache_entry = \Drupal::cache('page')->get($cid);
+    sort($cache_entry->tags);
+    $expected_tags = [
+      'config:user.role.anonymous',
+      'http_response',
+      'pre_render',
+      'rendered',
+      'system_test_cache_tags_page',
+    ];
+    $this->assertSame($expected_tags, $cache_entry->tags);
+
+    Cache::invalidateTags($tags);
+    $this->drupalGet($path);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+  }
+
+  /**
+   * Tests support for different cache items with different request formats.
+   *
+   * The request formats are specified via a query parameter.
+   */
+  public function testQueryParameterFormatRequests(): void {
+    $this->enablePageCaching();
+
+    $accept_header_cache_url = Url::fromRoute('system_test.page_cache_accept_header');
+    $accept_header_cache_url_with_json = Url::fromRoute('system_test.page_cache_accept_header', ['_format' => 'json']);
+    $accept_header_cache_url_with_ajax = Url::fromRoute('system_test.page_cache_accept_header', ['_format' => 'json'], ['query' => ['_wrapper_format' => 'drupal_ajax']]);
+
+    $this->drupalGet($accept_header_cache_url);
+    // Verify that HTML page was not yet cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->drupalGet($accept_header_cache_url);
+    // Verify that HTML page was cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    // Verify that the correct HTML response was returned.
+    $this->assertSession()->responseContains('<p>oh hai this is html.</p>');
+
+    $this->drupalGet($accept_header_cache_url_with_json);
+    // Verify that JSON response was not yet cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->drupalGet($accept_header_cache_url_with_json);
+    // Verify that JSON response was cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    // Verify that the correct JSON response was returned.
+    $this->assertSession()->responseContains('{"content":"oh hai this is json"}');
+
+    $this->drupalGet($accept_header_cache_url_with_ajax);
+    // Verify that AJAX response was not yet cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->drupalGet($accept_header_cache_url_with_ajax);
+    // Verify that AJAX response was cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    // Verify that the correct AJAX response was returned.
+    $this->assertSession()->responseContains('{"content":"oh hai this is ajax"}');
+  }
+
+  /**
+   * Tests support of requests with If-Modified-Since and If-None-Match headers.
+   */
+  public function testConditionalRequests(): void {
+    $this->enablePageCaching();
+
+    // Fill the cache.
+    $this->drupalGet('');
+    // Verify the page is not printed twice when the cache is cold.
+    $this->assertSession()->responseNotMatches('#<html.*<html#');
+
+    $this->drupalGet('');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $etag = $this->getSession()->getResponseHeader('ETag');
+    $last_modified = $this->getSession()->getResponseHeader('Last-Modified');
+
+    // Ensure a conditional request returns 304 Not Modified.
+    $this->drupalGet('', [], ['If-Modified-Since' => $last_modified, 'If-None-Match' => $etag]);
+    $this->assertSession()->statusCodeEquals(304);
+
+    // Ensure a conditional request with obsolete If-Modified-Since date
+    // returns 304 Not Modified.
+    $this->drupalGet('', [], [
+      'If-Modified-Since' => gmdate(DATE_RFC822, strtotime($last_modified)),
+      'If-None-Match' => $etag,
+    ]);
+    $this->assertSession()->statusCodeEquals(304);
+
+    // Ensure a conditional request with obsolete If-Modified-Since date
+    // returns 304 Not Modified.
+    $this->drupalGet('', [], [
+      'If-Modified-Since' => gmdate(DATE_RFC850, strtotime($last_modified)),
+      'If-None-Match' => $etag,
+    ]);
+    $this->assertSession()->statusCodeEquals(304);
+
+    // Ensure a conditional request without If-None-Match returns 200 OK.
+    $this->drupalGet('', [], ['If-Modified-Since' => $last_modified, 'If-None-Match' => '']);
+    // Verify the page is not printed twice when the cache is warm.
+    $this->assertSession()->responseNotMatches('#<html.*<html#');
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+
+    // Ensure a conditional request with If-Modified-Since newer than
+    // Last-Modified returns 200 OK.
+    $this->drupalGet('', [], [
+      'If-Modified-Since' => gmdate(DateTimePlus::RFC7231, strtotime($last_modified) + 1),
+      'If-None-Match' => $etag,
+    ]);
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+
+    // Ensure a conditional request by an authenticated user returns 200 OK.
+    $user = $this->drupalCreateUser();
+    $this->drupalLogin($user);
+    $this->drupalGet('', [], ['If-Modified-Since' => $last_modified, 'If-None-Match' => $etag]);
+    $this->assertSession()->statusCodeEquals(200);
+    // Verify that absence of Page was not cached.
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (request policy)');
+    $this->drupalLogout();
+  }
+
+  /**
+   * Tests page caching.
+   */
+  public function testPageCache(): void {
+    $this->testCacheableWithCustomCacheControl();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheAnonymous403404();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testCacheabilityOfRedirectResponses();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testNoUrlNormalization();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheHeaders();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheWithoutVaryCookie();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheTags();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheAnonymousRolePermissions();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testHead();
+    \Drupal::service('cache.page')->deleteAll();
+    $this->testPageCacheTagsIndependentFromCacheabilityHeaders();
+  }
+
+  /**
+   * Tests page cache headers.
+   */
+  protected function testPageCacheHeaders(): void {
+    $this->enablePageCaching();
+
+    // Fill the cache.
+    $this->drupalGet('system-test/set-header', ['query' => ['name' => 'Foo', 'value' => 'bar']]);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->assertSession()->responseHeaderContains('Vary', 'cookie');
+    // Symfony's Response logic determines a specific order for the subvalues
+    // of the Cache-Control header, even if they are explicitly passed in to
+    // the response header bag in a different order.
+    $this->assertCacheMaxAge(300);
+    $this->assertSession()->responseHeaderEquals('Expires', 'Sun, 19 Nov 1978 05:00:00 GMT');
+    $this->assertSession()->responseHeaderEquals('Foo', 'bar');
+
+    // Check cache.
+    $this->drupalGet('system-test/set-header', ['query' => ['name' => 'Foo', 'value' => 'bar']]);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $this->assertSession()->responseHeaderContains('Vary', 'cookie');
+    $this->assertCacheMaxAge(300);
+    $this->assertSession()->responseHeaderEquals('Expires', 'Sun, 19 Nov 1978 05:00:00 GMT');
+    $this->assertSession()->responseHeaderEquals('Foo', 'bar');
+
+    // Check replacing default headers.
+    $this->drupalGet('system-test/set-header', ['query' => ['name' => 'Expires', 'value' => 'Fri, 19 Nov 2008 05:00:00 GMT']]);
+    $this->assertSession()->responseHeaderEquals('Expires', 'Fri, 19 Nov 2008 05:00:00 GMT');
+    $this->drupalGet('system-test/set-header', ['query' => ['name' => 'Vary', 'value' => 'User-Agent']]);
+    $this->assertSession()->responseHeaderContains('Vary', 'user-agent');
+
+    // Check that authenticated users bypass the cache.
+    $user = $this->drupalCreateUser();
+    $this->drupalLogin($user);
+    $this->drupalGet('system-test/set-header', ['query' => ['name' => 'Foo', 'value' => 'bar']]);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (request policy)');
+    $this->assertSession()->responseHeaderNotContains('Vary', 'cookie');
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'must-revalidate, no-cache, private');
+    $this->assertSession()->responseHeaderEquals('Expires', 'Sun, 19 Nov 1978 05:00:00 GMT');
+    $this->assertSession()->responseHeaderEquals('Foo', 'bar');
+
+    // Until bubbling of max-age up to the response is supported, verify that
+    // a custom #cache max-age set on an element does not affect page max-age.
+    $this->drupalLogout();
+    $this->drupalGet('system-test/cache_max_age_page');
+    $this->assertCacheMaxAge(300);
+  }
+
+  /**
+   * Tests the automatic presence of the anonymous role's cache tag.
+   *
+   * The 'user.permissions' cache context ensures that if the permissions for a
+   * role are modified, users are not served stale render cache content. But,
+   * when entire responses are cached in reverse proxies, the value for the
+   * cache context is never calculated, causing the stale response to not be
+   * invalidated. Therefore, when varying by permissions and the current user is
+   * the anonymous user, the cache tag for the 'anonymous' role must be added.
+   *
+   * This test verifies that, and it verifies that it does not happen for other
+   * roles.
+   */
+  protected function testPageCacheAnonymousRolePermissions(): void {
+    $this->enablePageCaching();
+
+    $content_url = Url::fromRoute('system_test.permission_dependent_content');
+    $route_access_url = Url::fromRoute('system_test.permission_dependent_route_access');
+
+    // 1. anonymous user, without permission.
+    $this->drupalGet($content_url);
+    $this->assertSession()->pageTextContains('Permission to pet llamas: no!');
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', 'config:user.role.anonymous');
+    $this->drupalGet($route_access_url);
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', 'config:user.role.anonymous');
+
+    // 2. anonymous user, with permission.
+    user_role_grant_permissions(RoleInterface::ANONYMOUS_ID, ['pet llamas']);
+    $this->drupalGet($content_url);
+    $this->assertSession()->pageTextContains('Permission to pet llamas: yes!');
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', 'config:user.role.anonymous');
+    $this->drupalGet($route_access_url);
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', 'config:user.role.anonymous');
+
+    // 3. authenticated user, without permission.
+    $auth_user = $this->drupalCreateUser();
+    $this->drupalLogin($auth_user);
+    $this->drupalGet($content_url);
+    $this->assertSession()->pageTextContains('Permission to pet llamas: no!');
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderNotContains('X-Drupal-Cache-Tags', 'config:user.role.authenticated');
+    $this->drupalGet($route_access_url);
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderNotContains('X-Drupal-Cache-Tags', 'config:user.role.authenticated');
+
+    // 4. authenticated user, with permission.
+    user_role_grant_permissions(RoleInterface::AUTHENTICATED_ID, ['pet llamas']);
+    $this->drupalGet($content_url);
+    $this->assertSession()->pageTextContains('Permission to pet llamas: yes!');
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderNotContains('X-Drupal-Cache-Tags', 'config:user.role.authenticated');
+    $this->drupalGet($route_access_url);
+    $this->assertCacheContext('user.permissions');
+    $this->assertSession()->responseHeaderNotContains('X-Drupal-Cache-Tags', 'config:user.role.authenticated');
+    $this->drupalLogout();
+  }
+
+  /**
+   * Tests the 4xx-response cache tag is added and invalidated.
+   */
+  protected function testPageCacheAnonymous403404(): void {
+    $admin_url = Url::fromRoute('system.admin');
+    $invalid_url = 'foo/does_not_exist';
+    $tests = [
+      403 => $admin_url,
+      404 => $invalid_url,
+    ];
+    $cache_ttl_4xx = Settings::get('cache_ttl_4xx', 3600);
+    foreach ($tests as $code => $content_url) {
+      // Anonymous user, without permissions.
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+      $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', '4xx-response');
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+      $entity_values = [
+        'name' => $this->randomMachineName(),
+        'user_id' => 1,
+        'field_test_text' => [
+          0 => [
+            'value' => $this->randomString(),
+            'format' => 'plain_text',
+          ],
+        ],
+      ];
+      $entity = EntityTest::create($entity_values);
+      $entity->save();
+      // Saving an entity clears 4xx cache tag.
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+      // Rebuilding the router should invalidate the 4xx cache tag.
+      $this->container->get('router.builder')->rebuild();
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+
+      // Ensure the 'expire' field on the cache entry uses cache_ttl_4xx.
+      $cache_item = \Drupal::service('cache.page')->get($this->getUrl() . ':');
+      $difference = $cache_item->expire - (int) $cache_item->created;
+      // Given that a second might have passed we cannot be sure that
+      // $difference will exactly equal the default cache_ttl_4xx setting.
+      // Account for any timing difference or rounding errors by ensuring the
+      // value is within 10 seconds.
+      $this->assertTrue(
+        $difference > $cache_ttl_4xx - 10 &&
+        $difference < $cache_ttl_4xx + 10,
+        "The cache entry expiry time uses the cache_ttl_4xx setting. Expire: {$cache_item->expire} Created: {$cache_item->created}"
+      );
+    }
+
+    // Disable 403 and 404 caching.
+    $settings['settings']['cache_ttl_4xx'] = (object) [
+      'value' => 0,
+      'required' => TRUE,
+    ];
+    $this->writeSettings($settings);
+    \Drupal::service('cache.page')->deleteAll();
+
+    foreach ($tests as $code => $content_url) {
+      // Getting the 404 page twice should still result in a cache miss.
+      $this->drupalGet($content_url);
+      $this->drupalGet($content_url);
+      $this->assertSession()->statusCodeEquals($code);
+      $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    }
+    // Restore 403 and 404 caching.
+    $settings['settings']['cache_ttl_4xx'] = (object) [
+      'value' => 3600,
+      'required' => TRUE,
+    ];
+    $this->writeSettings($settings);
+  }
+
+  /**
+   * Tests the omit_vary_cookie setting.
+   */
+  protected function testPageCacheWithoutVaryCookie(): void {
+    $this->enablePageCaching();
+
+    $settings['settings']['omit_vary_cookie'] = (object) [
+      'value' => TRUE,
+      'required' => TRUE,
+    ];
+    $this->writeSettings($settings);
+
+    // Fill the cache.
+    $this->drupalGet('');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->assertSession()->responseHeaderNotContains('Vary', 'cookie');
+    $this->assertCacheMaxAge(300);
+
+    // Check cache.
+    $this->drupalGet('');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $this->assertSession()->responseHeaderNotContains('Vary', 'cookie');
+    $this->assertCacheMaxAge(300);
+  }
+
+  /**
+   * Tests cacheability of a CacheableResponse.
+   *
+   * Tests the difference between having a controller return a plain Symfony
+   * Response object versus returning a Response object that implements the
+   * CacheableResponseInterface.
+   */
+  public function testCacheableResponseResponses(): void {
+    $this->enablePageCaching();
+
+    // GET a URL, which would be marked as a cache miss if it were cacheable.
+    $this->drupalGet('/system-test/respond-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (no cacheability)');
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'must-revalidate, no-cache, private');
+
+    // GET it again, verify it's still not cached.
+    $this->drupalGet('/system-test/respond-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (no cacheability)');
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'must-revalidate, no-cache, private');
+
+    // GET a URL, which would be marked as a cache miss if it were cacheable.
+    $this->drupalGet('/system-test/respond-public-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (no cacheability)');
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'max-age=60, public');
+
+    // GET it again, verify it's still not cached.
+    $this->drupalGet('/system-test/respond-public-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'UNCACHEABLE (no cacheability)');
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'max-age=60, public');
+
+    // GET a URL, which should be marked as a cache miss.
+    $this->drupalGet('/system-test/respond-cacheable-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->assertCacheMaxAge(300);
+
+    // GET it again, it should now be a cache hit.
+    $this->drupalGet('/system-test/respond-cacheable-response');
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $this->assertCacheMaxAge(300);
+
+    // Uninstall page cache. This should flush all caches so the next call to a
+    // previously cached page should be a miss now.
+    $this->container->get('module_installer')
+      ->uninstall(['page_cache']);
+
+    // GET a URL that was cached by Page Cache before, it should not be now.
+    $this->drupalGet('/respond-cacheable-response');
+    $this->assertSession()->responseHeaderDoesNotExist('X-Drupal-Cache');
+  }
+
+  /**
+   * Tests that HEAD requests are treated the same as GET requests.
+   */
+  protected function testHead(): void {
+    /** @var \GuzzleHttp\ClientInterface $client */
+    $client = $this->getSession()->getDriver()->getClient()->getClient();
+
+    // GET, then HEAD.
+    $url_a = $this->buildUrl('system-test/set-header', ['query' => ['name' => 'Foo', 'value' => 'bar']]);
+    $response_body = $this->drupalGet($url_a);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'MISS');
+    $this->assertSession()->responseHeaderEquals('Foo', 'bar');
+    $this->assertEquals('The following header was set: <em class="placeholder">Foo</em>: <em class="placeholder">bar</em>', $response_body);
+    $response = $client->request('HEAD', $url_a);
+    $this->assertEquals('HIT', $response->getHeaderLine('X-Drupal-Cache'), 'Page was cached.');
+    $this->assertEquals('bar', $response->getHeaderLine('Foo'), 'Custom header was sent.');
+    $this->assertEquals('', $response->getBody()->getContents());
+
+    // HEAD, then GET.
+    $url_b = $this->buildUrl('system-test/set-header', ['query' => ['name' => 'Foo', 'value' => 'baz']]);
+    $response = $client->request('HEAD', $url_b);
+    $this->assertEquals('MISS', $response->getHeaderLine('X-Drupal-Cache'), 'Page was not cached.');
+    $this->assertEquals('baz', $response->getHeaderLine('Foo'), 'Custom header was sent.');
+    $this->assertEquals('', $response->getBody()->getContents());
+    $response_body = $this->drupalGet($url_b);
+    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', 'HIT');
+    $this->assertSession()->responseHeaderEquals('Foo', 'baz');
+    $this->assertEquals('The following header was set: <em class="placeholder">Foo</em>: <em class="placeholder">baz</em>', $response_body);
+  }
+
+  /**
+   * Tests a cacheable response with custom cache control.
+   */
+  protected function testCacheableWithCustomCacheControl(): void {
+    $this->enablePageCaching();
+
+    $this->drupalGet('/system-test/custom-cache-control');
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSession()->responseHeaderEquals('Cache-Control', 'bar, private');
+  }
+
+  /**
+   * Tests that the Cache-Control header is added by FinishResponseSubscriber.
+   */
+  protected function testCacheabilityOfRedirectResponses(): void {
+    $this->enablePageCaching();
+
+    $this->getSession()->getDriver()->getClient()->followRedirects(FALSE);
+    $this->maximumMetaRefreshCount = 0;
+
+    foreach ([301, 302, 303, 307, 308] as $status_code) {
+      foreach (['local', 'cacheable', 'trusted'] as $type) {
+        $this->drupalGet("/system-test/redirect/{$type}/{$status_code}");
+        $this->assertSession()->statusCodeEquals($status_code);
+        $this->assertCacheMaxAge(300);
+      }
+    }
+    $this->getSession()->getDriver()->getClient()->followRedirects(TRUE);
+  }
+
+  /**
+   * Tests that URLs are cached in a not normalized form.
+   */
+  protected function testNoUrlNormalization(): void {
+    // Use absolute URLs to avoid any processing.
+    $url = Url::fromRoute('<front>')->setAbsolute()->toString();
+
+    // In each test, the first array value is raw URL, the second one is the
+    // possible normalized URL.
+    $tests = [
+      [
+        $url . '?z=z&a=a',
+        $url . '?a=a&z=z',
+      ],
+      [
+        $url . '?a=b+c',
+        $url . '?a=b%20c',
+      ],
+    ];
+
+    foreach ($tests as [$url_raw, $url_normalized]) {
+      // Initialize cache on raw URL.
+      $headers = $this->getHeaders($url_raw);
+      $this->assertEquals('MISS', $headers['X-Drupal-Cache']);
+
+      // Ensure cache was set.
+      $headers = $this->getHeaders($url_raw);
+      $this->assertEquals('HIT', $headers['X-Drupal-Cache'], "Cache was set for {$url_raw} URL.");
+
+      // Check if the normalized URL is not cached.
+      $headers = $this->getHeaders($url_normalized);
+      $this->assertEquals('MISS', $headers['X-Drupal-Cache'], "Cache is missing for {$url_normalized} URL.");
+    }
+  }
+
+  /**
+   * Retrieves only the headers for an absolute path.
+   *
+   * Executes a cURL request without any modifications to the given URL.
+   * Note that Guzzle always normalizes URLs which prevents testing all
+   * possible edge cases.
+   *
+   * @param string $url
+   *   URL to request.
+   *
+   * @return array
+   *   Array of headers.
+   */
+  protected function getHeaders($url): array {
+    $ch = curl_init();
+    curl_setopt($ch, CURLOPT_URL, $url);
+    curl_setopt($ch, CURLOPT_HEADER, TRUE);
+    curl_setopt($ch, CURLOPT_NOBODY, TRUE);
+    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
+    curl_setopt($ch, CURLOPT_USERAGENT, drupal_generate_test_ua($this->databasePrefix));
+    $output = curl_exec($ch);
+
+    $headers = [];
+    foreach (explode("\n", $output) as $header) {
+      if (strpos($header, ':')) {
+        [$key, $value] = explode(':', $header, 2);
+        $headers[trim($key)] = trim($value);
+      }
+    }
+
+    return $headers;
+  }
+
+}