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   protected function schemaDefinition() {
  43     $schema = parent::schemaDefinition();
  44     $schema['views_test_data']['fields']['description'] = [
  45       'description' => "A person's description",
  46       'type' => 'text',
  47       'not null' => FALSE,
  48       'size' => 'big',
  49     ];
  50
  51     return $schema;
  52   }
  53
  54   /**
  55    * An extended test dataset.
  56    */
  57   protected function dataSet() {
  58     $dataset = parent::dataSet();
  59     $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.';
  60     $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.';
  61     $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.';
  62     $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]';
  63     $dataset[4]['description'] = NULL;
  64
  65     return $dataset;
  66   }
  67
  68   /**
  69    * Build and return a Page view of the views_test_data table.
  70    *
  71    * @return view
  72    */
  73   protected function getBasicPageView() {
  74     $view = Views::getView('test_view');
  75
  76     // In order to test exposed filters, we have to disable
  77     // the exposed forms cache.
  78     \Drupal::service('views.exposed_form_cache')->reset();
  79
  80     $view->newDisplay('page', 'Page', 'page_1');
  81     return $view;
  82   }
  83
  84   public function testFilterStringEqual() {
  85     $view = Views::getView('test_view');
  86     $view->setDisplay();
  87
  88     // Change the filtering
  89     $view->displayHandlers->get('default')->overrideOption('filters', [
  90       'name' => [
  91         'id' => 'name',
  92         'table' => 'views_test_data',
  93         'field' => 'name',
  94         'relationship' => 'none',
  95         'operator' => '=',
  96         'value' => 'Ringo',
  97       ],
  98     ]);
  99
 100     $this->executeView($view);
 101     $resultset = [
 102       [
 103         'name' => 'Ringo',
 104       ],
 105     ];
 106     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 107   }
 108
 109   public function testFilterStringGroupedExposedEqual() {
 110     $filters = $this->getGroupedExposedFilters();
 111     $view = $this->getBasicPageView();
 112
 113     // Filter: Name, Operator: =, Value: Ringo
 114     $filters['name']['group_info']['default_group'] = 1;
 115     $view->setDisplay('page_1');
 116     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 117     $view->save();
 118     $this->container->get('router.builder')->rebuild();
 119
 120     $this->executeView($view);
 121
 122     $resultset = [
 123       [
 124         'name' => 'Ringo',
 125       ],
 126     ];
 127
 128     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 129   }
 130
 131   public function testFilterStringNotEqual() {
 132     $view = Views::getView('test_view');
 133     $view->setDisplay();
 134
 135     // Change the filtering
 136     $view->displayHandlers->get('default')->overrideOption('filters', [
 137       'name' => [
 138         'id' => 'name',
 139         'table' => 'views_test_data',
 140         'field' => 'name',
 141         'relationship' => 'none',
 142         'operator' => '!=',
 143         'value' => 'Ringo',
 144       ],
 145     ]);
 146
 147     $this->executeView($view);
 148     $resultset = [
 149       [
 150         'name' => 'John',
 151       ],
 152       [
 153         'name' => 'George',
 154       ],
 155       [
 156         'name' => 'Paul',
 157       ],
 158       [
 159         'name' => 'Meredith',
 160       ],
 161     ];
 162     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 163   }
 164
 165   public function testFilterStringGroupedExposedNotEqual() {
 166     $filters = $this->getGroupedExposedFilters();
 167     $view = $this->getBasicPageView();
 168
 169     // Filter: Name, Operator: !=, Value: Ringo
 170     $filters['name']['group_info']['default_group'] = '2';
 171
 172     $view->setDisplay('page_1');
 173     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 174     $view->save();
 175     $this->container->get('router.builder')->rebuild();
 176
 177     $this->executeView($view);
 178
 179     $resultset = [
 180       [
 181         'name' => 'John',
 182       ],
 183       [
 184         'name' => 'George',
 185       ],
 186       [
 187         'name' => 'Paul',
 188       ],
 189       [
 190         'name' => 'Meredith',
 191       ],
 192     ];
 193
 194     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 195   }
 196
 197   public function testFilterStringContains() {
 198     $view = Views::getView('test_view');
 199     $view->setDisplay();
 200
 201     // Change the filtering
 202     $view->displayHandlers->get('default')->overrideOption('filters', [
 203       'name' => [
 204         'id' => 'name',
 205         'table' => 'views_test_data',
 206         'field' => 'name',
 207         'relationship' => 'none',
 208         'operator' => 'contains',
 209         'value' => 'ing',
 210       ],
 211     ]);
 212
 213     $this->executeView($view);
 214     $resultset = [
 215       [
 216         'name' => 'Ringo',
 217       ],
 218     ];
 219     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 220   }
 221
 222
 223   public function testFilterStringGroupedExposedContains() {
 224     $filters = $this->getGroupedExposedFilters();
 225     $view = $this->getBasicPageView();
 226
 227     // Filter: Name, Operator: contains, Value: ing
 228     $filters['name']['group_info']['default_group'] = '3';
 229     $view->setDisplay('page_1');
 230     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 231     $view->save();
 232     $this->container->get('router.builder')->rebuild();
 233
 234     $this->executeView($view);
 235
 236     $resultset = [
 237       [
 238         'name' => 'Ringo',
 239       ],
 240     ];
 241
 242     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 243   }
 244
 245
 246   public function testFilterStringWord() {
 247     $view = Views::getView('test_view');
 248     $view->setDisplay();
 249
 250     // Change the filtering
 251     $view->displayHandlers->get('default')->overrideOption('filters', [
 252       'description' => [
 253         'id' => 'description',
 254         'table' => 'views_test_data',
 255         'field' => 'description',
 256         'relationship' => 'none',
 257         'operator' => 'word',
 258         'value' => 'actor',
 259       ],
 260     ]);
 261
 262     $this->executeView($view);
 263     $resultset = [
 264       [
 265         'name' => 'George',
 266       ],
 267       [
 268         'name' => 'Ringo',
 269       ],
 270     ];
 271     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 272     $view->destroy();
 273
 274     $view = Views::getView('test_view');
 275     $view->setDisplay();
 276
 277     // Change the filtering
 278     $view->displayHandlers->get('default')->overrideOption('filters', [
 279       'description' => [
 280         'id' => 'description',
 281         'table' => 'views_test_data',
 282         'field' => 'description',
 283         'relationship' => 'none',
 284         'operator' => 'allwords',
 285         'value' => 'Richard Starkey',
 286       ],
 287     ]);
 288
 289     $this->executeView($view);
 290     $resultset = [
 291       [
 292         'name' => 'Ringo',
 293       ],
 294     ];
 295     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 296     $view->destroy();
 297
 298     $view = Views::getView('test_view');
 299     $view->setDisplay();
 300
 301     // Change the filtering to a sting containing only illegal characters.
 302     $view->displayHandlers->get('default')->overrideOption('filters', [
 303       'description' => [
 304         'id' => 'description',
 305         'table' => 'views_test_data',
 306         'field' => 'description',
 307         'relationship' => 'none',
 308         'operator' => 'allwords',
 309         'value' => ':-)',
 310       ],
 311     ]);
 312
 313     $this->executeView($view);
 314     $resultset = [
 315       [
 316         'name' => 'Ringo',
 317       ],
 318       [
 319         'name' => 'John',
 320       ],
 321       [
 322         'name' => 'George',
 323       ],
 324       [
 325         'name' => 'Paul',
 326       ],
 327       [
 328         'name' => 'Meredith',
 329       ],
 330     ];
 331     $this->assertIdenticalResultset($view, $resultset);
 332   }
 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
 619   public function testFilterStringGroupedExposedNot() {
 620     $filters = $this->getGroupedExposedFilters();
 621     $view = $this->getBasicPageView();
 622
 623     // Filter: Description, Operator: not (does not contains), Value: Beatles
 624     $filters['description']['group_info']['default_group'] = 6;
 625     $view->setDisplay('page_1');
 626     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 627     $view->save();
 628     $this->container->get('router.builder')->rebuild();
 629
 630     $this->executeView($view);
 631
 632     $resultset = [
 633       [
 634         'name' => 'John',
 635       ],
 636       [
 637         'name' => 'Paul',
 638       ],
 639       // There is no Meredith returned because his description is empty
 640     ];
 641     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 642
 643   }
 644
 645   public function testFilterStringShorter() {
 646     $view = Views::getView('test_view');
 647     $view->setDisplay();
 648
 649     // Change the filtering
 650     $view->displayHandlers->get('default')->overrideOption('filters', [
 651       'name' => [
 652         'id' => 'name',
 653         'table' => 'views_test_data',
 654         'field' => 'name',
 655         'relationship' => 'none',
 656         'operator' => 'shorterthan',
 657         'value' => 5,
 658       ],
 659     ]);
 660
 661     $this->executeView($view);
 662     $resultset = [
 663       [
 664         'name' => 'John',
 665       ],
 666       [
 667         'name' => 'Paul',
 668       ],
 669     ];
 670     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 671   }
 672
 673   public function testFilterStringGroupedExposedShorter() {
 674     $filters = $this->getGroupedExposedFilters();
 675     $view = $this->getBasicPageView();
 676
 677     // Filter: Name, Operator: shorterthan, Value: 5
 678     $filters['name']['group_info']['default_group'] = 4;
 679     $view->setDisplay('page_1');
 680     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 681     $view->save();
 682     $this->container->get('router.builder')->rebuild();
 683
 684     $this->executeView($view);
 685     $resultset = [
 686       [
 687         'name' => 'John',
 688       ],
 689       [
 690         'name' => 'Paul',
 691       ],
 692     ];
 693     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 694   }
 695
 696   public function testFilterStringLonger() {
 697     $view = Views::getView('test_view');
 698     $view->setDisplay();
 699
 700     // Change the filtering
 701     $view->displayHandlers->get('default')->overrideOption('filters', [
 702       'name' => [
 703         'id' => 'name',
 704         'table' => 'views_test_data',
 705         'field' => 'name',
 706         'relationship' => 'none',
 707         'operator' => 'longerthan',
 708         'value' => 7,
 709       ],
 710     ]);
 711
 712     $this->executeView($view);
 713     $resultset = [
 714       [
 715         'name' => 'Meredith',
 716       ],
 717     ];
 718     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 719   }
 720
 721   public function testFilterStringGroupedExposedLonger() {
 722     $filters = $this->getGroupedExposedFilters();
 723     $view = $this->getBasicPageView();
 724
 725     // Filter: Name, Operator: longerthan, Value: 4
 726     $filters['name']['group_info']['default_group'] = 5;
 727     $view->setDisplay('page_1');
 728     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 729     $view->save();
 730     $this->container->get('router.builder')->rebuild();
 731
 732     $this->executeView($view);
 733     $resultset = [
 734       [
 735         'name' => 'Meredith',
 736       ],
 737     ];
 738     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 739   }
 740
 741
 742   public function testFilterStringEmpty() {
 743     $view = Views::getView('test_view');
 744     $view->setDisplay();
 745
 746     // Change the filtering
 747     $view->displayHandlers->get('default')->overrideOption('filters', [
 748       'description' => [
 749         'id' => 'description',
 750         'table' => 'views_test_data',
 751         'field' => 'description',
 752         'relationship' => 'none',
 753         'operator' => 'empty',
 754       ],
 755     ]);
 756
 757     $this->executeView($view);
 758     $resultset = [
 759       [
 760         'name' => 'Meredith',
 761       ],
 762     ];
 763     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 764   }
 765
 766   public function testFilterStringGroupedExposedEmpty() {
 767     $filters = $this->getGroupedExposedFilters();
 768     $view = $this->getBasicPageView();
 769
 770     // Filter: Description, Operator: empty, Value:
 771     $filters['description']['group_info']['default_group'] = 7;
 772     $view->setDisplay('page_1');
 773     $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
 774     $view->save();
 775     $this->container->get('router.builder')->rebuild();
 776
 777     $this->executeView($view);
 778     $resultset = [
 779       [
 780         'name' => 'Meredith',
 781       ],
 782     ];
 783     $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
 784   }
 785
 786   protected function getGroupedExposedFilters() {
 787     $filters = [
 788       'name' => [
 789         'id' => 'name',
 790         'plugin_id' => 'string',
 791         'table' => 'views_test_data',
 792         'field' => 'name',
 793         'relationship' => 'none',
 794         'exposed' => TRUE,
 795         'expose' => [
 796           'operator' => 'name_op',
 797           'label' => 'name',
 798           'identifier' => 'name',
 799         ],
 800         'is_grouped' => TRUE,
 801         'group_info' => [
 802           'label' => 'name',
 803           'identifier' => 'name',
 804           'default_group' => 'All',
 805           'group_items' => [
 806             1 => [
 807               'title' => 'Is Ringo',
 808               'operator' => '=',
 809               'value' => 'Ringo',
 810             ],
 811             2 => [
 812               'title' => 'Is not Ringo',
 813               'operator' => '!=',
 814               'value' => 'Ringo',
 815             ],
 816             3 => [
 817               'title' => 'Contains ing',
 818               'operator' => 'contains',
 819               'value' => 'ing',
 820             ],
 821             4 => [
 822               'title' => 'Shorter than 5 letters',
 823               'operator' => 'shorterthan',
 824               'value' => 5,
 825             ],
 826             5 => [
 827               'title' => 'Longer than 7 letters',
 828               'operator' => 'longerthan',
 829               'value' => 7,
 830             ],
 831           ],
 832         ],
 833       ],
 834       'description' => [
 835         'id' => 'description',
 836         'plugin_id' => 'string',
 837         'table' => 'views_test_data',
 838         'field' => 'description',
 839         'relationship' => 'none',
 840         'exposed' => TRUE,
 841         'expose' => [
 842           'operator' => 'description_op',
 843           'label' => 'description',
 844           'identifier' => 'description',
 845         ],
 846         'is_grouped' => TRUE,
 847         'group_info' => [
 848           'label' => 'description',
 849           'identifier' => 'description',
 850           'default_group' => 'All',
 851           'group_items' => [
 852             1 => [
 853               'title' => 'Contains the word: Actor',
 854               'operator' => 'word',
 855               'value' => 'actor',
 856             ],
 857             2 => [
 858               'title' => 'Starts with George',
 859               'operator' => 'starts',
 860               'value' => 'George',
 861             ],
 862             3 => [
 863               'title' => 'Not Starts with: George',
 864               'operator' => 'not_starts',
 865               'value' => 'George',
 866             ],
 867             4 => [
 868               'title' => 'Ends with: Beatles',
 869               'operator' => 'ends',
 870               'value' => 'Beatles.',
 871             ],
 872             5 => [
 873               'title' => 'Not Ends with: Beatles',
 874               'operator' => 'not_ends',
 875               'value' => 'Beatles.',
 876             ],
 877             6 => [
 878               'title' => 'Does not contain: Beatles',
 879               'operator' => 'not',
 880               'value' => 'Beatles.',
 881             ],
 882             7 => [
 883               'title' => 'Empty description',
 884               'operator' => 'empty',
 885               'value' => '',
 886             ],
 887           ],
 888         ],
 889       ],
 890     ];
 891     return $filters;
 892   }
 893
 894 }