Hello, world!
This is a dynamic llama.
'; $this->assertEqual($expected_markup, $build['#markup'], 'Expected #post_render_cache callback has been applied.'); } diff --git a/core/modules/filter/tests/filter_test/src/Plugin/Filter/FilterTestCacheContexts.php b/core/modules/filter/tests/filter_test/src/Plugin/Filter/FilterTestCacheContexts.php new file mode 100644 index 0000000..6a98956 --- /dev/null +++ b/core/modules/filter/tests/filter_test/src/Plugin/Filter/FilterTestCacheContexts.php @@ -0,0 +1,35 @@ +addCacheContexts(['language']); + return $result; + } + +} diff --git a/core/modules/node/src/Tests/NodeCacheTagsTest.php b/core/modules/node/src/Tests/NodeCacheTagsTest.php index cd46f79..333a111 100644 --- a/core/modules/node/src/Tests/NodeCacheTagsTest.php +++ b/core/modules/node/src/Tests/NodeCacheTagsTest.php @@ -43,6 +43,21 @@ protected function createEntity() { } /** + * Returns the additional (non-standard) cache contexts for the tested entity. + * + * @param \Drupal\Core\Entity\EntityInterface $entity + * The entity to be tested, as created by createEntity(). + * + * @return string[] + * An array of the additional cache contexts. + * + * @see \Drupal\system\Tests\Entity\EntityCacheTagsTestBase::createEntity() + */ + protected function getAdditionalCacheContextsForEntity(EntityInterface $entity) { + return ['timezone']; + } + + /** * {@inheritdoc} * * Each node must have an author. diff --git a/core/modules/system/src/Tests/Entity/EntityCacheTagsTestBase.php b/core/modules/system/src/Tests/Entity/EntityCacheTagsTestBase.php index 3d7c93f..580cada 100644 --- a/core/modules/system/src/Tests/Entity/EntityCacheTagsTestBase.php +++ b/core/modules/system/src/Tests/Entity/EntityCacheTagsTestBase.php @@ -128,6 +128,21 @@ protected static function generateStandardizedInfo($entity_type_label, $group) { abstract protected function createEntity(); /** + * Returns the additional (non-standard) cache contexts for the tested entity. + * + * @param \Drupal\Core\Entity\EntityInterface $entity + * The entity to be tested, as created by createEntity(). + * + * @return string[] + * An array of the additional cache contexts. + * + * @see \Drupal\system\Tests\Entity\EntityCacheTagsTestBase::createEntity() + */ + protected function getAdditionalCacheContextsForEntity(EntityInterface $entity) { + return []; + } + + /** * Returns the additional (non-standard) cache tags for the tested entity. * * @param \Drupal\Core\Entity\EntityInterface $entity @@ -288,6 +303,9 @@ public function testReferencedEntity() { $empty_entity_listing_url = Url::fromRoute('entity.entity_test.collection_empty', ['entity_type_id' => $entity_type]); $nonempty_entity_listing_url = Url::fromRoute('entity.entity_test.collection_labels_alphabetically', ['entity_type_id' => $entity_type]); + // The default cache contexts for rendered entities. + $entity_cache_contexts = ['theme', 'user.roles']; + // Cache tags present on every rendered page. $page_cache_tags = Cache::mergeTags( ['rendered'], @@ -337,15 +355,18 @@ public function testReferencedEntity() { // Verify a cache hit, but also the presence of the correct cache tags. $this->verifyPageCache($referencing_entity_url, 'HIT', Cache::mergeTags($referencing_entity_cache_tags, $page_cache_tags)); // Also verify the existence of an entity render cache entry. - $cid = 'entity_view:entity_test:' . $this->referencing_entity->id() . ':full:classy:r.anonymous:' . date_default_timezone_get(); - $this->verifyRenderCache($cid, $referencing_entity_cache_tags); + $cache_keys = ['entity_view', 'entity_test', $this->referencing_entity->id(), 'full']; + $cid = $this->createCacheId($cache_keys, $entity_cache_contexts); + $redirected_cid = $this->createRedirectedCacheId($cache_keys, $entity_cache_contexts); + $this->verifyRenderCache($cid, $referencing_entity_cache_tags, $redirected_cid); $this->pass("Test non-referencing entity.", 'Debug'); $this->verifyPageCache($non_referencing_entity_url, 'MISS'); // Verify a cache hit, but also the presence of the correct cache tags. $this->verifyPageCache($non_referencing_entity_url, 'HIT', Cache::mergeTags($non_referencing_entity_cache_tags, $page_cache_tags)); // Also verify the existence of an entity render cache entry. - $cid = 'entity_view:entity_test:' . $this->non_referencing_entity->id() . ':full:classy:r.anonymous:' . date_default_timezone_get(); + $cache_keys = ['entity_view', 'entity_test', $this->non_referencing_entity->id(), 'full']; + $cid = $this->createCacheId($cache_keys, $entity_cache_contexts); $this->verifyRenderCache($cid, $non_referencing_entity_cache_tags); @@ -579,20 +600,87 @@ public function testReferencedEntity() { } /** + * Creates a cache ID from a list of cache keys and a set of cache contexts. + * + * @param string[] $keys + * A list of cache keys. + * @param string[] $contexts + * A set of cache contexts. + * + * @return string + * The cache ID string. + */ + protected function createCacheId(array $keys, array $contexts) { + $cid_parts = $keys; + + sort($contexts); + $contexts = \Drupal::service('cache_contexts')->convertTokensToKeys($contexts); + $cid_parts = array_merge($cid_parts, $contexts); + + return implode(':', $cid_parts); + } + + /** + * Creates the redirected cache ID, if any. + * + * If a subclass overrides ::getAdditionalCacheContextsForEntity(), it can + * specify the additional cache contexts by which the given entity must be + * varied, because those are the cache contexts that are bubbled from the + * field formatters. + * + * @param string[] $keys + * A list of cache keys used for the regular (pre-bubbling) CID. + * @param string[] $contexts + * A set of cache contexts used for the regular (pre-bubbling) CID. + * + * @return null|string + * The redirected (post-bubbling) CID, if any. + */ + protected function createRedirectedCacheId(array $keys, array $contexts) { + $additional_cache_contexts = $this->getAdditionalCacheContextsForEntity($this->referencing_entity); + if (count($additional_cache_contexts)) { + return $this->createCacheId($keys, Cache::mergeContexts($contexts, $additional_cache_contexts)); + } + else { + return NULL; + } + } + + /** * Verify that a given render cache entry exists, with the correct cache tags. * * @param string $cid * The render cache item ID. * @param array $tags * An array of expected cache tags. + * @param string|null $redirected_cid + * (optional) The redirected render cache item ID. */ - protected function verifyRenderCache($cid, array $tags) { + protected function verifyRenderCache($cid, array $tags, $redirected_cid = NULL) { // Also verify the existence of an entity render cache entry. $cache_entry = \Drupal::cache('render')->get($cid); $this->assertTrue($cache_entry, 'A render cache entry exists.'); sort($cache_entry->tags); sort($tags); $this->assertIdentical($cache_entry->tags, $tags); + if ($redirected_cid === NULL) { + $this->assertTrue(!isset($cache_entry->data['#cache_redirect']), 'Render cache entry is not a redirect.'); + } + else { + // Verify that $cid contains a cache redirect. + $this->assertTrue(isset($cache_entry->data['#cache_redirect']), 'Render cache entry is a redirect.'); + // Verify that the cache redirect points to the expected CID. + $redirect_cache_metadata = $cache_entry->data['#cache']; + $cache_keys = array_merge( + $redirect_cache_metadata['keys'], + \Drupal::service('cache_contexts')->convertTokensToKeys($redirect_cache_metadata['contexts']) + ); + $actual_redirection_cid = implode(':', $cache_keys); + $this->assertIdentical($redirected_cid, $actual_redirection_cid); + // Finally, verify that the redirected CID exists and has the same cache + // tags. + $this->verifyRenderCache($redirected_cid, $tags); + } } } diff --git a/core/modules/system/src/Tests/Entity/EntityWithUriCacheTagsTestBase.php b/core/modules/system/src/Tests/Entity/EntityWithUriCacheTagsTestBase.php index 0c8cd1d..c72d7d0 100644 --- a/core/modules/system/src/Tests/Entity/EntityWithUriCacheTagsTestBase.php +++ b/core/modules/system/src/Tests/Entity/EntityWithUriCacheTagsTestBase.php @@ -30,6 +30,9 @@ public function testEntityUri() { // Selects the view mode that will be used. $view_mode = $this->selectViewMode($entity_type); + // The default cache contexts for rendered entities. + $entity_cache_contexts = ['theme', 'user.roles']; + // Generate the standardized entity cache tags. $cache_tag = $this->entity->getCacheTags(); $view_cache_tag = \Drupal::entityManager()->getViewBuilder($entity_type)->getCacheTags(); @@ -45,10 +48,11 @@ public function testEntityUri() { // Also verify the existence of an entity render cache entry, if this entity // type supports render caching. if (\Drupal::entityManager()->getDefinition($entity_type)->isRenderCacheable()) { - $cid = 'entity_view:' . $entity_type . ':' . $this->entity->id() . ':' . $view_mode . ':classy:r.anonymous:' . date_default_timezone_get(); - $cache_entry = \Drupal::cache('render')->get($cid); + $cache_keys = ['entity_view', $entity_type, $this->entity->id(), $view_mode]; + $cid = $this->createCacheId($cache_keys, $entity_cache_contexts); + $redirected_cid = $this->createRedirectedCacheId($cache_keys, $entity_cache_contexts); $expected_cache_tags = Cache::mergeTags($cache_tag, $view_cache_tag, $this->getAdditionalCacheTagsForEntity($this->entity), array($render_cache_tag)); - $this->verifyRenderCache($cid, $expected_cache_tags); + $this->verifyRenderCache($cid, $expected_cache_tags, $redirected_cid); } // Verify that after modifying the entity, there is a cache miss. diff --git a/core/modules/text/src/Plugin/Field/FieldFormatter/TextDefaultFormatter.php b/core/modules/text/src/Plugin/Field/FieldFormatter/TextDefaultFormatter.php index efc4c0d..623c808 100644 --- a/core/modules/text/src/Plugin/Field/FieldFormatter/TextDefaultFormatter.php +++ b/core/modules/text/src/Plugin/Field/FieldFormatter/TextDefaultFormatter.php @@ -34,6 +34,8 @@ class TextDefaultFormatter extends FormatterBase { public function viewElements(FieldItemListInterface $items) { $elements = array(); + // The ProcessedText element already handles cache context & tag bubbling. + // @see \Drupal\filter\Element\ProcessedText::preRenderText() foreach ($items as $delta => $item) { $elements[$delta] = array( '#type' => 'processed_text', diff --git a/core/modules/text/src/Plugin/Field/FieldFormatter/TextTrimmedFormatter.php b/core/modules/text/src/Plugin/Field/FieldFormatter/TextTrimmedFormatter.php index ed1c8c3..105bfd5 100644 --- a/core/modules/text/src/Plugin/Field/FieldFormatter/TextTrimmedFormatter.php +++ b/core/modules/text/src/Plugin/Field/FieldFormatter/TextTrimmedFormatter.php @@ -81,6 +81,8 @@ public function viewElements(FieldItemListInterface $items) { $element['#text_summary_trim_length'] = $this->getSetting('trim_length'); }; + // The ProcessedText element already handles cache context & tag bubbling. + // @see \Drupal\filter\Element\ProcessedText::preRenderText() foreach ($items as $delta => $item) { $elements[$delta] = array( '#type' => 'processed_text', diff --git a/core/tests/Drupal/Tests/Core/Render/BubbleableMetadataTest.php b/core/tests/Drupal/Tests/Core/Render/BubbleableMetadataTest.php index c3fd7ba..ea336da 100644 --- a/core/tests/Drupal/Tests/Core/Render/BubbleableMetadataTest.php +++ b/core/tests/Drupal/Tests/Core/Render/BubbleableMetadataTest.php @@ -35,11 +35,12 @@ public function providerTestApplyTo() { $data = []; $empty_metadata = new BubbleableMetadata(); - $nonempty_metadata = new BubbleableMetadata(['foo:bar'], ['settings' => ['foo' => 'bar']]); + $nonempty_metadata = new BubbleableMetadata(['qux'], ['foo:bar'], ['settings' => ['foo' => 'bar']]); $empty_render_array = []; $nonempty_render_array = [ '#cache' => [ + 'contexts' => ['qux'], 'tags' => ['llamas:are:awesome:but:kittens:too'], ], '#attached' => [ @@ -53,7 +54,8 @@ public function providerTestApplyTo() { $expected_when_empty_metadata = [ '#cache' => [ - 'tags' => [] + 'contexts' => [], + 'tags' => [], ], '#attached' => [], '#post_render_cache' => [], @@ -61,7 +63,10 @@ public function providerTestApplyTo() { $data[] = [$empty_metadata, $empty_render_array, $expected_when_empty_metadata]; $data[] = [$empty_metadata, $nonempty_render_array, $expected_when_empty_metadata]; $expected_when_nonempty_metadata = [ - '#cache' => ['tags' => ['foo:bar']], + '#cache' => [ + 'contexts' => ['qux'], + 'tags' => ['foo:bar'], + ], '#attached' => [ 'settings' => [ 'foo' => 'bar', @@ -92,11 +97,12 @@ public function providerTestCreateFromRenderArray() { $data = []; $empty_metadata = new BubbleableMetadata(); - $nonempty_metadata = new BubbleableMetadata(['foo:bar'], ['settings' => ['foo' => 'bar']]); + $nonempty_metadata = new BubbleableMetadata(['qux'], ['foo:bar'], ['settings' => ['foo' => 'bar']]); $empty_render_array = []; $nonempty_render_array = [ '#cache' => [ + 'contexts' => ['qux'], 'tags' => ['foo:bar'], ], '#attached' => [ diff --git a/core/tests/Drupal/Tests/Core/Render/RendererBubblingTest.php b/core/tests/Drupal/Tests/Core/Render/RendererBubblingTest.php index 34c988c..336a22d 100644 --- a/core/tests/Drupal/Tests/Core/Render/RendererBubblingTest.php +++ b/core/tests/Drupal/Tests/Core/Render/RendererBubblingTest.php @@ -34,6 +34,9 @@ public function testBubblingWithoutPreRender() { $this->elementInfo->expects($this->any()) ->method('getInfo') ->willReturn([]); + $this->cacheContexts->expects($this->any()) + ->method('convertTokensToKeys') + ->willReturnArgument(0); // Create an element with a child and subchild. Each element loads a // different library using #attached. @@ -68,6 +71,321 @@ public function testBubblingWithoutPreRender() { } /** + * Tests cache context bubbling in edge cases, because it affects the CID. + * + * ::testBubblingWithPrerender() already tests the common case. + * + * @dataProvider providerTestContextBubblingEdgeCases + */ + public function testContextBubblingEdgeCases(array $element, array $expected_top_level_contexts, array $expected_cache_items) { + $this->setUpRequest(); + $this->setupMemoryCache(); + $this->cacheContexts->expects($this->any()) + ->method('convertTokensToKeys') + ->willReturnArgument(0); + + $this->renderer->render($element); + + $this->assertEquals($expected_top_level_contexts, $element['#cache']['contexts'], 'Expected cache contexts found.'); + foreach ($expected_cache_items as $cid => $expected_cache_item) { + $this->assertRenderCacheItem($cid, $expected_cache_item); + } + } + + public function providerTestContextBubblingEdgeCases() { + $data = []; + + // Bubbled cache contexts cannot override a cache ID set by #cache['cid']. + // But the cache context is bubbled nevertheless. + $test_element = [ + '#cache' => [ + 'cid' => 'parent', + ], + '#markup' => 'parent', + 'child' => [ + '#cache' => [ + 'contexts' => ['foo'], + ], + ], + ]; + $expected_cache_items = [ + 'parent' => [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['foo'], + 'tags' => ['rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ], + ]; + $data[] = [$test_element, ['foo'], $expected_cache_items]; + + // Cache contexts of inaccessible children aren't bubbled (because those + // children are not rendered at all). + $test_element = [ + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => [], + ], + '#markup' => 'parent', + 'child' => [ + '#access' => FALSE, + '#cache' => [ + 'contexts' => ['foo'], + ], + ], + ]; + $expected_cache_items = [ + 'parent' => [ + '#attached' => [], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ], + ]; + $data[] = [$test_element, [], $expected_cache_items]; + + // Assert cache contexts are sorted when they are used to generate a CID. + // (Necessary to ensure that different render arrays where the same keys + + // set of contexts are present point to the same cache item. Regardless of + // the contexts' order. A sad necessity because PHP doesn't have sets.) + $test_element = [ + '#cache' => [ + 'keys' => ['set_test'], + 'contexts' => [], + ], + ]; + $expected_cache_items = [ + 'set_test:bar:baz:foo' => [ + '#attached' => [], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], + '#post_render_cache' => [], + '#markup' => '', + ], + ]; + $context_orders = [ + ['foo', 'bar', 'baz'], + ['foo', 'baz', 'bar'], + ['bar', 'foo', 'baz'], + ['bar', 'baz', 'foo'], + ['baz', 'foo', 'bar'], + ['baz', 'bar', 'foo'], + ]; + foreach ($context_orders as $context_order) { + $test_element['#cache']['contexts'] = $context_order; + sort($context_order); + $expected_cache_items['set_test:bar:baz:foo']['#cache']['contexts'] = $context_order; + $data[] = [$test_element, $context_order, $expected_cache_items]; + } + + // A parent with a certain set of cache contexts is unaffected by a child + // that has a subset of those contexts. + $test_element = [ + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => ['foo', 'bar', 'baz'], + ], + '#markup' => 'parent', + 'child' => [ + '#cache' => [ + 'contexts' => ['foo', 'baz'], + ], + ], + ]; + $expected_cache_items = [ + 'parent:bar:baz:foo' => [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['bar', 'baz', 'foo'], + 'tags' => ['rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ], + ]; + $data[] = [$test_element, ['bar', 'baz', 'foo'], $expected_cache_items]; + + // A parent with a certain set of cache contexts that is a subset of the + // cache contexts of a child gets a redirecting cache item for the cache ID + // created pre-bubbling (without the child's additional cache contexts). It + // points to a cache item with a post-bubbling cache ID (i.e. with the + // child's additional cache contexts). + // Furthermore, the redirecting cache item also includes the children's + // cache tags, since changes in the children may cause those children to get + // different cache contexts and therefore cause different cache contexts to + // be stored in the redirecting cache item. + $test_element = [ + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => ['foo'], + 'tags' => ['yar', 'har'], + ], + '#markup' => 'parent', + 'child' => [ + '#cache' => [ + 'contexts' => ['bar'], + 'tags' => ['fiddle', 'dee'], + ], + '#markup' => '', + ], + ]; + $expected_cache_items = [ + 'parent:foo' => [ + '#cache_redirect' => TRUE, + '#cache' => [ + // The keys + contexts this redirects to. + 'keys' => ['parent'], + 'contexts' => ['bar', 'foo'], + // The 'rendered' cache tag is also present for the redirecting cache + // item, to ensure it is considered to be part of the render cache + // and thus invalidated along with everything else. + 'tags' => ['dee', 'fiddle', 'har', 'rendered', 'yar'], + ], + ], + 'parent:bar:foo' => [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['bar', 'foo'], + 'tags' => ['dee', 'fiddle', 'har', 'yar', 'rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ], + ]; + $data[] = [$test_element, ['bar', 'foo'], $expected_cache_items]; + + return $data; + } + + /** + * Tests the self-healing of the redirect with conditional cache contexts. + */ + public function testConditionalCacheContextBubblingSelfHealing() { + global $foo_cache_context; + $this->setUpRequest(); + $this->setupMemoryCache(); + $this->cacheContexts->expects($this->any()) + ->method('convertTokensToKeys') + ->willReturnCallback(function($context_tokens) use ($foo_cache_context) { + global $foo_cache_context; + $keys = []; + foreach ($context_tokens as $context_id) { + if ($context_id === 'foo') { + $keys[] = $context_id . '.' . ($foo_cache_context ? '1' : '0'); + } + else { + $keys[] = $context_id; + } + } + return $keys; + }); + + $test_element = [ + '#cache' => [ + 'keys' => ['parent'], + 'tags' => ['a'], + ], + '#markup' => 'parent', + 'child' => [ + '#cache' => [ + 'contexts' => ['foo'], + 'tags' => ['b'], + ], + 'grandchild' => [ + '#cache' => [ + 'contexts' => ['bar'], + 'tags' => ['c'], + ], + ], + ], + ]; + + // Request 1: grandchild is inaccessible => bubbled cache contexts: foo. + $element = $test_element; + $foo_cache_context = FALSE; + $element['child']['grandchild']['#access'] = FALSE; + $this->renderer->render($element); + $this->assertRenderCacheItem('parent', [ + '#cache_redirect' => TRUE, + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => ['foo'], + 'tags' => ['a', 'b', 'rendered'], + ], + ]); + $this->assertRenderCacheItem('parent:foo.0', [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['foo'], + 'tags' => ['a', 'b', 'rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ]); + + // Request 2: grandchild is accessible => bubbled cache contexts: foo, bar. + $element = $test_element; + $foo_cache_context = TRUE; + $this->renderer->render($element); + $this->assertRenderCacheItem('parent', [ + '#cache_redirect' => TRUE, + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => ['bar', 'foo'], + 'tags' => ['a', 'b', 'c', 'rendered'], + ], + ]); + $this->assertRenderCacheItem('parent:bar:foo.1', [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['bar', 'foo'], + 'tags' => ['a', 'b', 'c', 'rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ]); + + // Request 3: grandchild is inaccessible again => bubbled cache contexts: + // foo; but that's a subset of the already-bubbled cache contexts, so + // nothing is actually changed in the redirecting cache item. However, the + // cache item we were looking for in request 1 is technically the same one + // we're looking for now (it's the exact same request), but with one + // additional cache context. This is necessary to avoid "cache ping-pong". + // (Requests 1 and 3 are identical, but without the right merging logic to + // handle request 2, the redirecting cache item would toggle between only + // the 'foo' cache context and only the 'bar' cache context, resulting in + // cache miss every time.) + $element = $test_element; + $foo_cache_context = FALSE; + $element['child']['grandchild']['#access'] = FALSE; + $this->renderer->render($element); + $this->assertRenderCacheItem('parent', [ + '#cache_redirect' => TRUE, + '#cache' => [ + 'keys' => ['parent'], + 'contexts' => ['bar', 'foo'], + 'tags' => ['a', 'b', 'c', 'rendered'], + ], + ]); + $this->assertRenderCacheItem('parent:bar:foo.0', [ + '#attached' => [], + '#cache' => [ + 'contexts' => ['bar', 'foo'], + 'tags' => ['a', 'b', 'rendered'], + ], + '#post_render_cache' => [], + '#markup' => 'parent', + ]); + } + + /** * Tests bubbling of bubbleable metadata added by #pre_render callbacks. * * @dataProvider providerTestBubblingWithPrerender @@ -94,13 +412,14 @@ public function testBubblingWithPrerender($test_element) { // - … is not cached DOES get called. \Drupal::state()->set('bubbling_nested_pre_render_cached', FALSE); \Drupal::state()->set('bubbling_nested_pre_render_uncached', FALSE); - $this->memoryCache->set('cached_nested', ['#markup' => 'Cached nested!', '#attached' => [], '#cache' => ['tags' => []], '#post_render_cache' => []]); + $this->memoryCache->set('cached_nested', ['#markup' => 'Cached nested!', '#attached' => [], '#cache' => ['contexts' => [], 'tags' => []], '#post_render_cache' => []]); // Simulate the rendering of an entire response (i.e. a root call). $output = $this->renderer->renderRoot($test_element); // First, assert the render array is of the expected form. - $this->assertEquals('Cache tag!Asset!Post-render cache!barquxNested!Cached nested!', trim($output), 'Expected HTML generated.'); + $this->assertEquals('Cache context!Cache tag!Asset!Post-render cache!barquxNested!Cached nested!', trim($output), 'Expected HTML generated.'); + $this->assertEquals(['child.cache_context'], $test_element['#cache']['contexts'], 'Expected cache contexts found.'); $this->assertEquals(['child:cache_tag'], $test_element['#cache']['tags'], 'Expected cache tags found.'); $expected_attached = [ 'drupalSettings' => ['foo' => 'bar'], @@ -155,6 +474,12 @@ public static function bubblingPreRender($elements) { ]; $placeholder = \Drupal::service('renderer')->generateCachePlaceholder($callback, $context); $elements += [ + 'child_cache_context' => [ + '#cache' => [ + 'contexts' => ['child.cache_context'], + ], + '#markup' => 'Cache context!', + ], 'child_cache_tag' => [ '#cache' => [ 'tags' => ['child:cache_tag'], diff --git a/core/tests/Drupal/Tests/Core/Render/RendererPostRenderCacheTest.php b/core/tests/Drupal/Tests/Core/Render/RendererPostRenderCacheTest.php index cb7ccc3..46a49be 100644 --- a/core/tests/Drupal/Tests/Core/Render/RendererPostRenderCacheTest.php +++ b/core/tests/Drupal/Tests/Core/Render/RendererPostRenderCacheTest.php @@ -89,7 +89,10 @@ public function testPostRenderCacheWithColdCache() { '#markup' => '#cache enabled, GET
', '#attached' => $test_element['#attached'], '#post_render_cache' => $test_element['#post_render_cache'], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $this->assertSame($cached_element, $expected_element, 'The correct data is cached: the stored #markup and #attached properties are not affected by #post_render_cache callbacks.'); @@ -222,7 +225,10 @@ public function testRenderChildrenPostRenderCacheDifferentContexts() { $context_3, ] ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $dom = Html::load($cached_element['#markup']); @@ -314,7 +320,10 @@ public function testRenderChildrenPostRenderCacheComplex() { $context_3, ] ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $dom = Html::load($cached_parent_element['#markup']); @@ -337,7 +346,10 @@ public function testRenderChildrenPostRenderCacheComplex() { $context_3, ] ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $dom = Html::load($cached_child_element['#markup']); @@ -448,7 +460,10 @@ public function testPlaceholder() { $context ], ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $this->assertSame($cached_element, $expected_element, 'The correct data is cached: the stored #markup and #attached properties are not affected by #post_render_cache callbacks.'); @@ -543,7 +558,10 @@ public function testChildElementPlaceholder() { $context, ], ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $this->assertSame($cached_element, $expected_element, 'The correct data is cached for the child element: the stored #markup and #attached properties are not affected by #post_render_cache callbacks.'); @@ -568,7 +586,10 @@ public function testChildElementPlaceholder() { $context, ], ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $this->assertSame($cached_element, $expected_element, 'The correct data is cached for the parent element: the stored #markup and #attached properties are not affected by #post_render_cache callbacks.'); @@ -596,7 +617,10 @@ public function testChildElementPlaceholder() { $context, ], ], - '#cache' => ['tags' => ['rendered']], + '#cache' => [ + 'contexts' => [], + 'tags' => ['rendered'], + ], ]; $this->assertSame($cached_element, $expected_element, 'The correct data is cached for the child element: the stored #markup and #attached properties are not affected by #post_render_cache callbacks.'); diff --git a/core/tests/Drupal/Tests/Core/Render/RendererTest.php b/core/tests/Drupal/Tests/Core/Render/RendererTest.php index 2f259b6..455834e 100644 --- a/core/tests/Drupal/Tests/Core/Render/RendererTest.php +++ b/core/tests/Drupal/Tests/Core/Render/RendererTest.php @@ -17,7 +17,10 @@ class RendererTest extends RendererTestBase { protected $defaultThemeVars = [ - '#cache' => ['tags' => []], + '#cache' => [ + 'contexts' => [], + 'tags' => [], + ], '#attached' => [], '#post_render_cache' => [], '#children' => '', diff --git a/core/tests/Drupal/Tests/Core/Render/RendererTestBase.php b/core/tests/Drupal/Tests/Core/Render/RendererTestBase.php index f4a051a..cf08554 100644 --- a/core/tests/Drupal/Tests/Core/Render/RendererTestBase.php +++ b/core/tests/Drupal/Tests/Core/Render/RendererTestBase.php @@ -139,6 +139,22 @@ protected function setUpRequest($method = 'GET') { $this->requestStack->push($request); } + /** + * Asserts a render cache item. + * + * @param string $cid + * The expected cache ID. + * @param mixed $data + * The expected data for that cache ID. + */ + protected function assertRenderCacheItem($cid, $data) { + $cached = $this->memoryCache->get($cid); + $this->assertNotFalse($cached, sprintf('Expected cache item "%s" exists.', $cid)); + if ($cached !== FALSE) { + $this->assertEquals($data, $cached->data, sprintf('Cache item "%s" has the expected data.', $cid)); + } + } + }