www.aleph1.co.uk Git - yaffs-website/blob - web/core/modules/views/tests/src/Kernel/RenderCacheIntegrationTest.php

   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 }