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 }