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

   1 <?php
   2
   3 namespace Drupal\Tests\views\Kernel\Handler;
   4
   5 use Drupal\Tests\views\Kernel\ViewsKernelTestBase;
   6 use Drupal\views\Views;
   7
   8 /**
   9  * Tests the core Drupal\views\Plugin\views\filter\StringFilter handler.
  10  *
  11  * @group views
  12  */
  13 class FilterStringTest extends ViewsKernelTestBase {
  14
  15   public static $modules = ['system'];
  16
  17   /**
  18    * Views used by this test.
  19    *
  20    * @var array
  21    */
  22   public static $testViews = ['test_view'];
  23
  24   /**
  25    * Map column names.
  26    *
  27    * @var array
  28    */
  29   protected $columnMap = [
  30     'views_test_data_name' => 'name',
  31   ];
  32
  33   public function viewsData() {
  34     $data = parent::viewsData();
  35     $data['views_test_data']['name']['filter']['allow empty'] = TRUE;
  36     $data['views_test_data']['job']['filter']['allow empty'] = FALSE;
  37     $data['views_test_data']['description'] = $data['views_test_data']['name'];
  38
  39     return $data;
  40   }
  41
  42   /**
  43    * {@inheritdoc}
  44    */
  45   protected function schemaDefinition() {
  46     $schema = parent::schemaDefinition();
  47     $schema['views_test_data']['fields']['description'] = [
  48       'description' => "A person's description",
  49       'type' => 'text',
  50       'not null' => FALSE,
  51       'size' => 'big',
  52     ];
  53
  54     return $schema;
  55   }
  56
  57   /**
  58    * An extended test dataset.
  59    */
  60   protected function dataSet() {
  61     $dataset = parent::dataSet();
  62     $dataset[0]['description'] = 'John Winston Ono Lennon, MBE (9 October 1940 – 8 December 1980) was an English musician and singer-songwriter who rose to worldwide fame as one of the founding members of The Beatles, one of the most commercially successful and critically acclaimed acts in the history of popular music. Along with fellow Beatle Paul McCartney, he formed one of the most successful songwriting partnerships of the 20th century.';
  63     $dataset[1]['description'] = 'George Harrison,[1] MBE (25 February 1943 – 29 November 2001)[2] was an English rock guitarist, singer-songwriter, actor and film producer who achieved international fame as lead guitarist of The Beatles.';
  64     $dataset[2]['description'] = 'Richard Starkey, MBE (born 7 July 1940), better known by his stage name Ringo Starr, is an English musician, singer-songwriter, and actor who gained worldwide fame as the drummer for The Beatles.';
  65     $dataset[3]['description'] = 'Sir James Paul McCartney, MBE (born 18 June 1942) is an English musician, singer-songwriter and composer. Formerly of The Beatles (1960–1970) and Wings (1971–1981), McCartney is the most commercially successful songwriter in the history of popular music, according to Guinness World Records.[1]';
  66     $dataset[4]['description'] = NULL;
  67
  68     return $dataset;
  69   }
  70
  71   /**
  72    * Build and return a Page view of the views_test_data table.
  73    *
  74    * @return view
  75    */
  76   protected function getBasicPageView() {
  77     $view = Views::getView('test_view');
  78
  79     // In order to test exposed filters, we have to disable
  80     // the exposed forms cache.
  81     \Drupal::service('views.exposed_form_cache')->reset();
  82
  83     $view->newDisplay('page', 'Page', 'page_1');
  84     return $view;
  85   }
  86
  87   public function testFilterStringEqual() {
  88     $view = Views::getView('test_view');
  89     $view->setDisplay();
  90
  91     // Change the filtering
  92     $view->displayHandlers->get('default')->overrideOption('filters', [
  93       'name' => [
  94         'id' => 'name',
  95         'table' => 'views_test_data',
  96         'field' => 'name',
  97         'relationship' => 'none',
  98         'operator' => '=',
  99         'value' => 'Ringo',
 100       ],
 101     ]);
 102
 103     $this->executeView($view);
 104     $resultset = [
 105       [
 106         'name' => 'Ringo',
 107       ],
 108     ];
 109     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 110   }
 111
 112   public function testFilterStringGroupedExposedEqual() {
 113     $filters = $this->getGroupedExposedFilters();
 114     $view = $this->getBasicPageView();
 115
 116     // Filter: Name, Operator: =, Value: Ringo
 117     $filters['name']['group_info']['default_group'] = 1;
 118     $view->setDisplay('page_1');
 119     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 120     $view->save();
 121     $this->container->get('router.builder')->rebuild();
 122
 123     $this->executeView($view);
 124
 125     $resultset = [
 126       [
 127         'name' => 'Ringo',
 128       ],
 129     ];
 130
 131     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 132   }
 133
 134   public function testFilterStringNotEqual() {
 135     $view = Views::getView('test_view');
 136     $view->setDisplay();
 137
 138     // Change the filtering
 139     $view->displayHandlers->get('default')->overrideOption('filters', [
 140       'name' => [
 141         'id' => 'name',
 142         'table' => 'views_test_data',
 143         'field' => 'name',
 144         'relationship' => 'none',
 145         'operator' => '!=',
 146         'value' => 'Ringo',
 147       ],
 148     ]);
 149
 150     $this->executeView($view);
 151     $resultset = [
 152       [
 153         'name' => 'John',
 154       ],
 155       [
 156         'name' => 'George',
 157       ],
 158       [
 159         'name' => 'Paul',
 160       ],
 161       [
 162         'name' => 'Meredith',
 163       ],
 164     ];
 165     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 166   }
 167
 168   public function testFilterStringGroupedExposedNotEqual() {
 169     $filters = $this->getGroupedExposedFilters();
 170     $view = $this->getBasicPageView();
 171
 172     // Filter: Name, Operator: !=, Value: Ringo
 173     $filters['name']['group_info']['default_group'] = '2';
 174
 175     $view->setDisplay('page_1');
 176     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 177     $view->save();
 178     $this->container->get('router.builder')->rebuild();
 179
 180     $this->executeView($view);
 181
 182     $resultset = [
 183       [
 184         'name' => 'John',
 185       ],
 186       [
 187         'name' => 'George',
 188       ],
 189       [
 190         'name' => 'Paul',
 191       ],
 192       [
 193         'name' => 'Meredith',
 194       ],
 195     ];
 196
 197     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 198   }
 199
 200   public function testFilterStringContains() {
 201     $view = Views::getView('test_view');
 202     $view->setDisplay();
 203
 204     // Change the filtering
 205     $view->displayHandlers->get('default')->overrideOption('filters', [
 206       'name' => [
 207         'id' => 'name',
 208         'table' => 'views_test_data',
 209         'field' => 'name',
 210         'relationship' => 'none',
 211         'operator' => 'contains',
 212         'value' => 'ing',
 213       ],
 214     ]);
 215
 216     $this->executeView($view);
 217     $resultset = [
 218       [
 219         'name' => 'Ringo',
 220       ],
 221     ];
 222     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 223   }
 224
 225   public function testFilterStringGroupedExposedContains() {
 226     $filters = $this->getGroupedExposedFilters();
 227     $view = $this->getBasicPageView();
 228
 229     // Filter: Name, Operator: contains, Value: ing
 230     $filters['name']['group_info']['default_group'] = '3';
 231     $view->setDisplay('page_1');
 232     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 233     $view->save();
 234     $this->container->get('router.builder')->rebuild();
 235
 236     $this->executeView($view);
 237
 238     $resultset = [
 239       [
 240         'name' => 'Ringo',
 241       ],
 242     ];
 243
 244     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 245   }
 246
 247   public function testFilterStringWord() {
 248     $view = Views::getView('test_view');
 249     $view->setDisplay();
 250
 251     // Change the filtering
 252     $view->displayHandlers->get('default')->overrideOption('filters', [
 253       'description' => [
 254         'id' => 'description',
 255         'table' => 'views_test_data',
 256         'field' => 'description',
 257         'relationship' => 'none',
 258         'operator' => 'word',
 259         'value' => 'actor',
 260       ],
 261     ]);
 262
 263     $this->executeView($view);
 264     $resultset = [
 265       [
 266         'name' => 'George',
 267       ],
 268       [
 269         'name' => 'Ringo',
 270       ],
 271     ];
 272     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 273     $view->destroy();
 274
 275     $view = Views::getView('test_view');
 276     $view->setDisplay();
 277
 278     // Change the filtering
 279     $view->displayHandlers->get('default')->overrideOption('filters', [
 280       'description' => [
 281         'id' => 'description',
 282         'table' => 'views_test_data',
 283         'field' => 'description',
 284         'relationship' => 'none',
 285         'operator' => 'allwords',
 286         'value' => 'Richard Starkey',
 287       ],
 288     ]);
 289
 290     $this->executeView($view);
 291     $resultset = [
 292       [
 293         'name' => 'Ringo',
 294       ],
 295     ];
 296     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 297     $view->destroy();
 298
 299     $view = Views::getView('test_view');
 300     $view->setDisplay();
 301
 302     // Change the filtering to a sting containing only illegal characters.
 303     $view->displayHandlers->get('default')->overrideOption('filters', [
 304       'description' => [
 305         'id' => 'description',
 306         'table' => 'views_test_data',
 307         'field' => 'description',
 308         'relationship' => 'none',
 309         'operator' => 'allwords',
 310         'value' => ':-)',
 311       ],
 312     ]);
 313
 314     $this->executeView($view);
 315     $resultset = [
 316       [
 317         'name' => 'Ringo',
 318       ],
 319       [
 320         'name' => 'John',
 321       ],
 322       [
 323         'name' => 'George',
 324       ],
 325       [
 326         'name' => 'Paul',
 327       ],
 328       [
 329         'name' => 'Meredith',
 330       ],
 331     ];
 332     $this->assertIdenticalResultset($view, $resultset);
 333   }
 334
 335   public function testFilterStringGroupedExposedWord() {
 336     $filters = $this->getGroupedExposedFilters();
 337     $view = $this->getBasicPageView();
 338
 339     // Filter: Name, Operator: contains, Value: ing
 340     $filters['name']['group_info']['default_group'] = '3';
 341     $view->setDisplay('page_1');
 342     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 343     $view->save();
 344     $this->container->get('router.builder')->rebuild();
 345
 346     $this->executeView($view);
 347
 348     $resultset = [
 349       [
 350         'name' => 'Ringo',
 351       ],
 352     ];
 353
 354     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 355     $view->destroy();
 356
 357     $filters = $this->getGroupedExposedFilters();
 358     $view = $this->getBasicPageView();
 359
 360     // Filter: Description, Operator: contains, Value: actor
 361     $filters['description']['group_info']['default_group'] = '1';
 362     $view->setDisplay('page_1');
 363     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 364
 365     $this->executeView($view);
 366     $resultset = [
 367       [
 368         'name' => 'George',
 369       ],
 370       [
 371         'name' => 'Ringo',
 372       ],
 373     ];
 374     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 375   }
 376
 377   public function testFilterStringStarts() {
 378     $view = Views::getView('test_view');
 379     $view->setDisplay();
 380
 381     // Change the filtering
 382     $view->displayHandlers->get('default')->overrideOption('filters', [
 383       'description' => [
 384         'id' => 'description',
 385         'table' => 'views_test_data',
 386         'field' => 'description',
 387         'relationship' => 'none',
 388         'operator' => 'starts',
 389         'value' => 'George',
 390       ],
 391     ]);
 392
 393     $this->executeView($view);
 394     $resultset = [
 395       [
 396         'name' => 'George',
 397       ],
 398     ];
 399     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 400   }
 401
 402   public function testFilterStringGroupedExposedStarts() {
 403     $filters = $this->getGroupedExposedFilters();
 404     $view = $this->getBasicPageView();
 405
 406     // Filter: Name, Operator: starts, Value: George
 407     $filters['description']['group_info']['default_group'] = 2;
 408     $view->setDisplay('page_1');
 409     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 410     $view->save();
 411     $this->container->get('router.builder')->rebuild();
 412
 413     $this->executeView($view);
 414
 415     $resultset = [
 416       [
 417         'name' => 'George',
 418       ],
 419     ];
 420     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 421   }
 422
 423   public function testFilterStringNotStarts() {
 424     $view = Views::getView('test_view');
 425     $view->setDisplay();
 426
 427     // Change the filtering
 428     $view->displayHandlers->get('default')->overrideOption('filters', [
 429       'description' => [
 430         'id' => 'description',
 431         'table' => 'views_test_data',
 432         'field' => 'description',
 433         'relationship' => 'none',
 434         'operator' => 'not_starts',
 435         'value' => 'George',
 436       ],
 437     ]);
 438
 439     $this->executeView($view);
 440     $resultset = [
 441       [
 442         'name' => 'John',
 443       ],
 444       [
 445         'name' => 'Ringo',
 446       ],
 447       [
 448         'name' => 'Paul',
 449       ],
 450       // There is no Meredith returned because his description is empty
 451     ];
 452     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 453   }
 454
 455   public function testFilterStringGroupedExposedNotStarts() {
 456     $filters = $this->getGroupedExposedFilters();
 457     $view = $this->getBasicPageView();
 458
 459     // Filter: Name, Operator: not_starts, Value: George
 460     $filters['description']['group_info']['default_group'] = 3;
 461     $view->setDisplay('page_1');
 462     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 463     $view->save();
 464     $this->container->get('router.builder')->rebuild();
 465
 466     $this->executeView($view);
 467
 468     $resultset = [
 469       [
 470         'name' => 'John',
 471       ],
 472       [
 473         'name' => 'Ringo',
 474       ],
 475       [
 476         'name' => 'Paul',
 477       ],
 478       // There is no Meredith returned because his description is empty
 479     ];
 480     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 481   }
 482
 483   public function testFilterStringEnds() {
 484     $view = Views::getView('test_view');
 485     $view->setDisplay();
 486
 487     // Change the filtering
 488     $view->displayHandlers->get('default')->overrideOption('filters', [
 489       'description' => [
 490         'id' => 'description',
 491         'table' => 'views_test_data',
 492         'field' => 'description',
 493         'relationship' => 'none',
 494         'operator' => 'ends',
 495         'value' => 'Beatles.',
 496       ],
 497     ]);
 498
 499     $this->executeView($view);
 500     $resultset = [
 501       [
 502         'name' => 'George',
 503       ],
 504       [
 505         'name' => 'Ringo',
 506       ],
 507     ];
 508     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 509   }
 510
 511   public function testFilterStringGroupedExposedEnds() {
 512     $filters = $this->getGroupedExposedFilters();
 513     $view = $this->getBasicPageView();
 514
 515     // Filter: Description, Operator: ends, Value: Beatles
 516     $filters['description']['group_info']['default_group'] = 4;
 517     $view->setDisplay('page_1');
 518     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 519     $view->save();
 520     $this->container->get('router.builder')->rebuild();
 521
 522     $this->executeView($view);
 523
 524     $resultset = [
 525       [
 526         'name' => 'George',
 527       ],
 528       [
 529         'name' => 'Ringo',
 530       ],
 531     ];
 532     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 533   }
 534
 535   public function testFilterStringNotEnds() {
 536     $view = Views::getView('test_view');
 537     $view->setDisplay();
 538
 539     // Change the filtering
 540     $view->displayHandlers->get('default')->overrideOption('filters', [
 541       'description' => [
 542         'id' => 'description',
 543         'table' => 'views_test_data',
 544         'field' => 'description',
 545         'relationship' => 'none',
 546         'operator' => 'not_ends',
 547         'value' => 'Beatles.',
 548       ],
 549     ]);
 550
 551     $this->executeView($view);
 552     $resultset = [
 553       [
 554         'name' => 'John',
 555       ],
 556       [
 557         'name' => 'Paul',
 558       ],
 559       // There is no Meredith returned because his description is empty
 560     ];
 561     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 562   }
 563
 564   public function testFilterStringGroupedExposedNotEnds() {
 565     $filters = $this->getGroupedExposedFilters();
 566     $view = $this->getBasicPageView();
 567
 568     // Filter: Description, Operator: not_ends, Value: Beatles
 569     $filters['description']['group_info']['default_group'] = 5;
 570     $view->setDisplay('page_1');
 571     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 572     $view->save();
 573     $this->container->get('router.builder')->rebuild();
 574
 575     $this->executeView($view);
 576
 577     $resultset = [
 578       [
 579         'name' => 'John',
 580       ],
 581       [
 582         'name' => 'Paul',
 583       ],
 584       // There is no Meredith returned because his description is empty
 585     ];
 586     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 587   }
 588
 589   public function testFilterStringNot() {
 590     $view = Views::getView('test_view');
 591     $view->setDisplay();
 592
 593     // Change the filtering
 594     $view->displayHandlers->get('default')->overrideOption('filters', [
 595       'description' => [
 596         'id' => 'description',
 597         'table' => 'views_test_data',
 598         'field' => 'description',
 599         'relationship' => 'none',
 600         'operator' => 'not',
 601         'value' => 'Beatles.',
 602       ],
 603     ]);
 604
 605     $this->executeView($view);
 606     $resultset = [
 607       [
 608         'name' => 'John',
 609       ],
 610       [
 611         'name' => 'Paul',
 612       ],
 613       // There is no Meredith returned because his description is empty
 614     ];
 615     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 616   }
 617
 618   public function testFilterStringGroupedExposedNot() {
 619     $filters = $this->getGroupedExposedFilters();
 620     $view = $this->getBasicPageView();
 621
 622     // Filter: Description, Operator: not (does not contains), Value: Beatles
 623     $filters['description']['group_info']['default_group'] = 6;
 624     $view->setDisplay('page_1');
 625     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 626     $view->save();
 627     $this->container->get('router.builder')->rebuild();
 628
 629     $this->executeView($view);
 630
 631     $resultset = [
 632       [
 633         'name' => 'John',
 634       ],
 635       [
 636         'name' => 'Paul',
 637       ],
 638       // There is no Meredith returned because his description is empty
 639     ];
 640     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 641
 642   }
 643
 644   public function testFilterStringShorter() {
 645     $view = Views::getView('test_view');
 646     $view->setDisplay();
 647
 648     // Change the filtering
 649     $view->displayHandlers->get('default')->overrideOption('filters', [
 650       'name' => [
 651         'id' => 'name',
 652         'table' => 'views_test_data',
 653         'field' => 'name',
 654         'relationship' => 'none',
 655         'operator' => 'shorterthan',
 656         'value' => 5,
 657       ],
 658     ]);
 659
 660     $this->executeView($view);
 661     $resultset = [
 662       [
 663         'name' => 'John',
 664       ],
 665       [
 666         'name' => 'Paul',
 667       ],
 668     ];
 669     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 670   }
 671
 672   public function testFilterStringGroupedExposedShorter() {
 673     $filters = $this->getGroupedExposedFilters();
 674     $view = $this->getBasicPageView();
 675
 676     // Filter: Name, Operator: shorterthan, Value: 5
 677     $filters['name']['group_info']['default_group'] = 4;
 678     $view->setDisplay('page_1');
 679     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 680     $view->save();
 681     $this->container->get('router.builder')->rebuild();
 682
 683     $this->executeView($view);
 684     $resultset = [
 685       [
 686         'name' => 'John',
 687       ],
 688       [
 689         'name' => 'Paul',
 690       ],
 691     ];
 692     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 693   }
 694
 695   public function testFilterStringLonger() {
 696     $view = Views::getView('test_view');
 697     $view->setDisplay();
 698
 699     // Change the filtering
 700     $view->displayHandlers->get('default')->overrideOption('filters', [
 701       'name' => [
 702         'id' => 'name',
 703         'table' => 'views_test_data',
 704         'field' => 'name',
 705         'relationship' => 'none',
 706         'operator' => 'longerthan',
 707         'value' => 7,
 708       ],
 709     ]);
 710
 711     $this->executeView($view);
 712     $resultset = [
 713       [
 714         'name' => 'Meredith',
 715       ],
 716     ];
 717     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 718   }
 719
 720   public function testFilterStringGroupedExposedLonger() {
 721     $filters = $this->getGroupedExposedFilters();
 722     $view = $this->getBasicPageView();
 723
 724     // Filter: Name, Operator: longerthan, Value: 4
 725     $filters['name']['group_info']['default_group'] = 5;
 726     $view->setDisplay('page_1');
 727     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 728     $view->save();
 729     $this->container->get('router.builder')->rebuild();
 730
 731     $this->executeView($view);
 732     $resultset = [
 733       [
 734         'name' => 'Meredith',
 735       ],
 736     ];
 737     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 738   }
 739
 740   public function testFilterStringEmpty() {
 741     $view = Views::getView('test_view');
 742     $view->setDisplay();
 743
 744     // Change the filtering
 745     $view->displayHandlers->get('default')->overrideOption('filters', [
 746       'description' => [
 747         'id' => 'description',
 748         'table' => 'views_test_data',
 749         'field' => 'description',
 750         'relationship' => 'none',
 751         'operator' => 'empty',
 752       ],
 753     ]);
 754
 755     $this->executeView($view);
 756     $resultset = [
 757       [
 758         'name' => 'Meredith',
 759       ],
 760     ];
 761     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 762   }
 763
 764   public function testFilterStringGroupedExposedEmpty() {
 765     $filters = $this->getGroupedExposedFilters();
 766     $view = $this->getBasicPageView();
 767
 768     // Filter: Description, Operator: empty, Value:
 769     $filters['description']['group_info']['default_group'] = 7;
 770     $view->setDisplay('page_1');
 771     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 772     $view->save();
 773     $this->container->get('router.builder')->rebuild();
 774
 775     $this->executeView($view);
 776     $resultset = [
 777       [
 778         'name' => 'Meredith',
 779       ],
 780     ];
 781     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 782   }
 783
 784   protected function getGroupedExposedFilters() {
 785     $filters = [
 786       'name' => [
 787         'id' => 'name',
 788         'plugin_id' => 'string',
 789         'table' => 'views_test_data',
 790         'field' => 'name',
 791         'relationship' => 'none',
 792         'exposed' => TRUE,
 793         'expose' => [
 794           'operator' => 'name_op',
 795           'label' => 'name',
 796           'identifier' => 'name',
 797         ],
 798         'is_grouped' => TRUE,
 799         'group_info' => [
 800           'label' => 'name',
 801           'identifier' => 'name',
 802           'default_group' => 'All',
 803           'group_items' => [
 804             1 => [
 805               'title' => 'Is Ringo',
 806               'operator' => '=',
 807               'value' => 'Ringo',
 808             ],
 809             2 => [
 810               'title' => 'Is not Ringo',
 811               'operator' => '!=',
 812               'value' => 'Ringo',
 813             ],
 814             3 => [
 815               'title' => 'Contains ing',
 816               'operator' => 'contains',
 817               'value' => 'ing',
 818             ],
 819             4 => [
 820               'title' => 'Shorter than 5 letters',
 821               'operator' => 'shorterthan',
 822               'value' => 5,
 823             ],
 824             5 => [
 825               'title' => 'Longer than 7 letters',
 826               'operator' => 'longerthan',
 827               'value' => 7,
 828             ],
 829           ],
 830         ],
 831       ],
 832       'description' => [
 833         'id' => 'description',
 834         'plugin_id' => 'string',
 835         'table' => 'views_test_data',
 836         'field' => 'description',
 837         'relationship' => 'none',
 838         'exposed' => TRUE,
 839         'expose' => [
 840           'operator' => 'description_op',
 841           'label' => 'description',
 842           'identifier' => 'description',
 843         ],
 844         'is_grouped' => TRUE,
 845         'group_info' => [
 846           'label' => 'description',
 847           'identifier' => 'description',
 848           'default_group' => 'All',
 849           'group_items' => [
 850             1 => [
 851               'title' => 'Contains the word: Actor',
 852               'operator' => 'word',
 853               'value' => 'actor',
 854             ],
 855             2 => [
 856               'title' => 'Starts with George',
 857               'operator' => 'starts',
 858               'value' => 'George',
 859             ],
 860             3 => [
 861               'title' => 'Not Starts with: George',
 862               'operator' => 'not_starts',
 863               'value' => 'George',
 864             ],
 865             4 => [
 866               'title' => 'Ends with: Beatles',
 867               'operator' => 'ends',
 868               'value' => 'Beatles.',
 869             ],
 870             5 => [
 871               'title' => 'Not Ends with: Beatles',
 872               'operator' => 'not_ends',
 873               'value' => 'Beatles.',
 874             ],
 875             6 => [
 876               'title' => 'Does not contain: Beatles',
 877               'operator' => 'not',
 878               'value' => 'Beatles.',
 879             ],
 880             7 => [
 881               'title' => 'Empty description',
 882               'operator' => 'empty',
 883               'value' => '',
 884             ],
 885           ],
 886         ],
 887       ],
 888     ];
 889     return $filters;
 890   }
 891
 892 }