assertResponse(200, 'HTTP code 200 returned.'); return $ret; } /** * Overrides DrupalWebTestCase::drupalPost(). * * Additionally asserts that the HTTP request returned a 200 status code. */ protected function drupalPost($path, $edit, $submit, array $options = array(), array $headers = array(), $form_html_id = NULL, $extra_post = NULL) { $ret = parent::drupalPost($path, $edit, $submit, $options, $headers, $form_html_id, $extra_post); $this->assertResponse(200, 'HTTP code 200 returned.'); return $ret; } /** * Returns information about this test case. * * @return array * An array with information about this test case. */ public static function getInfo() { return array( 'name' => 'Test search API framework', 'description' => 'Tests basic functions of the Search API, like creating, editing and deleting servers and indexes.', 'group' => 'Search API', ); } /** * {@inheritdoc} */ public function setUp() { parent::setUp('entity', 'search_api', 'search_api_test'); } /** * Tests correct admin UI, indexing and search behavior. * * We only use a single test method to avoid wasting ressources on setting up * the test environment multiple times. This will be the only method called * by the Simpletest framework (since the method name starts with "test"). It * in turn calls other methdos that set up the environment in a certain way * and then run tests on it. */ public function testFramework() { $this->drupalLogin($this->drupalCreateUser(array('administer search_api'))); $this->insertItems(); $this->createIndex(); $this->insertItems(); $this->createServer(); $this->checkOverview(); $this->enableIndex(); $this->searchNoResults(); $this->indexItems(); $this->searchSuccess(); $this->checkIndexingOrder(); $this->editServer(); $this->clearIndex(); $this->searchNoResults(); $this->deleteServer(); $this->disableModules(); } /** * Returns the test server in use by this test case. * * @return SearchApiServer * The test server. */ protected function server() { return search_api_server_load($this->server_id, TRUE); } /** * Returns the test index in use by this test case. * * @return SearchApiIndex * The test index. */ protected function index() { return search_api_index_load($this->index_id, TRUE); } /** * Inserts some test items into the database, via the test module. * * @param int $number * The number of items to insert. * * @see insertItem() */ protected function insertItems($number = 5) { $count = db_query('SELECT COUNT(*) FROM {search_api_test}')->fetchField(); for ($i = 1; $i <= $number; ++$i) { $id = $count + $i; $this->insertItem(array( 'id' => $id, 'title' => "Title $id", 'body' => "Body text $id.", 'type' => 'Item', )); } $count = db_query('SELECT COUNT(*) FROM {search_api_test}')->fetchField() - $count; $this->assertEqual($count, $number, "$number items successfully inserted."); } /** * Helper function for inserting a single test item. * * @param array $values * The property values of the test item. * * @see search_api_test_insert_item() */ protected function insertItem(array $values) { $this->drupalPost('search_api_test/insert', $values, t('Save')); } /** * Creates a test index via the UI and tests whether this works correctly. */ protected function createIndex() { $values = array( 'name' => '', 'item_type' => '', 'enabled' => 1, 'description' => 'An index used for testing.', 'server' => '', 'options[cron_limit]' => 5, ); $this->drupalPost('admin/config/search/search_api/add_index', $values, t('Create index')); $this->assertText(t('!name field is required.', array('!name' => t('Index name')))); $this->assertText(t('!name field is required.', array('!name' => t('Item type')))); $this->index_id = $id = 'test_index'; $values = array( 'name' => 'Search API test index', 'machine_name' => $id, 'item_type' => 'search_api_test', 'enabled' => 1, 'description' => 'An index used for testing.', 'server' => '', 'options[cron_limit]' => 1, ); $this->drupalPost(NULL, $values, t('Create index')); $this->assertText(t('The index was successfully created. Please set up its indexed fields now.'), 'The index was successfully created.'); $found = strpos($this->getUrl(), 'admin/config/search/search_api/index/' . $id) !== FALSE; $this->assertTrue($found, 'Correct redirect.'); $index = $this->index(); $this->assertEqual($index->name, $values['name'], 'Name correctly inserted.'); $this->assertEqual($index->item_type, $values['item_type'], 'Index item type correctly inserted.'); $this->assertFalse($index->enabled, 'Status correctly inserted.'); $this->assertEqual($index->description, $values['description'], 'Description correctly inserted.'); $this->assertNull($index->server, 'Index server correctly inserted.'); $this->assertEqual($index->options['cron_limit'], $values['options[cron_limit]'], 'Cron batch size correctly inserted.'); $values = array( 'additional[field]' => 'parent', ); $this->drupalPost("admin/config/search/search_api/index/$id/fields", $values, t('Add fields')); $this->assertText(t('The available fields were successfully changed.'), 'Successfully added fields.'); $this->assertText('Parent » ID', 'Added fields are displayed.'); $values = array( 'fields[id][type]' => 'integer', 'fields[id][boost]' => '1.0', 'fields[id][indexed]' => 1, 'fields[title][type]' => 'text', 'fields[title][boost]' => '5.0', 'fields[title][indexed]' => 1, 'fields[body][type]' => 'text', 'fields[body][boost]' => '1.0', 'fields[body][indexed]' => 1, 'fields[type][type]' => 'string', 'fields[type][boost]' => '1.0', 'fields[type][indexed]' => 1, 'fields[parent:id][type]' => 'integer', 'fields[parent:id][boost]' => '1.0', 'fields[parent:id][indexed]' => 1, 'fields[parent:title][type]' => 'text', 'fields[parent:title][boost]' => '5.0', 'fields[parent:title][indexed]' => 1, 'fields[parent:body][type]' => 'text', 'fields[parent:body][boost]' => '1.0', 'fields[parent:body][indexed]' => 1, 'fields[parent:type][type]' => 'string', 'fields[parent:type][boost]' => '1.0', 'fields[parent:type][indexed]' => 1, ); $this->drupalPost(NULL, $values, t('Save changes')); $this->assertText(t('The indexed fields were successfully changed. The index was cleared and will have to be re-indexed with the new settings.'), 'Field settings saved.'); $values = array( 'callbacks[search_api_alter_add_url][status]' => 1, 'callbacks[search_api_alter_add_url][weight]' => 0, 'callbacks[search_api_alter_add_aggregation][status]' => 1, 'callbacks[search_api_alter_add_aggregation][weight]' => 10, 'processors[search_api_case_ignore][status]' => 1, 'processors[search_api_case_ignore][weight]' => 0, 'processors[search_api_case_ignore][settings][fields][title]' => 1, 'processors[search_api_case_ignore][settings][fields][body]' => 1, 'processors[search_api_case_ignore][settings][fields][parent:title]' => 1, 'processors[search_api_case_ignore][settings][fields][parent:body]' => 1, 'processors[search_api_tokenizer][status]' => 1, 'processors[search_api_tokenizer][weight]' => 20, 'processors[search_api_tokenizer][settings][spaces]' => '[^\p{L}\p{N}]', 'processors[search_api_tokenizer][settings][ignorable]' => '[-]', 'processors[search_api_tokenizer][settings][fields][title]' => 1, 'processors[search_api_tokenizer][settings][fields][body]' => 1, 'processors[search_api_tokenizer][settings][fields][parent:title]' => 1, 'processors[search_api_tokenizer][settings][fields][parent:body]' => 1, ); $this->drupalPost(NULL, $values, t('Add new field')); $values = array( 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][name]' => 'Test fulltext field', 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][type]' => 'fulltext', 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][fields][title]' => 1, 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][fields][body]' => 1, 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][fields][parent:title]' => 1, 'callbacks[search_api_alter_add_aggregation][settings][fields][search_api_aggregation_1][fields][parent:body]' => 1, ); $this->drupalPost(NULL, $values, t('Save configuration')); $this->assertText(t("The indexing workflow was successfully edited. All content was scheduled for re-indexing so the new settings can take effect."), 'Workflow successfully edited.'); $this->drupalGet("admin/config/search/search_api/index/$id"); $this->assertTitle('Search API test index | Drupal', 'Correct title when viewing index.'); $this->assertText('An index used for testing.', 'Description displayed.'); $this->assertText('Search API test entity', 'Item type displayed.'); $this->assertText(t('disabled'), '"Disabled" status displayed.'); } /** * Creates a test server via the UI and tests whether this works correctly. */ protected function createServer() { $values = array( 'name' => '', 'enabled' => 1, 'description' => 'A server used for testing.', 'class' => '', ); $this->drupalPost('admin/config/search/search_api/add_server', $values, t('Create server')); $this->assertText(t('!name field is required.', array('!name' => t('Server name')))); $this->assertText(t('!name field is required.', array('!name' => t('Service class')))); $this->server_id = $id = 'test_server'; $values = array( 'name' => 'Search API test server', 'machine_name' => $id, 'enabled' => 1, 'description' => 'A server used for testing.', 'class' => 'search_api_test_service', ); $this->drupalPost(NULL, $values, t('Create server')); $values2 = array( 'options[form][test]' => 'search_api_test foo bar', ); $this->drupalPost(NULL, $values2, t('Create server')); $this->assertText(t('The server was successfully created.')); $found = strpos($this->getUrl(), 'admin/config/search/search_api/server/' . $id) !== FALSE; $this->assertTrue($found, 'Correct redirect.'); $server = $this->server(); $this->assertEqual($server->name, $values['name'], 'Name correctly inserted.'); $this->assertTrue($server->enabled, 'Status correctly inserted.'); $this->assertEqual($server->description, $values['description'], 'Description correctly inserted.'); $this->assertEqual($server->class, $values['class'], 'Service class correctly inserted.'); $this->assertEqual($server->options['test'], $values2['options[form][test]'], 'Service options correctly inserted.'); $this->assertTitle('Search API test server | Drupal', 'Correct title when viewing server.'); $this->assertText('A server used for testing.', 'Description displayed.'); $this->assertText('search_api_test_service', 'Service name displayed.'); $this->assertText('search_api_test foo bar', 'Service options displayed.'); } /** * Checks whether the server and index are correctly listed in the overview. */ protected function checkOverview() { $this->drupalGet('admin/config/search/search_api'); $this->assertText('Search API test server', 'Server displayed.'); $this->assertText('Search API test index', 'Index displayed.'); $this->assertNoText(t('There are no search servers or indexes defined yet.'), '"No servers" message not displayed.'); } /** * Moves the index onto the server and enables it. */ protected function enableIndex() { $values = array( 'server' => $this->server_id, ); $this->drupalPost("admin/config/search/search_api/index/{$this->index_id}/edit", $values, t('Save settings')); $this->assertText(t('The search index was successfully edited.')); $this->assertText('Search API test server', 'Server displayed.'); $this->clickLink(t('enable')); $this->assertText(t('The index was successfully enabled.')); } /** * Asserts that a search on the index works but yields no results. * * This is the case since no items should have been indexed yet. */ protected function searchNoResults() { $results = $this->doSearch(); $this->assertEqual($results['result count'], 0, 'No search results returned without indexing.'); $this->assertEqual(array_keys($results['results']), array(), 'No search results returned without indexing.'); } /** * Executes a search on the test index. * * Helper method used for testing search results. * * @param int|null $offset * (optional) The offset for the returned results. * @param int|null $limit * (optional) The limit for the returned results. * * @return array * Search results as specified by SearchApiQueryInterface::execute(). */ protected function doSearch($offset = NULL, $limit = NULL) { // Since we change server and index settings via the UI (and, therefore, in // different page requests), the static cache in this page request // (executing the tests) will get stale. Therefore, we clear it before // executing the search. $this->index(); $this->server(); $query = search_api_query($this->index_id); if ($offset || $limit) { $query->range($offset, $limit); } return $query->execute(); } /** * Tests indexing via the UI "Index now" functionality. * * Asserts that errors during indexing are handled properly and that the * status readings work. */ protected function indexItems() { $this->checkIndexStatus(); // Here we test the indexing + the warning message when some items // cannot be indexed. // The server refuses (for test purpose) to index the item that has the same // ID as the "search_api_test_indexing_break" variable (default: 8). // Therefore, if we try to index 8 items, only the first seven will be // successfully indexed and a warning should be displayed. $values = array( 'limit' => 8, ); $this->drupalPost(NULL, $values, t('Index now')); $this->assertText(t('Successfully indexed @count items.', array('@count' => 7))); $this->assertText(t('1 item could not be indexed. Check the logs for details.'), 'Index errors warning is displayed.'); $this->assertNoText(t("Couldn't index items. Check the logs for details."), "Index error isn't displayed."); $this->checkIndexStatus(7); // Here we're testing the error message when no item could be indexed. // The item with ID 8 is still not indexed, but it will be the first to be // indexed now. Therefore, if we try to index a single items, only item 8 // will be passed to the server, which will reject it and no items will be // indexed. Since normally this signifies a more serious error than when // only some items couldn't be indexed, this is handled differently. $values = array( 'limit' => 1, ); $this->drupalPost(NULL, $values, t('Index now')); $this->assertNoPattern('/' . str_replace('144', '-?\d*', t('Successfully indexed @count items.', array('@count' => 144))) . '/', 'No items could be indexed.'); $this->assertNoText(t('1 item could not be indexed. Check the logs for details.'), "Index errors warning isn't displayed."); $this->assertText(t("Couldn't index items. Check the logs for details."), 'Index error is displayed.'); // No we set the "search_api_test_indexing_break" variable to 0, so all // items will be indexed. The remaining items (8, 9, 10) should therefore // be successfully indexed and no warning should show. variable_set('search_api_test_indexing_break', 0); $values = array( 'limit' => -1, ); $this->drupalPost(NULL, $values, t('Index now')); $this->assertText(t('Successfully indexed @count items.', array('@count' => 3))); $this->assertNoText(t("Some items couldn't be indexed. Check the logs for details."), "Index errors warning isn't displayed."); $this->assertNoText(t("Couldn't index items. Check the logs for details."), "Index error isn't displayed."); $this->checkIndexStatus(10); // Reset the static cache for the server. $this->server(); } /** * Checks whether the index's "Status" tab shows the correct values. * * Helper method used by indexItems() and others. * * The internal browser will point to the index's "Status" tab after this * method is called. * * @param int $indexed * (optional) The number of items that should be indexed at the moment. * Defaults to 0. * @param int $total * (optional) The (correct) total number of items. Defaults to 10. * @param bool $check_buttons * (optional) Whether to check for the correct presence/absence of buttons. * Defaults to TRUE. * @param int|null $on_server * (optional) The number of items actually on the server. Defaults to * $indexed. */ protected function checkIndexStatus($indexed = 0, $total = 10, $check_buttons = TRUE, $on_server = NULL) { $url = "admin/config/search/search_api/index/{$this->index_id}"; if (strpos($this->url, $url) === FALSE) { $this->drupalGet($url); } $index_status = t('@indexed/@total indexed', array('@indexed' => $indexed, '@total' => $total)); $this->assertText($index_status, 'Correct index status displayed.'); if (!isset($on_server)) { $on_server = $indexed; } $info = format_plural($on_server, 'There is 1 item indexed on the server for this index.', 'There are @count items indexed on the server for this index.'); $this->assertText(t('Server index status'), 'Server index status displayed.'); $this->assertText($info, 'Correct server index status displayed.'); if (!$check_buttons) { return; } $this->assertText(t('enabled'), '"Enabled" status displayed.'); if ($indexed == $total) { $this->assertRaw('disabled="disabled"', '"Index now" form disabled.'); } else { $this->assertNoRaw('disabled="disabled"', '"Index now" form enabled.'); } } /** * Tests whether searches yield the right results after indexing. * * The test server only implements range functionality, no kind of fulltext * search capabilities, so we can only test for that. */ protected function searchSuccess() { $results = $this->doSearch(); $this->assertEqual($results['result count'], 10, 'Correct search result count returned after indexing.'); $this->assertEqual(array_keys($results['results']), array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 'Correct search results returned after indexing.'); $results = $this->doSearch(2, 4); $this->assertEqual($results['result count'], 10, 'Correct search result count with ranged query.'); $this->assertEqual(array_keys($results['results']), array(3, 4, 5, 6), 'Correct search results with ranged query.'); } /** * Tests whether items are indexed in the right order. * * The indexing order should always be that new items are indexed before * changed ones, and only then the changed items in the order of their change. * * This method also assures that this behavior is even observed when indexing * temporarily fails. * * @see https://drupal.org/node/2115127 */ protected function checkIndexingOrder() { // Set cron batch size to 1 so not all items will get indexed right away. // This also ensures that later, when indexing of a single item will be // rejected by using the "search_api_test_indexing_break" variable, this // will have the effect of rejecting "all" items of a batch (since that // batch only consists of a single item). $values = array( 'options[cron_limit]' => 1, ); $this->drupalPost("admin/config/search/search_api/index/{$this->index_id}/edit", $values, t('Save settings')); $this->assertText(t('The search index was successfully edited.')); // Manually clear the server's item storage – that way, the items will still // count as indexed for the Search API, but won't be returned in searches. // We do this so we have finer-grained control over the order in which items // are indexed. $this->server()->deleteItems(); $results = $this->doSearch(); $this->assertEqual($results['result count'], 0, 'Indexed items were successfully deleted from the server.'); $this->assertEqual(array_keys($results['results']), array(), 'Indexed items were successfully deleted from the server.'); // Now insert some new items, and mark others as changed. Make sure that // each action has a unique timestamp, so the order will be correct. $this->drupalGet('search_api_test/touch/8'); $this->insertItems(1);// item 11 sleep(1); $this->drupalGet('search_api_test/touch/2'); $this->insertItems(1);// item 12 sleep(1); $this->drupalGet('search_api_test/touch/5'); $this->insertItems(1);// item 13 sleep(1); $this->drupalGet('search_api_test/touch/8'); $this->insertItems(1); // item 14 // Check whether the status display is right. $this->checkIndexStatus(7, 14, FALSE, 0); // Indexing order should now be: 11, 12, 13, 14, 8, 2, 4. Let's try it out! // First manually index one item, and see if it's 11. $values = array( 'limit' => 1, ); $this->drupalPost(NULL, $values, t('Index now')); $this->assertText(t('Successfully indexed @count item.', array('@count' => 1))); $this->assertNoText(t("Some items couldn't be indexed. Check the logs for details."), "Index errors warning isn't displayed."); $this->assertNoText(t("Couldn't index items. Check the logs for details."), "Index error isn't displayed."); $this->checkIndexStatus(8, 14, FALSE, 1); $results = $this->doSearch(); $this->assertEqual($results['result count'], 1, 'Indexing order test 1: correct result count.'); $this->assertEqual(array_keys($results['results']), array(11), 'Indexing order test 1: correct results.'); // Now index with a cron run, but stop at item 8. variable_set('search_api_test_indexing_break', 8); $this->cronRun(); // Now just the four new items should have been indexed. $results = $this->doSearch(); $this->assertEqual($results['result count'], 4, 'Indexing order test 2: correct result count.'); $this->assertEqual(array_keys($results['results']), array(11, 12, 13, 14), 'Indexing order test 2: correct results.'); // This time stop at item 5 (should be the last one). variable_set('search_api_test_indexing_break', 5); $this->cronRun(); // Now all new and changed items should have been indexed, except item 5. $results = $this->doSearch(); $this->assertEqual($results['result count'], 6, 'Indexing order test 3: correct result count.'); $this->assertEqual(array_keys($results['results']), array(2, 8, 11, 12, 13, 14), 'Indexing order test 3: correct results.'); // Index the remaining item. variable_set('search_api_test_indexing_break', 0); $this->cronRun(); // Now all new and changed items should have been indexed. $results = $this->doSearch(); $this->assertEqual($results['result count'], 7, 'Indexing order test 4: correct result count.'); $this->assertEqual(array_keys($results['results']), array(2, 5, 8, 11, 12, 13, 14), 'Indexing order test 4: correct results.'); } /** * Tests whether the server tasks system works correctly. * * Uses the "search_api_test_error_state" variable to trigger exceptions in * the test service class and asserts that the Search API reacts correctly and * re-attempts the operation on the next cron run. */ protected function checkServerTasks() { // Make sure none of the previous operations added any tasks. $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 0, 'No server tasks were previously saved.'); // Set error state for test service, so all operations will fail. variable_set('search_api_test_error_state', TRUE); // Delete some items. $this->drupalGet('search_api_test/delete/8'); $this->drupalGet('search_api_test/delete/12'); // Assert that the indexed items haven't changed yet. $results = $this->doSearch(); $this->assertEqual(array_keys($results['results']), array(2, 5, 8, 11, 12, 13, 14), 'During error state, no indexed items were deleted.'); // Check that tasks were correctly inserted. $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 2, 'Server tasks for deleted items were saved.'); // Now reset the error state variable and run cron to delete the items. variable_set('search_api_test_error_state', FALSE); $this->cronRun(); // Assert that the indexed items were indeed deleted from the server. $results = $this->doSearch(); $this->assertEqual(array_keys($results['results']), array(2, 5, 11, 13, 14), 'Pending "delete item" server tasks were correctly executed during the cron run.'); // Check that the tasks were correctly deleted. $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 0, 'Server tasks were correctly deleted after being executed.'); // Now we first delete more items, then disable the server (thereby removing // the index from it) – all while in error state. variable_set('search_api_test_error_state', TRUE); $this->drupalGet('search_api_test/delete/14'); $this->drupalGet('search_api_test/delete/2'); $settings['enabled'] = 0; $this->drupalPost("admin/config/search/search_api/server/{$this->server_id}/edit", $settings, t('Save settings')); // Check whether the index was correctly removed from the server. $this->assertEqual($this->index()->server(), NULL, 'The index was successfully set to have no server.'); $exception = FALSE; try { $this->doSearch(); } catch (SearchApiException $e) { $exception = TRUE; } $this->assertTrue($exception, 'Searching on the index failed with an exception.'); // Check that only one task – to remove the index from the server – is now // present in the tasks table. $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 1, 'Only the "remove index" task is present in the server tasks.'); // Reset the error state variable, re-enable the server. variable_set('search_api_test_error_state', FALSE); $settings['enabled'] = 1; $this->drupalPost("admin/config/search/search_api/server/{$this->server_id}/edit", $settings, t('Save settings')); // Check whether the index was really removed from the server now. $server = $this->server(); $this->assertTrue(empty($server->options['indexes'][$this->index_id]), 'The index was removed from the server after cron ran.'); $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 0, 'Server tasks were correctly deleted after being executed.'); // Put the index back on the server and index some items for the next tests. $settings = array('server' => $this->server_id); $this->drupalPost("admin/config/search/search_api/index/{$this->index_id}/edit", $settings, t('Save settings')); $this->cronRun(); } /** * Tests whether editing the server works correctly. */ protected function editServer() { $values = array( 'name' => 'test-name-foo', 'description' => 'test-description-bar', 'options[form][test]' => 'test-test-baz', ); $this->drupalPost("admin/config/search/search_api/server/{$this->server_id}/edit", $values, t('Save settings')); $this->assertText(t('The search server was successfully edited.')); $this->assertText('test-name-foo', 'Name changed.'); $this->assertText('test-description-bar', 'Description changed.'); $this->assertText('test-test-baz', 'Service options changed.'); } /** * Tests whether clearing the index works correctly. */ protected function clearIndex() { $this->drupalPost("admin/config/search/search_api/index/{$this->index_id}", array(), t('Clear all indexed data')); $this->drupalPost(NULL, array(), t('Confirm')); $this->assertText(t('The index was successfully cleared.')); $this->assertText(t('@indexed/@total indexed', array('@indexed' => 0, '@total' => 14)), 'Correct index status displayed.'); } /** * Tests whether deleting the server works correctly. * * The index still lying on the server should be disabled and removed from it. * Also, any tasks with that server's ID should be deleted. */ protected function deleteServer() { // Insert some dummy tasks to check for. $server = $this->server(); search_api_server_tasks_add($server, 'foo'); search_api_server_tasks_add($server, 'bar', $this->index()); $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 2, 'Dummy tasks were added.'); // Delete the server. $this->drupalPost("admin/config/search/search_api/server/{$this->server_id}/delete", array(), t('Confirm')); $this->assertNoText('test-name-foo', 'Server no longer listed.'); $this->drupalGet("admin/config/search/search_api/index/{$this->index_id}"); $this->assertNoText(t('Server'), 'The index was removed from the server.'); $this->assertText(t('disabled'), 'The index was disabled.'); // Check whether the tasks were correctly deleted. $task_count = db_query('SELECT COUNT(id) FROM {search_api_task}')->fetchField(); $this->assertEqual($task_count, 0, 'Remaining server tasks were correctly deleted.'); } /** * Tests whether disabling and uninstalling the modules works correctly. * * This will disable and uninstall both the test module and the Search API. It * asserts that this works correctly (since the server has been deleted in * deleteServer()) and that all associated tables and variables are removed. */ protected function disableModules() { module_disable(array('search_api_test'), FALSE); $this->assertFalse(module_exists('search_api_test'), 'Test module was successfully disabled.'); module_disable(array('search_api'), FALSE); $this->assertFalse(module_exists('search_api'), 'Search API module was successfully disabled.'); drupal_uninstall_modules(array('search_api_test'), FALSE); $this->assertEqual(drupal_get_installed_schema_version('search_api_test', TRUE), SCHEMA_UNINSTALLED, 'Test module was successfully uninstalled.'); $this->assertFalse(db_table_exists('search_api_test'), 'Test module table was successfully removed.'); drupal_uninstall_modules(array('search_api'), FALSE); $this->assertEqual(drupal_get_installed_schema_version('search_api', TRUE), SCHEMA_UNINSTALLED, 'Search API module was successfully uninstalled.'); $this->assertFalse(db_table_exists('search_api_server'), 'Search server table was successfully removed.'); $this->assertFalse(db_table_exists('search_api_index'), 'Search index table was successfully removed.'); $this->assertFalse(db_table_exists('search_api_item'), 'Index items table was successfully removed.'); $this->assertFalse(db_table_exists('search_api_task'), 'Server tasks table was successfully removed.'); $this->assertNull(variable_get('search_api_index_worker_callback_runtime'), 'Worker runtime variable was correctly removed.'); } } /** * Class with unit tests testing small fragments of the Search API. * * Due to severe limitations for "real" unit tests, this still has to be a * subclass of DrupalWebTestCase. */ class SearchApiUnitTest extends DrupalWebTestCase { /** * The index used by these tests. * * @var SearchApIindex */ protected $index; /** * Overrides DrupalTestCase::assertEqual(). * * For arrays, checks whether all array keys are mapped the same in both * arrays recursively, while ignoring their order. */ protected function assertEqual($first, $second, $message = '', $group = 'Other') { if (is_array($first) && is_array($second)) { return $this->assertTrue($this->deepEquals($first, $second), $message, $group); } else { return parent::assertEqual($first, $second, $message, $group); } } /** * Tests whether two values are equal. * * For arrays, this is done by comparing the key/value pairs recursively * instead of checking for simple equality. * * @param mixed $first * The first value. * @param mixed $second * The second value. * * @return bool * TRUE if the two values are equal, FALSE otherwise. */ protected function deepEquals($first, $second) { if (!is_array($first) || !is_array($second)) { return $first == $second; } $first = array_merge($first); $second = array_merge($second); foreach ($first as $key => $value) { if (!array_key_exists($key, $second) || !$this->deepEquals($value, $second[$key])) { return FALSE; } unset($second[$key]); } return empty($second); } /** * Returns information about this test case. * * @return array * An array with information about this test case. */ public static function getInfo() { return array( 'name' => 'Test search API components', 'description' => 'Tests some independent components of the Search API, like the processors.', 'group' => 'Search API', ); } /** * {@inheritdoc} */ public function setUp() { parent::setUp('entity', 'search_api'); $this->index = entity_create('search_api_index', array( 'id' => 1, 'name' => 'test', 'enabled' => 1, 'item_type' => 'user', 'options' => array( 'fields' => array( 'name' => array( 'type' => 'text', ), 'mail' => array( 'type' => 'string', ), 'search_api_language' => array( 'type' => 'string', ), ), ), )); } /** * Tests the functionality of several components of the module. * * This is the single test method called by the Simpletest framework. It in * turn calls other helper methods to test specific functionality. */ public function testUnits() { $this->checkQueryParseKeys(); $this->checkIgnoreCaseProcessor(); $this->checkTokenizer(); $this->checkHtmlFilter(); } /** * Checks whether the keys are parsed correctly by the query class. */ protected function checkQueryParseKeys() { $options['parse mode'] = 'direct'; $mode = &$options['parse mode']; $query = new SearchApiQuery($this->index, $options); $query->keys('foo'); $this->assertEqual($query->getKeys(), 'foo', '"Direct query" parse mode, test 1.'); $query->keys('foo bar'); $this->assertEqual($query->getKeys(), 'foo bar', '"Direct query" parse mode, test 2.'); $query->keys('(foo bar) OR "bar baz"'); $this->assertEqual($query->getKeys(), '(foo bar) OR "bar baz"', '"Direct query" parse mode, test 3.'); $mode = 'single'; $query = new SearchApiQuery($this->index, $options); $query->keys('foo'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', 'foo'), '"Single term" parse mode, test 1.'); $query->keys('foo bar'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', 'foo bar'), '"Single term" parse mode, test 2.'); $query->keys('(foo bar) OR "bar baz"'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', '(foo bar) OR "bar baz"'), '"Single term" parse mode, test 3.'); $mode = 'terms'; $query = new SearchApiQuery($this->index, $options); $query->keys('foo'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', 'foo'), '"Multiple terms" parse mode, test 1.'); $query->keys('foo bar'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', 'foo', 'bar'), '"Multiple terms" parse mode, test 2.'); $query->keys('(foo bar) OR "bar baz"'); $this->assertEqual($query->getKeys(), array('(foo', 'bar)', 'OR', 'bar baz', '#conjunction' => 'AND'), '"Multiple terms" parse mode, test 3.'); // http://drupal.org/node/1468678 $query->keys('"Münster"'); $this->assertEqual($query->getKeys(), array('#conjunction' => 'AND', 'Münster'), '"Multiple terms" parse mode, test 4.'); } /** * Tests the functionality of the "Ignore case" processor. */ protected function checkIgnoreCaseProcessor() { $orig = 'Foo bar BaZ, ÄÖÜÀÁ<>»«.'; $processed = drupal_strtolower($orig); $items = array( 1 => array( 'name' => array( 'type' => 'text', 'original_type' => 'text', 'value' => $orig, ), 'mail' => array( 'type' => 'string', 'original_type' => 'text', 'value' => $orig, ), 'search_api_language' => array( 'type' => 'string', 'original_type' => 'string', 'value' => LANGUAGE_NONE, ), ), ); $keys1 = $keys2 = array( 'foo', 'bar baz', 'foobar1', '#conjunction' => 'AND', ); $filters1 = array( array('name', 'foo', '='), array('mail', 'BAR', '='), ); $filters2 = array( array('name', 'foo', '='), array('mail', 'bar', '='), ); $processor = new SearchApiIgnoreCase($this->index, array('fields' => array('name' => 'name'))); $tmp = $items; $processor->preprocessIndexItems($tmp); $this->assertEqual($tmp[1]['name']['value'], $processed, 'Name field was processed.'); $this->assertEqual($tmp[1]['mail']['value'], $orig, "Mail field wasn't processed."); $query = new SearchApiQuery($this->index); $query->keys('Foo "baR BaZ" fOObAr1'); $query->condition('name', 'FOO'); $query->condition('mail', 'BAR'); $processor->preprocessSearchQuery($query); $this->assertEqual($query->getKeys(), $keys1, 'Search keys were processed correctly.'); $this->assertEqual($query->getFilter()->getFilters(), $filters1, 'Filters were processed correctly.'); $processor = new SearchApiIgnoreCase($this->index, array('fields' => array('name' => 'name', 'mail' => 'mail'))); $tmp = $items; $processor->preprocessIndexItems($tmp); $this->assertEqual($tmp[1]['name']['value'], $processed, 'Name field was processed.'); $this->assertEqual($tmp[1]['mail']['value'], $processed, 'Mail field was processed.'); $query = new SearchApiQuery($this->index); $query->keys('Foo "baR BaZ" fOObAr1'); $query->condition('name', 'FOO'); $query->condition('mail', 'BAR'); $processor->preprocessSearchQuery($query); $this->assertEqual($query->getKeys(), $keys2, 'Search keys were processed correctly.'); $this->assertEqual($query->getFilter()->getFilters(), $filters2, 'Filters were processed correctly.'); } /** * Tests the functionality of the "Tokenizer" processor. */ protected function checkTokenizer() { $orig = 'Foo bar1 BaZ, La-la-la.'; $processed1 = array( array( 'value' => 'Foo', 'score' => 1, ), array( 'value' => 'bar1', 'score' => 1, ), array( 'value' => 'BaZ', 'score' => 1, ), array( 'value' => 'Lalala', 'score' => 1, ), ); $processed2 = array( array( 'value' => 'Foob', 'score' => 1, ), array( 'value' => 'r1B', 'score' => 1, ), array( 'value' => 'Z,L', 'score' => 1, ), array( 'value' => 'l', 'score' => 1, ), array( 'value' => 'l', 'score' => 1, ), array( 'value' => '.', 'score' => 1, ), ); $items = array( 1 => array( 'name' => array( 'type' => 'text', 'original_type' => 'text', 'value' => $orig, ), 'search_api_language' => array( 'type' => 'string', 'original_type' => 'string', 'value' => LANGUAGE_NONE, ), ), ); $processor = new SearchApiTokenizer($this->index, array('fields' => array('name' => 'name'), 'spaces' => '[^\p{L}\p{N}]', 'ignorable' => '[-]')); $tmp = $items; $processor->preprocessIndexItems($tmp); $this->assertEqual($tmp[1]['name']['value'], $processed1, 'Value was correctly tokenized with default settings.'); $query = new SearchApiQuery($this->index, array('parse mode' => 'direct')); $query->keys("foo \"bar-baz\" \n\t foobar1"); $processor->preprocessSearchQuery($query); $this->assertEqual($query->getKeys(), 'foo barbaz foobar1', 'Search keys were processed correctly.'); $processor = new SearchApiTokenizer($this->index, array('fields' => array('name' => 'name'), 'spaces' => '[-a]', 'ignorable' => '\s')); $tmp = $items; $processor->preprocessIndexItems($tmp); $this->assertEqual($tmp[1]['name']['value'], $processed2, 'Value was correctly tokenized with custom settings.'); $query = new SearchApiQuery($this->index, array('parse mode' => 'direct')); $query->keys("foo \"bar-baz\" \n\t foobar1"); $processor->preprocessSearchQuery($query); $this->assertEqual($query->getKeys(), 'foo"b r b z"foob r1', 'Search keys were processed correctly.'); } /** * Tests the functionality of the "HTML filter" processor. */ protected function checkHtmlFilter() { $orig = <<a test. How to write links to other sites: <a href="URL" title="MOUSEOVER TEXT">TEXT</a>. < signs can be escaped with "&lt;". someone's image END; $tags = << 'This', 'score' => 1), array('value' => 'is', 'score' => 1), array('value' => 'something', 'score' => 1.5), array('value' => 'a', 'score' => 1.5), array('value' => 'test', 'score' => 1.5), array('value' => 'How', 'score' => 1), array('value' => 'to', 'score' => 1), array('value' => 'write', 'score' => 1), array('value' => 'links', 'score' => 2), array('value' => 'to', 'score' => 2), array('value' => 'other', 'score' => 3), array('value' => 'sites', 'score' => 3), array('value' => ' 1), array('value' => 'href="URL"', 'score' => 1), array('value' => 'title="MOUSEOVER', 'score' => 1), array('value' => 'TEXT">TEXT', 'score' => 1), array('value' => '<', 'score' => 1), array('value' => 'signs', 'score' => 1), array('value' => 'can', 'score' => 1), array('value' => 'be', 'score' => 1), array('value' => 'HTML', 'score' => 1), array('value' => '"escapes"', 'score' => 1), array('value' => 'escaped', 'score' => 1), array('value' => 'with', 'score' => 1), array('value' => '"<"', 'score' => 1), array('value' => 'someone\'s', 'score' => 1), array('value' => 'image', 'score' => 1), ); $items = array( 1 => array( 'name' => array( 'type' => 'text', 'original_type' => 'text', 'value' => $orig, ), 'search_api_language' => array( 'type' => 'string', 'original_type' => 'string', 'value' => LANGUAGE_NONE, ), ), ); $tmp = $items; $processor = new SearchApiHtmlFilter($this->index, array('fields' => array('name' => 'name'), 'title' => TRUE, 'alt' => TRUE, 'tags' => $tags)); $processor->preprocessIndexItems($tmp); $processor = new SearchApiTokenizer($this->index, array('fields' => array('name' => 'name'), 'spaces' => '[\s.:]', 'ignorable' => '')); $processor->preprocessIndexItems($tmp); $this->assertEqual($tmp[1]['name']['value'], $processed1, 'Text was correctly processed.'); } }