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
 226   public function testFilterStringGroupedExposedContains() {
 227     $filters = $this->getGroupedExposedFilters();
 228     $view = $this->getBasicPageView();
 229
 230     // Filter: Name, Operator: contains, Value: ing
 231     $filters['name']['group_info']['default_group'] = '3';
 232     $view->setDisplay('page_1');
 233     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 234     $view->save();
 235     $this->container->get('router.builder')->rebuild();
 236
 237     $this->executeView($view);
 238
 239     $resultset = [
 240       [
 241         'name' => 'Ringo',
 242       ],
 243     ];
 244
 245     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 246   }
 247
 248
 249   public function testFilterStringWord() {
 250     $view = Views::getView('test_view');
 251     $view->setDisplay();
 252
 253     // Change the filtering
 254     $view->displayHandlers->get('default')->overrideOption('filters', [
 255       'description' => [
 256         'id' => 'description',
 257         'table' => 'views_test_data',
 258         'field' => 'description',
 259         'relationship' => 'none',
 260         'operator' => 'word',
 261         'value' => 'actor',
 262       ],
 263     ]);
 264
 265     $this->executeView($view);
 266     $resultset = [
 267       [
 268         'name' => 'George',
 269       ],
 270       [
 271         'name' => 'Ringo',
 272       ],
 273     ];
 274     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 275     $view->destroy();
 276
 277     $view = Views::getView('test_view');
 278     $view->setDisplay();
 279
 280     // Change the filtering
 281     $view->displayHandlers->get('default')->overrideOption('filters', [
 282       'description' => [
 283         'id' => 'description',
 284         'table' => 'views_test_data',
 285         'field' => 'description',
 286         'relationship' => 'none',
 287         'operator' => 'allwords',
 288         'value' => 'Richard Starkey',
 289       ],
 290     ]);
 291
 292     $this->executeView($view);
 293     $resultset = [
 294       [
 295         'name' => 'Ringo',
 296       ],
 297     ];
 298     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 299     $view->destroy();
 300
 301     $view = Views::getView('test_view');
 302     $view->setDisplay();
 303
 304     // Change the filtering to a sting containing only illegal characters.
 305     $view->displayHandlers->get('default')->overrideOption('filters', [
 306       'description' => [
 307         'id' => 'description',
 308         'table' => 'views_test_data',
 309         'field' => 'description',
 310         'relationship' => 'none',
 311         'operator' => 'allwords',
 312         'value' => ':-)',
 313       ],
 314     ]);
 315
 316     $this->executeView($view);
 317     $resultset = [
 318       [
 319         'name' => 'Ringo',
 320       ],
 321       [
 322         'name' => 'John',
 323       ],
 324       [
 325         'name' => 'George',
 326       ],
 327       [
 328         'name' => 'Paul',
 329       ],
 330       [
 331         'name' => 'Meredith',
 332       ],
 333     ];
 334     $this->assertIdenticalResultset($view, $resultset);
 335   }
 336
 337
 338   public function testFilterStringGroupedExposedWord() {
 339     $filters = $this->getGroupedExposedFilters();
 340     $view = $this->getBasicPageView();
 341
 342     // Filter: Name, Operator: contains, Value: ing
 343     $filters['name']['group_info']['default_group'] = '3';
 344     $view->setDisplay('page_1');
 345     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 346     $view->save();
 347     $this->container->get('router.builder')->rebuild();
 348
 349     $this->executeView($view);
 350
 351     $resultset = [
 352       [
 353         'name' => 'Ringo',
 354       ],
 355     ];
 356
 357     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 358     $view->destroy();
 359
 360     $filters = $this->getGroupedExposedFilters();
 361     $view = $this->getBasicPageView();
 362
 363     // Filter: Description, Operator: contains, Value: actor
 364     $filters['description']['group_info']['default_group'] = '1';
 365     $view->setDisplay('page_1');
 366     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 367
 368     $this->executeView($view);
 369     $resultset = [
 370       [
 371         'name' => 'George',
 372       ],
 373       [
 374         'name' => 'Ringo',
 375       ],
 376     ];
 377     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 378   }
 379
 380   public function testFilterStringStarts() {
 381     $view = Views::getView('test_view');
 382     $view->setDisplay();
 383
 384     // Change the filtering
 385     $view->displayHandlers->get('default')->overrideOption('filters', [
 386       'description' => [
 387         'id' => 'description',
 388         'table' => 'views_test_data',
 389         'field' => 'description',
 390         'relationship' => 'none',
 391         'operator' => 'starts',
 392         'value' => 'George',
 393       ],
 394     ]);
 395
 396     $this->executeView($view);
 397     $resultset = [
 398       [
 399         'name' => 'George',
 400       ],
 401     ];
 402     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 403   }
 404
 405   public function testFilterStringGroupedExposedStarts() {
 406     $filters = $this->getGroupedExposedFilters();
 407     $view = $this->getBasicPageView();
 408
 409     // Filter: Name, Operator: starts, Value: George
 410     $filters['description']['group_info']['default_group'] = 2;
 411     $view->setDisplay('page_1');
 412     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 413     $view->save();
 414     $this->container->get('router.builder')->rebuild();
 415
 416     $this->executeView($view);
 417
 418     $resultset = [
 419       [
 420         'name' => 'George',
 421       ],
 422     ];
 423     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 424   }
 425
 426   public function testFilterStringNotStarts() {
 427     $view = Views::getView('test_view');
 428     $view->setDisplay();
 429
 430     // Change the filtering
 431     $view->displayHandlers->get('default')->overrideOption('filters', [
 432       'description' => [
 433         'id' => 'description',
 434         'table' => 'views_test_data',
 435         'field' => 'description',
 436         'relationship' => 'none',
 437         'operator' => 'not_starts',
 438         'value' => 'George',
 439       ],
 440     ]);
 441
 442     $this->executeView($view);
 443     $resultset = [
 444       [
 445         'name' => 'John',
 446       ],
 447       [
 448         'name' => 'Ringo',
 449       ],
 450       [
 451         'name' => 'Paul',
 452       ],
 453       // There is no Meredith returned because his description is empty
 454     ];
 455     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 456   }
 457
 458   public function testFilterStringGroupedExposedNotStarts() {
 459     $filters = $this->getGroupedExposedFilters();
 460     $view = $this->getBasicPageView();
 461
 462     // Filter: Name, Operator: not_starts, Value: George
 463     $filters['description']['group_info']['default_group'] = 3;
 464     $view->setDisplay('page_1');
 465     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 466     $view->save();
 467     $this->container->get('router.builder')->rebuild();
 468
 469     $this->executeView($view);
 470
 471     $resultset = [
 472       [
 473         'name' => 'John',
 474       ],
 475       [
 476         'name' => 'Ringo',
 477       ],
 478       [
 479         'name' => 'Paul',
 480       ],
 481       // There is no Meredith returned because his description is empty
 482     ];
 483     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 484   }
 485
 486   public function testFilterStringEnds() {
 487     $view = Views::getView('test_view');
 488     $view->setDisplay();
 489
 490     // Change the filtering
 491     $view->displayHandlers->get('default')->overrideOption('filters', [
 492       'description' => [
 493         'id' => 'description',
 494         'table' => 'views_test_data',
 495         'field' => 'description',
 496         'relationship' => 'none',
 497         'operator' => 'ends',
 498         'value' => 'Beatles.',
 499       ],
 500     ]);
 501
 502     $this->executeView($view);
 503     $resultset = [
 504       [
 505         'name' => 'George',
 506       ],
 507       [
 508         'name' => 'Ringo',
 509       ],
 510     ];
 511     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 512   }
 513
 514   public function testFilterStringGroupedExposedEnds() {
 515     $filters = $this->getGroupedExposedFilters();
 516     $view = $this->getBasicPageView();
 517
 518     // Filter: Description, Operator: ends, Value: Beatles
 519     $filters['description']['group_info']['default_group'] = 4;
 520     $view->setDisplay('page_1');
 521     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 522     $view->save();
 523     $this->container->get('router.builder')->rebuild();
 524
 525     $this->executeView($view);
 526
 527     $resultset = [
 528       [
 529         'name' => 'George',
 530       ],
 531       [
 532         'name' => 'Ringo',
 533       ],
 534     ];
 535     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 536   }
 537
 538   public function testFilterStringNotEnds() {
 539     $view = Views::getView('test_view');
 540     $view->setDisplay();
 541
 542     // Change the filtering
 543     $view->displayHandlers->get('default')->overrideOption('filters', [
 544       'description' => [
 545         'id' => 'description',
 546         'table' => 'views_test_data',
 547         'field' => 'description',
 548         'relationship' => 'none',
 549         'operator' => 'not_ends',
 550         'value' => 'Beatles.',
 551       ],
 552     ]);
 553
 554     $this->executeView($view);
 555     $resultset = [
 556       [
 557         'name' => 'John',
 558       ],
 559       [
 560         'name' => 'Paul',
 561       ],
 562       // There is no Meredith returned because his description is empty
 563     ];
 564     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 565   }
 566
 567   public function testFilterStringGroupedExposedNotEnds() {
 568     $filters = $this->getGroupedExposedFilters();
 569     $view = $this->getBasicPageView();
 570
 571     // Filter: Description, Operator: not_ends, Value: Beatles
 572     $filters['description']['group_info']['default_group'] = 5;
 573     $view->setDisplay('page_1');
 574     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 575     $view->save();
 576     $this->container->get('router.builder')->rebuild();
 577
 578     $this->executeView($view);
 579
 580     $resultset = [
 581       [
 582         'name' => 'John',
 583       ],
 584       [
 585         'name' => 'Paul',
 586       ],
 587       // There is no Meredith returned because his description is empty
 588     ];
 589     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 590   }
 591
 592   public function testFilterStringNot() {
 593     $view = Views::getView('test_view');
 594     $view->setDisplay();
 595
 596     // Change the filtering
 597     $view->displayHandlers->get('default')->overrideOption('filters', [
 598       'description' => [
 599         'id' => 'description',
 600         'table' => 'views_test_data',
 601         'field' => 'description',
 602         'relationship' => 'none',
 603         'operator' => 'not',
 604         'value' => 'Beatles.',
 605       ],
 606     ]);
 607
 608     $this->executeView($view);
 609     $resultset = [
 610       [
 611         'name' => 'John',
 612       ],
 613       [
 614         'name' => 'Paul',
 615       ],
 616       // There is no Meredith returned because his description is empty
 617     ];
 618     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 619   }
 620
 621
 622   public function testFilterStringGroupedExposedNot() {
 623     $filters = $this->getGroupedExposedFilters();
 624     $view = $this->getBasicPageView();
 625
 626     // Filter: Description, Operator: not (does not contains), Value: Beatles
 627     $filters['description']['group_info']['default_group'] = 6;
 628     $view->setDisplay('page_1');
 629     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 630     $view->save();
 631     $this->container->get('router.builder')->rebuild();
 632
 633     $this->executeView($view);
 634
 635     $resultset = [
 636       [
 637         'name' => 'John',
 638       ],
 639       [
 640         'name' => 'Paul',
 641       ],
 642       // There is no Meredith returned because his description is empty
 643     ];
 644     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 645
 646   }
 647
 648   public function testFilterStringShorter() {
 649     $view = Views::getView('test_view');
 650     $view->setDisplay();
 651
 652     // Change the filtering
 653     $view->displayHandlers->get('default')->overrideOption('filters', [
 654       'name' => [
 655         'id' => 'name',
 656         'table' => 'views_test_data',
 657         'field' => 'name',
 658         'relationship' => 'none',
 659         'operator' => 'shorterthan',
 660         'value' => 5,
 661       ],
 662     ]);
 663
 664     $this->executeView($view);
 665     $resultset = [
 666       [
 667         'name' => 'John',
 668       ],
 669       [
 670         'name' => 'Paul',
 671       ],
 672     ];
 673     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 674   }
 675
 676   public function testFilterStringGroupedExposedShorter() {
 677     $filters = $this->getGroupedExposedFilters();
 678     $view = $this->getBasicPageView();
 679
 680     // Filter: Name, Operator: shorterthan, Value: 5
 681     $filters['name']['group_info']['default_group'] = 4;
 682     $view->setDisplay('page_1');
 683     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 684     $view->save();
 685     $this->container->get('router.builder')->rebuild();
 686
 687     $this->executeView($view);
 688     $resultset = [
 689       [
 690         'name' => 'John',
 691       ],
 692       [
 693         'name' => 'Paul',
 694       ],
 695     ];
 696     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 697   }
 698
 699   public function testFilterStringLonger() {
 700     $view = Views::getView('test_view');
 701     $view->setDisplay();
 702
 703     // Change the filtering
 704     $view->displayHandlers->get('default')->overrideOption('filters', [
 705       'name' => [
 706         'id' => 'name',
 707         'table' => 'views_test_data',
 708         'field' => 'name',
 709         'relationship' => 'none',
 710         'operator' => 'longerthan',
 711         'value' => 7,
 712       ],
 713     ]);
 714
 715     $this->executeView($view);
 716     $resultset = [
 717       [
 718         'name' => 'Meredith',
 719       ],
 720     ];
 721     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 722   }
 723
 724   public function testFilterStringGroupedExposedLonger() {
 725     $filters = $this->getGroupedExposedFilters();
 726     $view = $this->getBasicPageView();
 727
 728     // Filter: Name, Operator: longerthan, Value: 4
 729     $filters['name']['group_info']['default_group'] = 5;
 730     $view->setDisplay('page_1');
 731     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 732     $view->save();
 733     $this->container->get('router.builder')->rebuild();
 734
 735     $this->executeView($view);
 736     $resultset = [
 737       [
 738         'name' => 'Meredith',
 739       ],
 740     ];
 741     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 742   }
 743
 744
 745   public function testFilterStringEmpty() {
 746     $view = Views::getView('test_view');
 747     $view->setDisplay();
 748
 749     // Change the filtering
 750     $view->displayHandlers->get('default')->overrideOption('filters', [
 751       'description' => [
 752         'id' => 'description',
 753         'table' => 'views_test_data',
 754         'field' => 'description',
 755         'relationship' => 'none',
 756         'operator' => 'empty',
 757       ],
 758     ]);
 759
 760     $this->executeView($view);
 761     $resultset = [
 762       [
 763         'name' => 'Meredith',
 764       ],
 765     ];
 766     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 767   }
 768
 769   public function testFilterStringGroupedExposedEmpty() {
 770     $filters = $this->getGroupedExposedFilters();
 771     $view = $this->getBasicPageView();
 772
 773     // Filter: Description, Operator: empty, Value:
 774     $filters['description']['group_info']['default_group'] = 7;
 775     $view->setDisplay('page_1');
 776     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 777     $view->save();
 778     $this->container->get('router.builder')->rebuild();
 779
 780     $this->executeView($view);
 781     $resultset = [
 782       [
 783         'name' => 'Meredith',
 784       ],
 785     ];
 786     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 787   }
 788
 789   protected function getGroupedExposedFilters() {
 790     $filters = [
 791       'name' => [
 792         'id' => 'name',
 793         'plugin_id' => 'string',
 794         'table' => 'views_test_data',
 795         'field' => 'name',
 796         'relationship' => 'none',
 797         'exposed' => TRUE,
 798         'expose' => [
 799           'operator' => 'name_op',
 800           'label' => 'name',
 801           'identifier' => 'name',
 802         ],
 803         'is_grouped' => TRUE,
 804         'group_info' => [
 805           'label' => 'name',
 806           'identifier' => 'name',
 807           'default_group' => 'All',
 808           'group_items' => [
 809             1 => [
 810               'title' => 'Is Ringo',
 811               'operator' => '=',
 812               'value' => 'Ringo',
 813             ],
 814             2 => [
 815               'title' => 'Is not Ringo',
 816               'operator' => '!=',
 817               'value' => 'Ringo',
 818             ],
 819             3 => [
 820               'title' => 'Contains ing',
 821               'operator' => 'contains',
 822               'value' => 'ing',
 823             ],
 824             4 => [
 825               'title' => 'Shorter than 5 letters',
 826               'operator' => 'shorterthan',
 827               'value' => 5,
 828             ],
 829             5 => [
 830               'title' => 'Longer than 7 letters',
 831               'operator' => 'longerthan',
 832               'value' => 7,
 833             ],
 834           ],
 835         ],
 836       ],
 837       'description' => [
 838         'id' => 'description',
 839         'plugin_id' => 'string',
 840         'table' => 'views_test_data',
 841         'field' => 'description',
 842         'relationship' => 'none',
 843         'exposed' => TRUE,
 844         'expose' => [
 845           'operator' => 'description_op',
 846           'label' => 'description',
 847           'identifier' => 'description',
 848         ],
 849         'is_grouped' => TRUE,
 850         'group_info' => [
 851           'label' => 'description',
 852           'identifier' => 'description',
 853           'default_group' => 'All',
 854           'group_items' => [
 855             1 => [
 856               'title' => 'Contains the word: Actor',
 857               'operator' => 'word',
 858               'value' => 'actor',
 859             ],
 860             2 => [
 861               'title' => 'Starts with George',
 862               'operator' => 'starts',
 863               'value' => 'George',
 864             ],
 865             3 => [
 866               'title' => 'Not Starts with: George',
 867               'operator' => 'not_starts',
 868               'value' => 'George',
 869             ],
 870             4 => [
 871               'title' => 'Ends with: Beatles',
 872               'operator' => 'ends',
 873               'value' => 'Beatles.',
 874             ],
 875             5 => [
 876               'title' => 'Not Ends with: Beatles',
 877               'operator' => 'not_ends',
 878               'value' => 'Beatles.',
 879             ],
 880             6 => [
 881               'title' => 'Does not contain: Beatles',
 882               'operator' => 'not',
 883               'value' => 'Beatles.',
 884             ],
 885             7 => [
 886               'title' => 'Empty description',
 887               'operator' => 'empty',
 888               'value' => '',
 889             ],
 890           ],
 891         ],
 892       ],
 893     ];
 894     return $filters;
 895   }
 896
 897 }