Mercurial > hg > isophonics-drupal-site
comparison core/modules/views/tests/src/Kernel/RenderCacheIntegrationTest.php @ 0:4c8ae668cc8c
Initial import (non-working)
author | Chris Cannam |
---|---|
date | Wed, 29 Nov 2017 16:09:58 +0000 |
parents | |
children | 7a779792577d |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4c8ae668cc8c |
---|---|
1 <?php | |
2 | |
3 namespace Drupal\Tests\views\Kernel; | |
4 | |
5 use Drupal\Core\Cache\Cache; | |
6 use Drupal\Core\Entity\EntityInterface; | |
7 use Drupal\Core\Language\LanguageInterface; | |
8 use Drupal\entity_test\Entity\EntityTest; | |
9 use Drupal\views\Tests\AssertViewsCacheTagsTrait; | |
10 use Drupal\views\Views; | |
11 use Drupal\views\Entity\View; | |
12 | |
13 /** | |
14 * Tests the general integration between views and the render cache. | |
15 * | |
16 * @group views | |
17 */ | |
18 class RenderCacheIntegrationTest extends ViewsKernelTestBase { | |
19 | |
20 use AssertViewsCacheTagsTrait; | |
21 | |
22 /** | |
23 * {@inheritdoc} | |
24 */ | |
25 public static $testViews = ['test_view', 'test_display', 'entity_test_fields', 'entity_test_row']; | |
26 | |
27 /** | |
28 * {@inheritdoc} | |
29 */ | |
30 public static $modules = ['entity_test', 'user', 'node']; | |
31 | |
32 /** | |
33 * {@inheritdoc} | |
34 */ | |
35 protected function setUp($import_test_views = TRUE) { | |
36 parent::setUp(); | |
37 | |
38 $this->installEntitySchema('entity_test'); | |
39 $this->installEntitySchema('user'); | |
40 } | |
41 | |
42 /** | |
43 * Tests a field-based view's cache tags when using the "none" cache plugin. | |
44 */ | |
45 public function testFieldBasedViewCacheTagsWithCachePluginNone() { | |
46 $view = Views::getview('entity_test_fields'); | |
47 $view->getDisplay()->overrideOption('cache', [ | |
48 'type' => 'none', | |
49 ]); | |
50 $view->save(); | |
51 | |
52 $this->assertCacheTagsForFieldBasedView(FALSE); | |
53 } | |
54 | |
55 /** | |
56 * Tests a field-based view's cache tags when using the "tag" cache plugin. | |
57 */ | |
58 public function testFieldBasedViewCacheTagsWithCachePluginTag() { | |
59 $view = Views::getview('entity_test_fields'); | |
60 $view->getDisplay()->overrideOption('cache', [ | |
61 'type' => 'tag', | |
62 ]); | |
63 $view->save(); | |
64 | |
65 $this->assertCacheTagsForFieldBasedView(TRUE); | |
66 } | |
67 | |
68 /** | |
69 * Tests a field-based view's cache tags when using the "time" cache plugin. | |
70 */ | |
71 public function testFieldBasedViewCacheTagsWithCachePluginTime() { | |
72 $view = Views::getview('entity_test_fields'); | |
73 $view->getDisplay()->overrideOption('cache', [ | |
74 'type' => 'time', | |
75 'options' => [ | |
76 'results_lifespan' => 3600, | |
77 'output_lifespan' => 3600, | |
78 ], | |
79 ]); | |
80 $view->save(); | |
81 | |
82 $this->assertCacheTagsForFieldBasedView(TRUE); | |
83 } | |
84 | |
85 /** | |
86 * Tests cache tags on output & result cache items for a field-based view. | |
87 * | |
88 * @param bool $do_assert_views_caches | |
89 * Whether to check Views' result & output caches. | |
90 */ | |
91 protected function assertCacheTagsForFieldBasedView($do_assert_views_caches) { | |
92 $this->pass('Checking cache tags for field-based view.'); | |
93 $view = Views::getview('entity_test_fields'); | |
94 | |
95 // Empty result (no entities yet). | |
96 $this->pass('Test without entities'); | |
97 $base_tags = ['config:views.view.entity_test_fields', 'entity_test_list']; | |
98 $this->assertViewsCacheTags($view, $base_tags, $do_assert_views_caches, $base_tags); | |
99 $this->assertViewsCacheTagsFromStaticRenderArray($view, $base_tags, $do_assert_views_caches); | |
100 | |
101 | |
102 // Non-empty result (1 entity). | |
103 /** @var \Drupal\Core\Entity\EntityInterface[] $entities */ | |
104 $entities[] = $entity = EntityTest::create(); | |
105 $entity->save(); | |
106 | |
107 $this->pass('Test with entities'); | |
108 $tags_with_entity = Cache::mergeTags($base_tags, $entities[0]->getCacheTags()); | |
109 $this->assertViewsCacheTags($view, $tags_with_entity, $do_assert_views_caches, $tags_with_entity); | |
110 $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags_with_entity, $do_assert_views_caches); | |
111 | |
112 | |
113 // Paged result (more entities than the items-per-page limit). | |
114 for ($i = 0; $i < 5; $i++) { | |
115 $entities[] = $entity = EntityTest::create(); | |
116 $entity->save(); | |
117 } | |
118 | |
119 // Page 1. | |
120 $this->pass('Test pager'); | |
121 $this->pass('Page 1'); | |
122 \Drupal::request()->query->set('page', 0); | |
123 $tags_page_1 = Cache::mergeTags($base_tags, $entities[1]->getCacheTags()); | |
124 $tags_page_1 = Cache::mergeTags($tags_page_1, $entities[2]->getCacheTags()); | |
125 $tags_page_1 = Cache::mergeTags($tags_page_1, $entities[3]->getCacheTags()); | |
126 $tags_page_1 = Cache::mergeTags($tags_page_1, $entities[4]->getCacheTags()); | |
127 $tags_page_1 = Cache::mergeTags($tags_page_1, $entities[5]->getCacheTags()); | |
128 $this->assertViewsCacheTags($view, $tags_page_1, $do_assert_views_caches, $tags_page_1); | |
129 $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags_page_1, $do_assert_views_caches); | |
130 $view->destroy(); | |
131 // Page 2. | |
132 $this->pass('Page 2'); | |
133 $view->setCurrentPage(1); | |
134 \Drupal::request()->query->set('page', 1); | |
135 $tags_page_2 = Cache::mergeTags($base_tags, $entities[0]->getCacheTags()); | |
136 $this->assertViewsCacheTags($view, $tags_page_2, $do_assert_views_caches, $tags_page_2); | |
137 $view->destroy(); | |
138 | |
139 // Ensure that invalidation works on both pages. | |
140 $this->pass('Page invalidations'); | |
141 $this->pass('Page 2'); | |
142 $view->setCurrentPage(1); | |
143 \Drupal::request()->query->set('page', 1); | |
144 $entities[0]->name->value = $random_name = $this->randomMachineName(); | |
145 $entities[0]->save(); | |
146 $build = $this->assertViewsCacheTags($view, $tags_page_2, $do_assert_views_caches, $tags_page_2); | |
147 // @todo Static render arrays don't support different pages yet, see | |
148 // https://www.drupal.org/node/2500701. | |
149 // $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags_page_2, $do_assert_views_caches); | |
150 $this->assertTrue(strpos($build['#markup'], $random_name) !== FALSE); | |
151 $view->destroy(); | |
152 | |
153 $this->pass('Page 1'); | |
154 $view->setCurrentPage(0); | |
155 \Drupal::request()->query->set('page', 0); | |
156 $entities[1]->name->value = $random_name = $this->randomMachineName(); | |
157 $entities[1]->save(); | |
158 $build = $this->assertViewsCacheTags($view, $tags_page_1, $do_assert_views_caches, $tags_page_1); | |
159 $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags_page_1, $do_assert_views_caches); | |
160 $this->assertTrue(strpos($build['#markup'], $random_name) !== FALSE); | |
161 $view->destroy(); | |
162 | |
163 // Setup arguments to ensure that render caching also varies by them. | |
164 $this->pass('Test arguments'); | |
165 | |
166 // Custom assert for a single result row. | |
167 $single_entity_assertions = function (array $build, EntityInterface $entity) { | |
168 $this->setRawContent($build['#markup']); | |
169 | |
170 $result = $this->cssSelect('div.views-row'); | |
171 $count = count($result); | |
172 $this->assertEqual($count, 1); | |
173 | |
174 $this->assertEqual((string) $result[0]->div->span, (string) $entity->id()); | |
175 }; | |
176 | |
177 // Execute the view once with a static renderable and one with a full | |
178 // prepared render array. | |
179 $tags_argument = Cache::mergeTags($base_tags, $entities[0]->getCacheTags()); | |
180 $view->setArguments([$entities[0]->id()]); | |
181 $build = $this->assertViewsCacheTags($view, $tags_argument, $do_assert_views_caches, $tags_argument); | |
182 $single_entity_assertions($build, $entities[0]); | |
183 | |
184 $view->setArguments([$entities[0]->id()]); | |
185 $build = $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags_argument, $do_assert_views_caches); | |
186 $single_entity_assertions($build, $entities[0]); | |
187 | |
188 // Set a different argument and ensure that the result is different. | |
189 $tags2_argument = Cache::mergeTags($base_tags, $entities[1]->getCacheTags()); | |
190 $view->setArguments([$entities[1]->id()]); | |
191 $build = $this->assertViewsCacheTagsFromStaticRenderArray($view, $tags2_argument, $do_assert_views_caches); | |
192 $single_entity_assertions($build, $entities[1]); | |
193 | |
194 $view->destroy(); | |
195 } | |
196 | |
197 /** | |
198 * Tests a entity-based view's cache tags when using the "none" cache plugin. | |
199 */ | |
200 public function testEntityBasedViewCacheTagsWithCachePluginNone() { | |
201 $view = Views::getview('entity_test_row'); | |
202 $view->getDisplay()->overrideOption('cache', [ | |
203 'type' => 'none', | |
204 ]); | |
205 $view->save(); | |
206 | |
207 $this->assertCacheTagsForEntityBasedView(FALSE); | |
208 } | |
209 | |
210 /** | |
211 * Tests a entity-based view's cache tags when using the "tag" cache plugin. | |
212 */ | |
213 public function testEntityBasedViewCacheTagsWithCachePluginTag() { | |
214 $view = Views::getview('entity_test_row'); | |
215 $view->getDisplay()->overrideOption('cache', [ | |
216 'type' => 'tag', | |
217 ]); | |
218 $view->save(); | |
219 | |
220 $this->assertCacheTagsForEntityBasedView(TRUE); | |
221 } | |
222 | |
223 /** | |
224 * Tests a entity-based view's cache tags when using the "time" cache plugin. | |
225 */ | |
226 public function testEntityBasedViewCacheTagsWithCachePluginTime() { | |
227 $view = Views::getview('entity_test_row'); | |
228 $view->getDisplay()->overrideOption('cache', [ | |
229 'type' => 'time', | |
230 'options' => [ | |
231 'results_lifespan' => 3600, | |
232 'output_lifespan' => 3600, | |
233 ], | |
234 ]); | |
235 $view->save(); | |
236 | |
237 $this->assertCacheTagsForEntityBasedView(TRUE); | |
238 } | |
239 | |
240 /** | |
241 * Tests cache tags on output & result cache items for an entity-based view. | |
242 */ | |
243 protected function assertCacheTagsForEntityBasedView($do_assert_views_caches) { | |
244 $this->pass('Checking cache tags for entity-based view.'); | |
245 $view = Views::getview('entity_test_row'); | |
246 | |
247 // Empty result (no entities yet). | |
248 $base_tags = $base_render_tags = ['config:views.view.entity_test_row', 'entity_test_list']; | |
249 $this->assertViewsCacheTags($view, $base_tags, $do_assert_views_caches, $base_tags); | |
250 $this->assertViewsCacheTagsFromStaticRenderArray($view, $base_tags, $do_assert_views_caches); | |
251 | |
252 // Non-empty result (1 entity). | |
253 $entities[] = $entity = EntityTest::create(); | |
254 $entity->save(); | |
255 | |
256 $result_tags_with_entity = Cache::mergeTags($base_tags, $entities[0]->getCacheTags()); | |
257 $render_tags_with_entity = Cache::mergeTags($base_render_tags, $entities[0]->getCacheTags()); | |
258 $render_tags_with_entity = Cache::mergeTags($render_tags_with_entity, ['entity_test_view']); | |
259 $this->assertViewsCacheTags($view, $result_tags_with_entity, $do_assert_views_caches, $render_tags_with_entity); | |
260 $this->assertViewsCacheTagsFromStaticRenderArray($view, $render_tags_with_entity, $do_assert_views_caches); | |
261 | |
262 | |
263 // Paged result (more entities than the items-per-page limit). | |
264 for ($i = 0; $i < 5; $i++) { | |
265 $entities[] = $entity = EntityTest::create(); | |
266 $entity->save(); | |
267 } | |
268 | |
269 $new_entities_cache_tags = Cache::mergeTags($entities[1]->getCacheTags(), $entities[2]->getCacheTags()); | |
270 $new_entities_cache_tags = Cache::mergeTags($new_entities_cache_tags, $entities[3]->getCacheTags()); | |
271 $new_entities_cache_tags = Cache::mergeTags($new_entities_cache_tags, $entities[4]->getCacheTags()); | |
272 $new_entities_cache_tags = Cache::mergeTags($new_entities_cache_tags, $entities[5]->getCacheTags()); | |
273 $result_tags_page_1 = Cache::mergeTags($base_tags, $new_entities_cache_tags); | |
274 $render_tags_page_1 = Cache::mergeTags($base_render_tags, $new_entities_cache_tags); | |
275 $render_tags_page_1 = Cache::mergeTags($render_tags_page_1, ['entity_test_view']); | |
276 $this->assertViewsCacheTags($view, $result_tags_page_1, $do_assert_views_caches, $render_tags_page_1); | |
277 $this->assertViewsCacheTagsFromStaticRenderArray($view, $render_tags_page_1, $do_assert_views_caches); | |
278 } | |
279 | |
280 /** | |
281 * Ensure that the view renderable contains the cache contexts. | |
282 */ | |
283 public function testBuildRenderableWithCacheContexts() { | |
284 $view = View::load('test_view'); | |
285 $display =& $view->getDisplay('default'); | |
286 $display['cache_metadata']['contexts'] = ['views_test_cache_context']; | |
287 $executable = $view->getExecutable(); | |
288 | |
289 $build = $executable->buildRenderable(); | |
290 $this->assertEqual(['views_test_cache_context'], $build['#cache']['contexts']); | |
291 } | |
292 | |
293 /** | |
294 * Ensures that saving a view calculates the cache contexts. | |
295 */ | |
296 public function testViewAddCacheMetadata() { | |
297 $view = View::load('test_display'); | |
298 $view->save(); | |
299 | |
300 $this->assertEqual(['languages:' . LanguageInterface::TYPE_CONTENT, 'languages:' . LanguageInterface::TYPE_INTERFACE, 'url.query_args', 'user.node_grants:view', 'user.permissions'], $view->getDisplay('default')['cache_metadata']['contexts']); | |
301 } | |
302 | |
303 } |