1 <?php

     2 

     3 /**

     4  * @file

     5  * Tests for search.module.

     6  */

     7 

     8 // The search index can contain different types of content. Typically the type is 'node'.

     9 // Here we test with _test_ and _test2_ as the type.

    10 define('SEARCH_TYPE', '_test_');

    11 define('SEARCH_TYPE_2', '_test2_');

    12 define('SEARCH_TYPE_JPN', '_test3_');

    13 

    14 /**

    15  * Indexes content and queries it.

    16  */

    17 class SearchMatchTestCase extends DrupalWebTestCase {

    18   public static function getInfo() {

    19     return array(

    20       'name' => 'Search engine queries',

    21       'description' => 'Indexes content and queries it.',

    22       'group' => 'Search',

    23     );

    24   }

    25 

    26   /**

    27    * Implementation setUp().

    28    */

    29   function setUp() {

    30     parent::setUp('search');

    31   }

    32 

    33   /**

    34    * Test search indexing.

    35    */

    36   function testMatching() {

    37     $this->_setup();

    38     $this->_testQueries();

    39   }

    40 

    41   /**

    42    * Set up a small index of items to test against.

    43    */

    44   function _setup() {

    45     variable_set('minimum_word_size', 3);

    46 

    47     for ($i = 1; $i <= 7; ++$i) {

    48       search_index($i, SEARCH_TYPE, $this->getText($i));

    49     }

    50     for ($i = 1; $i <= 5; ++$i) {

    51       search_index($i + 7, SEARCH_TYPE_2, $this->getText2($i));

    52     }

    53     // No getText builder function for Japanese text; just a simple array.

    54     foreach (array(

    55       13 => '以呂波耳・ほへとち。リヌルヲ。',

    56       14 => 'ドルーパルが大好きよ！',

    57       15 => 'コーヒーとケーキ',

    58     ) as $i => $jpn) {

    59       search_index($i, SEARCH_TYPE_JPN, $jpn);

    60     }

    61     search_update_totals();

    62   }

    63 

    64   /**

    65    * _test_: Helper method for generating snippets of content.

    66    *

    67    * Generated items to test against:

    68    *   1  ipsum

    69    *   2  dolore sit

    70    *   3  sit am ut

    71    *   4  am ut enim am

    72    *   5  ut enim am minim veniam

    73    *   6  enim am minim veniam es cillum

    74    *   7  am minim veniam es cillum dolore eu

    75    */

    76   function getText($n) {

    77     $words = explode(' ', "Ipsum dolore sit am. Ut enim am minim veniam. Es cillum dolore eu.");

    78     return implode(' ', array_slice($words, $n - 1, $n));

    79   }

    80 

    81   /**

    82    * _test2_: Helper method for generating snippets of content.

    83    *

    84    * Generated items to test against:

    85    *   8  dear

    86    *   9  king philip

    87    *   10 philip came over

    88    *   11 came over from germany

    89    *   12 over from germany swimming

    90    */

    91   function getText2($n) {

    92     $words = explode(' ', "Dear King Philip came over from Germany swimming.");

    93     return implode(' ', array_slice($words, $n - 1, $n));

    94   }

    95 

    96   /**

    97    * Run predefine queries looking for indexed terms.

    98    */

    99   function _testQueries() {

   100     /*

   101       Note: OR queries that include short words in OR groups are only accepted

   102       if the ORed terms are ANDed with at least one long word in the rest of the query.

   103 

   104       e.g. enim dolore OR ut = enim (dolore OR ut) = (enim dolor) OR (enim ut) -> good

   105       e.g. dolore OR ut = (dolore) OR (ut) -> bad

   106 

   107       This is a design limitation to avoid full table scans.

   108     */

   109     $queries = array(

   110       // Simple AND queries.

   111       'ipsum' => array(1),

   112       'enim' => array(4, 5, 6),

   113       'xxxxx' => array(),

   114       'enim minim' => array(5, 6),

   115       'enim xxxxx' => array(),

   116       'dolore eu' => array(7),

   117       'dolore xx' => array(),

   118       'ut minim' => array(5),

   119       'xx minim' => array(),

   120       'enim veniam am minim ut' => array(5),

   121       // Simple OR queries.

   122       'dolore OR ipsum' => array(1, 2, 7),

   123       'dolore OR xxxxx' => array(2, 7),

   124       'dolore OR ipsum OR enim' => array(1, 2, 4, 5, 6, 7),

   125       'ipsum OR dolore sit OR cillum' => array(2, 7),

   126       'minim dolore OR ipsum' => array(7),

   127       'dolore OR ipsum veniam' => array(7),

   128       'minim dolore OR ipsum OR enim' => array(5, 6, 7),

   129       'dolore xx OR yy' => array(),

   130       'xxxxx dolore OR ipsum' => array(),

   131       // Negative queries.

   132       'dolore -sit' => array(7),

   133       'dolore -eu' => array(2),

   134       'dolore -xxxxx' => array(2, 7),

   135       'dolore -xx' => array(2, 7),

   136       // Phrase queries.

   137       '"dolore sit"' => array(2),

   138       '"sit dolore"' => array(),

   139       '"am minim veniam es"' => array(6, 7),

   140       '"minim am veniam es"' => array(),

   141       // Mixed queries.

   142       '"am minim veniam es" OR dolore' => array(2, 6, 7),

   143       '"minim am veniam es" OR "dolore sit"' => array(2),

   144       '"minim am veniam es" OR "sit dolore"' => array(),

   145       '"am minim veniam es" -eu' => array(6),

   146       '"am minim veniam" -"cillum dolore"' => array(5, 6),

   147       '"am minim veniam" -"dolore cillum"' => array(5, 6, 7),

   148       'xxxxx "minim am veniam es" OR dolore' => array(),

   149       'xx "minim am veniam es" OR dolore' => array()

   150     );

   151     foreach ($queries as $query => $results) {

   152       $result = db_select('search_index', 'i')

   153         ->extend('SearchQuery')

   154         ->searchExpression($query, SEARCH_TYPE)

   155         ->execute();

   156 

   157       $set = $result ? $result->fetchAll() : array();

   158       $this->_testQueryMatching($query, $set, $results);

   159       $this->_testQueryScores($query, $set, $results);

   160     }

   161 

   162     // These queries are run against the second index type, SEARCH_TYPE_2.

   163     $queries = array(

   164       // Simple AND queries.

   165       'ipsum' => array(),

   166       'enim' => array(),

   167       'enim minim' => array(),

   168       'dear' => array(8),

   169       'germany' => array(11, 12),

   170     );

   171     foreach ($queries as $query => $results) {

   172       $result = db_select('search_index', 'i')

   173         ->extend('SearchQuery')

   174         ->searchExpression($query, SEARCH_TYPE_2)

   175         ->execute();

   176 

   177       $set = $result ? $result->fetchAll() : array();

   178       $this->_testQueryMatching($query, $set, $results);

   179       $this->_testQueryScores($query, $set, $results);

   180     }

   181 

   182     // These queries are run against the third index type, SEARCH_TYPE_JPN.

   183     $queries = array(

   184       // Simple AND queries.

   185       '呂波耳' => array(13),

   186       '以呂波耳' => array(13),

   187       'ほへと　ヌルヲ' => array(13),

   188       'とちリ' => array(),

   189       'ドルーパル' => array(14),

   190       'パルが大' => array(14),

   191       'コーヒー' => array(15),

   192       'ヒーキ' => array(),

   193     );

   194     foreach ($queries as $query => $results) {

   195       $result = db_select('search_index', 'i')

   196         ->extend('SearchQuery')

   197         ->searchExpression($query, SEARCH_TYPE_JPN)

   198         ->execute();

   199 

   200       $set = $result ? $result->fetchAll() : array();

   201       $this->_testQueryMatching($query, $set, $results);

   202       $this->_testQueryScores($query, $set, $results);

   203     }

   204   }

   205 

   206   /**

   207    * Test the matching abilities of the engine.

   208    *

   209    * Verify if a query produces the correct results.

   210    */

   211   function _testQueryMatching($query, $set, $results) {

   212     // Get result IDs.

   213     $found = array();

   214     foreach ($set as $item) {

   215       $found[] = $item->sid;

   216     }

   217 

   218     // Compare $results and $found.

   219     sort($found);

   220     sort($results);

   221     $this->assertEqual($found, $results, "Query matching '$query'");

   222   }

   223 

   224   /**

   225    * Test the scoring abilities of the engine.

   226    *

   227    * Verify if a query produces normalized, monotonous scores.

   228    */

   229   function _testQueryScores($query, $set, $results) {

   230     // Get result scores.

   231     $scores = array();

   232     foreach ($set as $item) {

   233       $scores[] = $item->calculated_score;

   234     }

   235 

   236     // Check order.

   237     $sorted = $scores;

   238     sort($sorted);

   239     $this->assertEqual($scores, array_reverse($sorted), "Query order '$query'");

   240 

   241     // Check range.

   242     $this->assertEqual(!count($scores) || (min($scores) > 0.0 && max($scores) <= 1.0001), TRUE, "Query scoring '$query'");

   243   }

   244 }

   245 

   246 /**

   247  * Tests the bike shed text on no results page, and text on the search page.

   248  */

   249 class SearchPageText extends DrupalWebTestCase {

   250   protected $searching_user;

   251 

   252   public static function getInfo() {

   253     return array(

   254       'name' => 'Search page text',

   255       'description' => 'Tests the bike shed text on the no results page, and various other text on search pages.',

   256       'group' => 'Search'

   257     );

   258   }

   259 

   260   function setUp() {

   261     parent::setUp('search');

   262 

   263     // Create user.

   264     $this->searching_user = $this->drupalCreateUser(array('search content', 'access user profiles'));

   265   }

   266 

   267   /**

   268    * Tests the failed search text, and various other text on the search page.

   269    */

   270   function testSearchText() {

   271     $this->drupalLogin($this->searching_user);

   272     $this->drupalGet('search/node');

   273     $this->assertText(t('Enter your keywords'));

   274     $this->assertText(t('Search'));

   275     $title = t('Search') . ' | Drupal';

   276     $this->assertTitle($title, 'Search page title is correct');

   277 

   278     $edit = array();

   279     $edit['keys'] = 'bike shed ' . $this->randomName();

   280     $this->drupalPost('search/node', $edit, t('Search'));

   281     $this->assertText(t('Consider loosening your query with OR. bike OR shed will often show more results than bike shed.'), 'Help text is displayed when search returns no results.');

   282     $this->assertText(t('Search'));

   283     $this->assertTitle($title, 'Search page title is correct');

   284 

   285     $edit['keys'] = $this->searching_user->name;

   286     $this->drupalPost('search/user', $edit, t('Search'));

   287     $this->assertText(t('Search'));

   288     $this->assertTitle($title, 'Search page title is correct');

   289 

   290     // Test that search keywords containing slashes are correctly loaded

   291     // from the path and displayed in the search form.

   292     $arg = $this->randomName() . '/' . $this->randomName();

   293     $this->drupalGet('search/node/' . $arg);

   294     $input = $this->xpath("//input[@id='edit-keys' and @value='{$arg}']");

   295     $this->assertFalse(empty($input), 'Search keys with a / are correctly set as the default value in the search box.');

   296 

   297     // Test a search input exceeding the limit of AND/OR combinations to test

   298     // the Denial-of-Service protection.

   299     $limit = variable_get('search_and_or_limit', 7);

   300     $keys = array();

   301     for ($i = 0; $i < $limit + 1; $i++) {

   302       $keys[] = $this->randomName(3);

   303       if ($i % 2 == 0) {

   304         $keys[] = 'OR';

   305       }

   306     }

   307     $edit['keys'] = implode(' ', $keys);

   308     $this->drupalPost('search/node', $edit, t('Search'));

   309     $this->assertRaw(t('Your search used too many AND/OR expressions. Only the first @count terms were included in this search.', array('@count' => $limit)));

   310   }

   311 }

   312 

   313 /**

   314  * Indexes content and tests the advanced search form.

   315  */

   316 class SearchAdvancedSearchForm extends DrupalWebTestCase {

   317   protected $node;

   318 

   319   public static function getInfo() {

   320     return array(

   321       'name' => 'Advanced search form',

   322       'description' => 'Indexes content and tests the advanced search form.',

   323       'group' => 'Search',

   324     );

   325   }

   326 

   327   function setUp() {

   328     parent::setUp('search');

   329     // Create and login user.

   330     $test_user = $this->drupalCreateUser(array('access content', 'search content', 'use advanced search', 'administer nodes'));

   331     $this->drupalLogin($test_user);

   332 

   333     // Create initial node.

   334     $node = $this->drupalCreateNode();

   335     $this->node = $this->drupalCreateNode();

   336 

   337     // First update the index. This does the initial processing.

   338     node_update_index();

   339 

   340     // Then, run the shutdown function. Testing is a unique case where indexing

   341     // and searching has to happen in the same request, so running the shutdown

   342     // function manually is needed to finish the indexing process.

   343     search_update_totals();

   344   }

   345 

   346   /**

   347    * Test using the search form with GET and POST queries.

   348    * Test using the advanced search form to limit search to nodes of type "Basic page".

   349    */

   350   function testNodeType() {

   351     $this->assertTrue($this->node->type == 'page', 'Node type is Basic page.');

   352 

   353     // Assert that the dummy title doesn't equal the real title.

   354     $dummy_title = 'Lorem ipsum';

   355     $this->assertNotEqual($dummy_title, $this->node->title, "Dummy title doesn't equal node title");

   356 

   357     // Search for the dummy title with a GET query.

   358     $this->drupalGet('search/node/' . $dummy_title);

   359     $this->assertNoText($this->node->title, 'Basic page node is not found with dummy title.');

   360 

   361     // Search for the title of the node with a GET query.

   362     $this->drupalGet('search/node/' . $this->node->title);

   363     $this->assertText($this->node->title, 'Basic page node is found with GET query.');

   364 

   365     // Search for the title of the node with a POST query.

   366     $edit = array('or' => $this->node->title);

   367     $this->drupalPost('search/node', $edit, t('Advanced search'));

   368     $this->assertText($this->node->title, 'Basic page node is found with POST query.');

   369 

   370     // Advanced search type option.

   371     $this->drupalPost('search/node', array_merge($edit, array('type[page]' => 'page')), t('Advanced search'));

   372     $this->assertText($this->node->title, 'Basic page node is found with POST query and type:page.');

   373 

   374     $this->drupalPost('search/node', array_merge($edit, array('type[article]' => 'article')), t('Advanced search'));

   375     $this->assertText('bike shed', 'Article node is not found with POST query and type:article.');

   376   }

   377 }

   378 

   379 /**

   380  * Indexes content and tests ranking factors.

   381  */

   382 class SearchRankingTestCase extends DrupalWebTestCase {

   383   public static function getInfo() {

   384     return array(

   385       'name' => 'Search engine ranking',

   386       'description' => 'Indexes content and tests ranking factors.',

   387       'group' => 'Search',

   388     );

   389   }

   390 

   391   /**

   392    * Implementation setUp().

   393    */

   394   function setUp() {

   395     parent::setUp('search', 'statistics', 'comment');

   396   }

   397 

   398   function testRankings() {

   399     // Login with sufficient privileges.

   400     $this->drupalLogin($this->drupalCreateUser(array('skip comment approval', 'create page content')));

   401 

   402     // Build a list of the rankings to test.

   403     $node_ranks = array('sticky', 'promote', 'relevance', 'recent', 'comments', 'views');

   404 

   405     // Create nodes for testing.

   406     foreach ($node_ranks as $node_rank) {

   407       $settings = array(

   408         'type' => 'page',

   409         'title' => 'Drupal rocks',

   410         'body' => array(LANGUAGE_NONE => array(array('value' => "Drupal's search rocks"))),

   411       );

   412       foreach (array(0, 1) as $num) {

   413         if ($num == 1) {

   414           switch ($node_rank) {

   415             case 'sticky':

   416             case 'promote':

   417               $settings[$node_rank] = 1;

   418               break;

   419             case 'relevance':

   420               $settings['body'][LANGUAGE_NONE][0]['value'] .= " really rocks";

   421               break;

   422             case 'recent':

   423               $settings['created'] = REQUEST_TIME + 3600;

   424               break;

   425             case 'comments':

   426               $settings['comment'] = 2;

   427               break;

   428           }

   429         }

   430         $nodes[$node_rank][$num] = $this->drupalCreateNode($settings);

   431       }

   432     }

   433 

   434     // Update the search index.

   435     module_invoke_all('update_index');

   436     search_update_totals();

   437 

   438     // Refresh variables after the treatment.

   439     $this->refreshVariables();

   440 

   441     // Add a comment to one of the nodes.

   442     $edit = array();

   443     $edit['subject'] = 'my comment title';

   444     $edit['comment_body[' . LANGUAGE_NONE . '][0][value]'] = 'some random comment';

   445     $this->drupalGet('comment/reply/' . $nodes['comments'][1]->nid);

   446     $this->drupalPost(NULL, $edit, t('Preview'));

   447     $this->drupalPost(NULL, $edit, t('Save'));

   448 

   449     // Enable counting of statistics.

   450     variable_set('statistics_count_content_views', 1);

   451 

   452     // Then View one of the nodes a bunch of times.

   453     for ($i = 0; $i < 5; $i ++) {

   454       $this->drupalGet('node/' . $nodes['views'][1]->nid);

   455     }

   456 

   457     // Test each of the possible rankings.

   458     foreach ($node_ranks as $node_rank) {

   459       // Disable all relevancy rankings except the one we are testing.

   460       foreach ($node_ranks as $var) {

   461         variable_set('node_rank_' . $var, $var == $node_rank ? 10 : 0);

   462       }

   463 

   464       // Do the search and assert the results.

   465       $set = node_search_execute('rocks');

   466       $this->assertEqual($set[0]['node']->nid, $nodes[$node_rank][1]->nid, 'Search ranking "' . $node_rank . '" order.');

   467     }

   468   }

   469 

   470   /**

   471    * Test rankings of HTML tags.

   472    */

   473   function testHTMLRankings() {

   474     // Login with sufficient privileges.

   475     $this->drupalLogin($this->drupalCreateUser(array('create page content')));

   476 

   477     // Test HTML tags with different weights.

   478     $sorted_tags = array('h1', 'h2', 'h3', 'h4', 'a', 'h5', 'h6', 'notag');

   479     $shuffled_tags = $sorted_tags;

   480 

   481     // Shuffle tags to ensure HTML tags are ranked properly.

   482     shuffle($shuffled_tags);

   483     $settings = array(

   484       'type' => 'page',

   485       'title' => 'Simple node',

   486     );

   487     foreach ($shuffled_tags as $tag) {

   488       switch ($tag) {

   489         case 'a':

   490           $settings['body'] = array(LANGUAGE_NONE => array(array('value' => l('Drupal Rocks', 'node'), 'format' => 'full_html')));

   491           break;

   492         case 'notag':

   493           $settings['body'] = array(LANGUAGE_NONE => array(array('value' => 'Drupal Rocks')));

   494           break;

   495         default:

   496           $settings['body'] = array(LANGUAGE_NONE => array(array('value' => "<$tag>Drupal Rocks</$tag>", 'format' => 'full_html')));

   497           break;

   498       }

   499       $nodes[$tag] = $this->drupalCreateNode($settings);

   500     }

   501 

   502     // Update the search index.

   503     module_invoke_all('update_index');

   504     search_update_totals();

   505 

   506     // Refresh variables after the treatment.

   507     $this->refreshVariables();

   508 

   509     // Disable all other rankings.

   510     $node_ranks = array('sticky', 'promote', 'recent', 'comments', 'views');

   511     foreach ($node_ranks as $node_rank) {

   512       variable_set('node_rank_' . $node_rank, 0);

   513     }

   514     $set = node_search_execute('rocks');

   515 

   516     // Test the ranking of each tag.

   517     foreach ($sorted_tags as $tag_rank => $tag) {

   518       // Assert the results.

   519       if ($tag == 'notag') {

   520         $this->assertEqual($set[$tag_rank]['node']->nid, $nodes[$tag]->nid, 'Search tag ranking for plain text order.');

   521       } else {

   522         $this->assertEqual($set[$tag_rank]['node']->nid, $nodes[$tag]->nid, 'Search tag ranking for "<' . $sorted_tags[$tag_rank] . '>" order.');

   523       }

   524     }

   525 

   526     // Test tags with the same weight against the sorted tags.

   527     $unsorted_tags = array('u', 'b', 'i', 'strong', 'em');

   528     foreach ($unsorted_tags as $tag) {

   529       $settings['body'] = array(LANGUAGE_NONE => array(array('value' => "<$tag>Drupal Rocks</$tag>", 'format' => 'full_html')));

   530       $node = $this->drupalCreateNode($settings);

   531 

   532       // Update the search index.

   533       module_invoke_all('update_index');

   534       search_update_totals();

   535 

   536       // Refresh variables after the treatment.

   537       $this->refreshVariables();

   538 

   539       $set = node_search_execute('rocks');

   540 

   541       // Ranking should always be second to last.

   542       $set = array_slice($set, -2, 1);

   543 

   544       // Assert the results.

   545       $this->assertEqual($set[0]['node']->nid, $node->nid, 'Search tag ranking for "<' . $tag . '>" order.');

   546 

   547       // Delete node so it doesn't show up in subsequent search results.

   548       node_delete($node->nid);

   549     }

   550   }

   551 

   552   /**

   553    * Verifies that if we combine two rankings, search still works.

   554    *

   555    * See issue http://drupal.org/node/771596

   556    */

   557   function testDoubleRankings() {

   558     // Login with sufficient privileges.

   559     $this->drupalLogin($this->drupalCreateUser(array('skip comment approval', 'create page content')));

   560 

   561     // See testRankings() above - build a node that will rank high for sticky.

   562     $settings = array(

   563       'type' => 'page',

   564       'title' => 'Drupal rocks',

   565       'body' => array(LANGUAGE_NONE => array(array('value' => "Drupal's search rocks"))),

   566       'sticky' => 1,

   567     );

   568 

   569     $node = $this->drupalCreateNode($settings);

   570 

   571     // Update the search index.

   572     module_invoke_all('update_index');

   573     search_update_totals();

   574 

   575     // Refresh variables after the treatment.

   576     $this->refreshVariables();

   577 

   578     // Set up for ranking sticky and lots of comments; make sure others are

   579     // disabled.

   580     $node_ranks = array('sticky', 'promote', 'relevance', 'recent', 'comments', 'views');

   581     foreach ($node_ranks as $var) {

   582       $value = ($var == 'sticky' || $var == 'comments') ? 10 : 0;

   583       variable_set('node_rank_' . $var, $value);

   584     }

   585 

   586     // Do the search and assert the results.

   587     $set = node_search_execute('rocks');

   588     $this->assertEqual($set[0]['node']->nid, $node->nid, 'Search double ranking order.');

   589   }

   590 }

   591 

   592 /**

   593  * Tests the rendering of the search block.

   594  */

   595 class SearchBlockTestCase extends DrupalWebTestCase {

   596   public static function getInfo() {

   597     return array(

   598       'name' => 'Block availability',

   599       'description' => 'Check if the search form block is available.',

   600       'group' => 'Search',

   601     );

   602   }

   603 

   604   function setUp() {

   605     parent::setUp('search');

   606 

   607     // Create and login user

   608     $admin_user = $this->drupalCreateUser(array('administer blocks', 'search content'));

   609     $this->drupalLogin($admin_user);

   610   }

   611 

   612   function testSearchFormBlock() {

   613     // Set block title to confirm that the interface is available.

   614     $this->drupalPost('admin/structure/block/manage/search/form/configure', array('title' => $this->randomName(8)), t('Save block'));

   615     $this->assertText(t('The block configuration has been saved.'), 'Block configuration set.');

   616 

   617     // Set the block to a region to confirm block is available.

   618     $edit = array();

   619     $edit['blocks[search_form][region]'] = 'footer';

   620     $this->drupalPost('admin/structure/block', $edit, t('Save blocks'));

   621     $this->assertText(t('The block settings have been updated.'), 'Block successfully move to footer region.');

   622   }

   623 

   624   /**

   625    * Test that the search block form works correctly.

   626    */

   627   function testBlock() {

   628     // Enable the block, and place it in the 'content' region so that it isn't

   629     // hidden on 404 pages.

   630     $edit = array('blocks[search_form][region]' => 'content');

   631     $this->drupalPost('admin/structure/block', $edit, t('Save blocks'));

   632 

   633     // Test a normal search via the block form, from the front page.

   634     $terms = array('search_block_form' => 'test');

   635     $this->drupalPost('node', $terms, t('Search'));

   636     $this->assertText('Your search yielded no results');

   637 

   638     // Test a search from the block on a 404 page.

   639     $this->drupalGet('foo');

   640     $this->assertResponse(404);

   641     $this->drupalPost(NULL, $terms, t('Search'));

   642     $this->assertResponse(200);

   643     $this->assertText('Your search yielded no results');

   644 

   645     // Test a search from the block when it doesn't appear on the search page.

   646     $edit = array('pages' => 'search');

   647     $this->drupalPost('admin/structure/block/manage/search/form/configure', $edit, t('Save block'));

   648     $this->drupalPost('node', $terms, t('Search'));

   649     $this->assertText('Your search yielded no results');

   650 

   651     // Confirm that the user is redirected to the search page.

   652     $this->assertEqual(

   653       $this->getUrl(),

   654       url('search/node/' . $terms['search_block_form'], array('absolute' => TRUE)),

   655       'Redirected to correct url.'

   656     );

   657 

   658     // Test an empty search via the block form, from the front page.

   659     $terms = array('search_block_form' => '');

   660     $this->drupalPost('node', $terms, t('Search'));

   661     $this->assertText('Please enter some keywords');

   662 

   663     // Confirm that the user is redirected to the search page, when form is submitted empty.

   664     $this->assertEqual(

   665       $this->getUrl(),

   666       url('search/node/', array('absolute' => TRUE)),

   667       'Redirected to correct url.'

   668     );

   669 

   670     // Test that after entering a too-short keyword in the form, you can then

   671     // search again with a longer keyword. First test using the block form.

   672     $terms = array('search_block_form' => 'a');

   673     $this->drupalPost('node', $terms, t('Search'));

   674     $this->assertText('You must include at least one positive keyword with 3 characters or more');

   675     $terms = array('search_block_form' => 'foo');

   676     $this->drupalPost(NULL, $terms, t('Search'));

   677     $this->assertNoText('You must include at least one positive keyword with 3 characters or more');

   678     $this->assertText('Your search yielded no results');

   679 

   680     // Same test again, using the search page form for the second search this time.

   681     $terms = array('search_block_form' => 'a');

   682     $this->drupalPost('node', $terms, t('Search'));

   683     $terms = array('keys' => 'foo');

   684     $this->drupalPost(NULL, $terms, t('Search'));

   685     $this->assertNoText('You must include at least one positive keyword with 3 characters or more');

   686     $this->assertText('Your search yielded no results');

   687   }

   688 }

   689 

   690 /**

   691  * Tests that searching for a phrase gets the correct page count.

   692  */

   693 class SearchExactTestCase extends DrupalWebTestCase {

   694   public static function getInfo() {

   695     return array(

   696       'name' => 'Search engine phrase queries',

   697       'description' => 'Tests that searching for a phrase gets the correct page count.',

   698       'group' => 'Search',

   699     );

   700   }

   701 

   702   function setUp() {

   703     parent::setUp('search');

   704   }

   705 

   706   /**

   707    * Tests that the correct number of pager links are found for both keywords and phrases.

   708    */

   709   function testExactQuery() {

   710     // Login with sufficient privileges.

   711     $this->drupalLogin($this->drupalCreateUser(array('create page content', 'search content')));

   712 

   713     $settings = array(

   714       'type' => 'page',

   715       'title' => 'Simple Node',

   716     );

   717     // Create nodes with exact phrase.

   718     for ($i = 0; $i <= 17; $i++) {

   719       $settings['body'] = array(LANGUAGE_NONE => array(array('value' => 'love pizza')));

   720       $this->drupalCreateNode($settings);

   721     }

   722     // Create nodes containing keywords.

   723     for ($i = 0; $i <= 17; $i++) {

   724       $settings['body'] = array(LANGUAGE_NONE => array(array('value' => 'love cheesy pizza')));

   725       $this->drupalCreateNode($settings);

   726     }

   727 

   728     // Update the search index.

   729     module_invoke_all('update_index');

   730     search_update_totals();

   731 

   732     // Refresh variables after the treatment.

   733     $this->refreshVariables();

   734 

   735     // Test that the correct number of pager links are found for keyword search.

   736     $edit = array('keys' => 'love pizza');

   737     $this->drupalPost('search/node', $edit, t('Search'));

   738     $this->assertLinkByHref('page=1', 0, '2nd page link is found for keyword search.');

   739     $this->assertLinkByHref('page=2', 0, '3rd page link is found for keyword search.');

   740     $this->assertLinkByHref('page=3', 0, '4th page link is found for keyword search.');

   741     $this->assertNoLinkByHref('page=4', '5th page link is not found for keyword search.');

   742 

   743     // Test that the correct number of pager links are found for exact phrase search.

   744     $edit = array('keys' => '"love pizza"');

   745     $this->drupalPost('search/node', $edit, t('Search'));

   746     $this->assertLinkByHref('page=1', 0, '2nd page link is found for exact phrase search.');

   747     $this->assertNoLinkByHref('page=2', '3rd page link is not found for exact phrase search.');

   748   }

   749 }

   750 

   751 /**

   752  * Test integration searching comments.

   753  */

   754 class SearchCommentTestCase extends DrupalWebTestCase {

   755   protected $admin_user;

   756 

   757   public static function getInfo() {

   758     return array(

   759       'name' => 'Comment Search tests',

   760       'description' => 'Test integration searching comments.',

   761       'group' => 'Search',

   762     );

   763   }

   764 

   765   function setUp() {

   766     parent::setUp('comment', 'search');

   767 

   768     // Create and log in an administrative user having access to the Full HTML

   769     // text format.

   770     $full_html_format = filter_format_load('full_html');

   771     $permissions = array(

   772       'administer filters',

   773       filter_permission_name($full_html_format),

   774       'administer permissions',

   775       'create page content',

   776       'skip comment approval',

   777       'access comments',

   778     );

   779     $this->admin_user = $this->drupalCreateUser($permissions);

   780     $this->drupalLogin($this->admin_user);

   781   }

   782 

   783   /**

   784    * Verify that comments are rendered using proper format in search results.

   785    */

   786   function testSearchResultsComment() {

   787     $comment_body = 'Test comment body';

   788 

   789     variable_set('comment_preview_article', DRUPAL_OPTIONAL);

   790     // Enable check_plain() for 'Filtered HTML' text format.

   791     $filtered_html_format_id = 'filtered_html';

   792     $edit = array(

   793       'filters[filter_html_escape][status]' => TRUE,

   794     );

   795     $this->drupalPost('admin/config/content/formats/' . $filtered_html_format_id, $edit, t('Save configuration'));

   796     // Allow anonymous users to search content.

   797     $edit = array(

   798       DRUPAL_ANONYMOUS_RID . '[search content]' => 1,

   799       DRUPAL_ANONYMOUS_RID . '[access comments]' => 1,

   800       DRUPAL_ANONYMOUS_RID . '[post comments]' => 1,

   801     );

   802     $this->drupalPost('admin/people/permissions', $edit, t('Save permissions'));

   803 

   804     // Create a node.

   805     $node = $this->drupalCreateNode(array('type' => 'article'));

   806     // Post a comment using 'Full HTML' text format.

   807     $edit_comment = array();

   808     $edit_comment['subject'] = 'Test comment subject';

   809     $edit_comment['comment_body[' . LANGUAGE_NONE . '][0][value]'] = '<h1>' . $comment_body . '</h1>';

   810     $full_html_format_id = 'full_html';

   811     $edit_comment['comment_body[' . LANGUAGE_NONE . '][0][format]'] = $full_html_format_id;

   812     $this->drupalPost('comment/reply/' . $node->nid, $edit_comment, t('Save'));

   813 

   814     // Invoke search index update.

   815     $this->drupalLogout();

   816     $this->cronRun();

   817 

   818     // Search for the comment subject.

   819     $edit = array(

   820       'search_block_form' => "'" . $edit_comment['subject'] . "'",

   821     );

   822     $this->drupalPost('', $edit, t('Search'));

   823     $this->assertText($node->title, 'Node found in search results.');

   824     $this->assertText($edit_comment['subject'], 'Comment subject found in search results.');

   825 

   826     // Search for the comment body.

   827     $edit = array(

   828       'search_block_form' => "'" . $comment_body . "'",

   829     );

   830     $this->drupalPost('', $edit, t('Search'));

   831     $this->assertText($node->title, 'Node found in search results.');

   832 

   833     // Verify that comment is rendered using proper format.

   834     $this->assertText($comment_body, 'Comment body text found in search results.');

   835     $this->assertNoRaw(t('n/a'), 'HTML in comment body is not hidden.');

   836     $this->assertNoRaw(check_plain($edit_comment['comment_body[' . LANGUAGE_NONE . '][0][value]']), 'HTML in comment body is not escaped.');

   837 

   838     // Hide comments.

   839     $this->drupalLogin($this->admin_user);

   840     $node->comment = 0;

   841     node_save($node);

   842 

   843     // Invoke search index update.

   844     $this->drupalLogout();

   845     $this->cronRun();

   846 

   847     // Search for $title.

   848     $this->drupalPost('', $edit, t('Search'));

   849     $this->assertNoText($comment_body, 'Comment body text not found in search results.');

   850   }

   851 

   852   /**

   853    * Verify access rules for comment indexing with different permissions.

   854    */

   855   function testSearchResultsCommentAccess() {

   856     $comment_body = 'Test comment body';

   857     $this->comment_subject = 'Test comment subject';

   858     $this->admin_role = $this->admin_user->roles;

   859     unset($this->admin_role[DRUPAL_AUTHENTICATED_RID]);

   860     $this->admin_role = key($this->admin_role);

   861 

   862     // Create a node.

   863     variable_set('comment_preview_article', DRUPAL_OPTIONAL);

   864     $this->node = $this->drupalCreateNode(array('type' => 'article'));

   865 

   866     // Post a comment using 'Full HTML' text format.

   867     $edit_comment = array();

   868     $edit_comment['subject'] = $this->comment_subject;

   869     $edit_comment['comment_body[' . LANGUAGE_NONE . '][0][value]'] = '<h1>' . $comment_body . '</h1>';

   870     $this->drupalPost('comment/reply/' . $this->node->nid, $edit_comment, t('Save'));

   871 

   872     $this->drupalLogout();

   873     $this->setRolePermissions(DRUPAL_ANONYMOUS_RID);

   874     $this->checkCommentAccess('Anon user has search permission but no access comments permission, comments should not be indexed');

   875 

   876     $this->setRolePermissions(DRUPAL_ANONYMOUS_RID, TRUE);

   877     $this->checkCommentAccess('Anon user has search permission and access comments permission, comments should be indexed', TRUE);

   878 

   879     $this->drupalLogin($this->admin_user);

   880     $this->drupalGet('admin/people/permissions');

   881 

   882     // Disable search access for authenticated user to test admin user.

   883     $this->setRolePermissions(DRUPAL_AUTHENTICATED_RID, FALSE, FALSE);

   884 

   885     $this->setRolePermissions($this->admin_role);

   886     $this->checkCommentAccess('Admin user has search permission but no access comments permission, comments should not be indexed');

   887 

   888     $this->setRolePermissions($this->admin_role, TRUE);

   889     $this->checkCommentAccess('Admin user has search permission and access comments permission, comments should be indexed', TRUE);

   890 

   891     $this->setRolePermissions(DRUPAL_AUTHENTICATED_RID);

   892     $this->checkCommentAccess('Authenticated user has search permission but no access comments permission, comments should not be indexed');

   893 

   894     $this->setRolePermissions(DRUPAL_AUTHENTICATED_RID, TRUE);

   895     $this->checkCommentAccess('Authenticated user has search permission and access comments permission, comments should be indexed', TRUE);

   896 

   897     // Verify that access comments permission is inherited from the

   898     // authenticated role.

   899     $this->setRolePermissions(DRUPAL_AUTHENTICATED_RID, TRUE, FALSE);

   900     $this->setRolePermissions($this->admin_role);

   901     $this->checkCommentAccess('Admin user has search permission and no access comments permission, but comments should be indexed because admin user inherits authenticated user\'s permission to access comments', TRUE);

   902 

   903     // Verify that search content permission is inherited from the authenticated

   904     // role.

   905     $this->setRolePermissions(DRUPAL_AUTHENTICATED_RID, TRUE, TRUE);

   906     $this->setRolePermissions($this->admin_role, TRUE, FALSE);

   907     $this->checkCommentAccess('Admin user has access comments permission and no search permission, but comments should be indexed because admin user inherits authenticated user\'s permission to search', TRUE);

   908 

   909   }

   910 

   911   /**

   912    * Set permissions for role.

   913    */

   914   function setRolePermissions($rid, $access_comments = FALSE, $search_content = TRUE) {

   915     $permissions = array(

   916       'access comments' => $access_comments,

   917       'search content' => $search_content,

   918     );

   919     user_role_change_permissions($rid, $permissions);

   920   }

   921 

   922   /**

   923    * Update search index and search for comment.

   924    */

   925   function checkCommentAccess($message, $assume_access = FALSE) {

   926     // Invoke search index update.

   927     search_touch_node($this->node->nid);

   928     $this->cronRun();

   929 

   930     // Search for the comment subject.

   931     $edit = array(

   932       'search_block_form' => "'" . $this->comment_subject . "'",

   933     );

   934     $this->drupalPost('', $edit, t('Search'));

   935     $method = $assume_access ? 'assertText' : 'assertNoText';

   936     $verb = $assume_access ? 'found' : 'not found';

   937     $this->{$method}($this->node->title, "Node $verb in search results: " . $message);

   938     $this->{$method}($this->comment_subject, "Comment subject $verb in search results: " . $message);

   939   }

   940 

   941   /**

   942    * Verify that 'add new comment' does not appear in search results or index.

   943    */

   944   function testAddNewComment() {

   945     // Create a node with a short body.

   946     $settings = array(

   947       'type' => 'article',

   948       'title' => 'short title',

   949       'body' => array(LANGUAGE_NONE => array(array('value' => 'short body text'))),

   950     );

   951 

   952     $user = $this->drupalCreateUser(array('search content', 'create article content', 'access content'));

   953     $this->drupalLogin($user);

   954 

   955     $node = $this->drupalCreateNode($settings);

   956     // Verify that if you view the node on its own page, 'add new comment'

   957     // is there.

   958     $this->drupalGet('node/' . $node->nid);

   959     $this->assertText(t('Add new comment'), 'Add new comment appears on node page');

   960 

   961     // Run cron to index this page.

   962     $this->drupalLogout();

   963     $this->cronRun();

   964 

   965     // Search for 'comment'. Should be no results.

   966     $this->drupalLogin($user);

   967     $this->drupalPost('search/node', array('keys' => 'comment'), t('Search'));

   968     $this->assertText(t('Your search yielded no results'), 'No results searching for the word comment');

   969 

   970     // Search for the node title. Should be found, and 'Add new comment' should

   971     // not be part of the search snippet.

   972     $this->drupalPost('search/node', array('keys' => 'short'), t('Search'));

   973     $this->assertText($node->title, 'Search for keyword worked');

   974     $this->assertNoText(t('Add new comment'), 'Add new comment does not appear on search results page');

   975   }

   976 

   977 }

   978 

   979 /**

   980  * Tests search_expression_insert() and search_expression_extract().

   981  *

   982  * @see http://drupal.org/node/419388 (issue)

   983  */

   984 class SearchExpressionInsertExtractTestCase extends DrupalUnitTestCase {

   985   public static function getInfo() {

   986     return array(

   987       'name' => 'Search expression insert/extract',

   988       'description' => 'Tests the functions search_expression_insert() and search_expression_extract()',

   989       'group' => 'Search',

   990     );

   991   }

   992 

   993   function setUp() {

   994     drupal_load('module', 'search');

   995     parent::setUp();

   996   }

   997 

   998   /**

   999    * Tests search_expression_insert() and search_expression_extract().

  1000    */

  1001   function testInsertExtract() {

  1002     $base_expression = "mykeyword";

  1003     // Build an array of option, value, what should be in the expression, what

  1004     // should be retrieved from expression.

  1005     $cases = array(

  1006       array('foo', 'bar', 'foo:bar', 'bar'), // Normal case.

  1007       array('foo', NULL, '', NULL), // Empty value: shouldn't insert.

  1008       array('foo', ' ', 'foo:', ''), // Space as value: should insert but retrieve empty string.

  1009       array('foo', '', 'foo:', ''), // Empty string as value: should insert but retrieve empty string.

  1010       array('foo', '0', 'foo:0', '0'), // String zero as value: should insert.

  1011       array('foo', 0, 'foo:0', '0'), // Numeric zero as value: should insert.

  1012     );

  1013 

  1014     foreach ($cases as $index => $case) {

  1015       $after_insert = search_expression_insert($base_expression, $case[0], $case[1]);

  1016       if (empty($case[2])) {

  1017         $this->assertEqual($after_insert, $base_expression, "Empty insert does not change expression in case $index");

  1018       }

  1019       else {

  1020         $this->assertEqual($after_insert, $base_expression . ' ' . $case[2], "Insert added correct expression for case $index");

  1021       }

  1022 

  1023       $retrieved = search_expression_extract($after_insert, $case[0]);

  1024       if (!isset($case[3])) {

  1025         $this->assertFalse(isset($retrieved), "Empty retrieval results in unset value in case $index");

  1026       }

  1027       else {

  1028         $this->assertEqual($retrieved, $case[3], "Value is retrieved for case $index");

  1029       }

  1030 

  1031       $after_clear = search_expression_insert($after_insert, $case[0]);

  1032       $this->assertEqual(trim($after_clear), $base_expression, "After clearing, base expression is restored for case $index");

  1033 

  1034       $cleared = search_expression_extract($after_clear, $case[0]);

  1035       $this->assertFalse(isset($cleared), "After clearing, value could not be retrieved for case $index");

  1036     }

  1037   }

  1038 }

  1039 

  1040 /**

  1041  * Tests that comment count display toggles properly on comment status of node

  1042  *

  1043  * Issue 537278

  1044  *

  1045  * - Nodes with comment status set to Open should always how comment counts

  1046  * - Nodes with comment status set to Closed should show comment counts

  1047  *     only when there are comments

  1048  * - Nodes with comment status set to Hidden should never show comment counts

  1049  */

  1050 class SearchCommentCountToggleTestCase extends DrupalWebTestCase {

  1051   protected $searching_user;

  1052   protected $searchable_nodes;

  1053 

  1054   public static function getInfo() {

  1055     return array(

  1056       'name' => 'Comment count toggle',

  1057       'description' => 'Verify that comment count display toggles properly on comment status of node.',

  1058       'group' => 'Search',

  1059     );

  1060   }

  1061 

  1062   function setUp() {

  1063     parent::setUp('search');

  1064 

  1065     // Create searching user.

  1066     $this->searching_user = $this->drupalCreateUser(array('search content', 'access content', 'access comments', 'skip comment approval'));

  1067 

  1068     // Create initial nodes.

  1069     $node_params = array('type' => 'article', 'body' => array(LANGUAGE_NONE => array(array('value' => 'SearchCommentToggleTestCase'))));

  1070 

  1071     $this->searchable_nodes['1 comment'] = $this->drupalCreateNode($node_params);

  1072     $this->searchable_nodes['0 comments'] = $this->drupalCreateNode($node_params);

  1073 

  1074     // Login with sufficient privileges.

  1075     $this->drupalLogin($this->searching_user);

  1076 

  1077     // Create a comment array

  1078     $edit_comment = array();

  1079     $edit_comment['subject'] = $this->randomName();

  1080     $edit_comment['comment_body[' . LANGUAGE_NONE . '][0][value]'] = $this->randomName();

  1081     $filtered_html_format_id = 'filtered_html';

  1082     $edit_comment['comment_body[' . LANGUAGE_NONE . '][0][format]'] = $filtered_html_format_id;

  1083 

  1084     // Post comment to the test node with comment

  1085     $this->drupalPost('comment/reply/' . $this->searchable_nodes['1 comment']->nid, $edit_comment, t('Save'));

  1086 

  1087     // First update the index. This does the initial processing.

  1088     node_update_index();

  1089 

  1090     // Then, run the shutdown function. Testing is a unique case where indexing

  1091     // and searching has to happen in the same request, so running the shutdown

  1092     // function manually is needed to finish the indexing process.

  1093     search_update_totals();

  1094   }

  1095 

  1096   /**

  1097    * Verify that comment count display toggles properly on comment status of node

  1098    */

  1099   function testSearchCommentCountToggle() {

  1100     // Search for the nodes by string in the node body.

  1101     $edit = array(

  1102       'search_block_form' => "'SearchCommentToggleTestCase'",

  1103     );

  1104 

  1105     // Test comment count display for nodes with comment status set to Open

  1106     $this->drupalPost('', $edit, t('Search'));

  1107     $this->assertText(t('0 comments'), 'Empty comment count displays for nodes with comment status set to Open');

  1108     $this->assertText(t('1 comment'), 'Non-empty comment count displays for nodes with comment status set to Open');

  1109 

  1110     // Test comment count display for nodes with comment status set to Closed

  1111     $this->searchable_nodes['0 comments']->comment = COMMENT_NODE_CLOSED;

  1112     node_save($this->searchable_nodes['0 comments']);

  1113     $this->searchable_nodes['1 comment']->comment = COMMENT_NODE_CLOSED;

  1114     node_save($this->searchable_nodes['1 comment']);

  1115 

  1116     $this->drupalPost('', $edit, t('Search'));

  1117     $this->assertNoText(t('0 comments'), 'Empty comment count does not display for nodes with comment status set to Closed');

  1118     $this->assertText(t('1 comment'), 'Non-empty comment count displays for nodes with comment status set to Closed');

  1119 

  1120     // Test comment count display for nodes with comment status set to Hidden

  1121     $this->searchable_nodes['0 comments']->comment = COMMENT_NODE_HIDDEN;

  1122     node_save($this->searchable_nodes['0 comments']);

  1123     $this->searchable_nodes['1 comment']->comment = COMMENT_NODE_HIDDEN;

  1124     node_save($this->searchable_nodes['1 comment']);

  1125 

  1126     $this->drupalPost('', $edit, t('Search'));

  1127     $this->assertNoText(t('0 comments'), 'Empty comment count does not display for nodes with comment status set to Hidden');

  1128     $this->assertNoText(t('1 comment'), 'Non-empty comment count does not display for nodes with comment status set to Hidden');

  1129   }

  1130 }

  1131 

  1132 /**

  1133  * Test search_simplify() on every Unicode character, and some other cases.

  1134  */

  1135 class SearchSimplifyTestCase extends DrupalWebTestCase {

  1136   public static function getInfo() {