Merge branch 'MDL-53643_master' of git://github.com/dmonllao/moodle
[moodle.git] / search / engine / solr / tests / engine_test.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Solr earch engine base unit tests.
19  *
20  * Required params:
21  * - define('TEST_SEARCH_SOLR_HOSTNAME', '127.0.0.1');
22  * - define('TEST_SEARCH_SOLR_PORT', '8983');
23  * - define('TEST_SEARCH_SOLR_INDEXNAME', 'unittest');
24  *
25  * Optional params:
26  * - define('TEST_SEARCH_SOLR_USERNAME', '');
27  * - define('TEST_SEARCH_SOLR_PASSWORD', '');
28  * - define('TEST_SEARCH_SOLR_SSLCERT', '');
29  * - define('TEST_SEARCH_SOLR_SSLKEY', '');
30  * - define('TEST_SEARCH_SOLR_KEYPASSWORD', '');
31  * - define('TEST_SEARCH_SOLR_CAINFOCERT', '');
32  *
33  * @package     core_search
34  * @category    phpunit
35  * @copyright   2015 David Monllao {@link http://www.davidmonllao.com}
36  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
37  */
39 defined('MOODLE_INTERNAL') || die();
41 global $CFG;
42 require_once($CFG->dirroot . '/search/tests/fixtures/testable_core_search.php');
43 require_once($CFG->dirroot . '/search/tests/fixtures/mock_search_area.php');
45 /**
46  * Solr search engine base unit tests.
47  *
48  * @package     core_search
49  * @category    phpunit
50  * @copyright   2015 David Monllao {@link http://www.davidmonllao.com}
51  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
52  */
53 class search_solr_engine_testcase extends advanced_testcase {
55     /**
56      * @var \core_search::manager
57      */
58     protected $search = null;
60     public function setUp() {
61         $this->resetAfterTest();
62         set_config('enableglobalsearch', true);
64         if (!function_exists('solr_get_version')) {
65             $this->markTestSkipped('Solr extension is not loaded.');
66         }
68         if (!defined('TEST_SEARCH_SOLR_HOSTNAME') || !defined('TEST_SEARCH_SOLR_INDEXNAME') ||
69                 !defined('TEST_SEARCH_SOLR_PORT')) {
70             $this->markTestSkipped('Solr extension test server not set.');
71         }
73         set_config('server_hostname', TEST_SEARCH_SOLR_HOSTNAME, 'search_solr');
74         set_config('server_port', TEST_SEARCH_SOLR_PORT, 'search_solr');
75         set_config('indexname', TEST_SEARCH_SOLR_INDEXNAME, 'search_solr');
77         if (defined('TEST_SEARCH_SOLR_USERNAME')) {
78             set_config('server_username', TEST_SEARCH_SOLR_USERNAME, 'search_solr');
79         }
81         if (defined('TEST_SEARCH_SOLR_PASSWORD')) {
82             set_config('server_password', TEST_SEARCH_SOLR_PASSWORD, 'search_solr');
83         }
85         if (defined('TEST_SEARCH_SOLR_SSLCERT')) {
86             set_config('secure', true, 'search_solr');
87             set_config('ssl_cert', TEST_SEARCH_SOLR_SSLCERT, 'search_solr');
88         }
90         if (defined('TEST_SEARCH_SOLR_SSLKEY')) {
91             set_config('ssl_key', TEST_SEARCH_SOLR_SSLKEY, 'search_solr');
92         }
94         if (defined('TEST_SEARCH_SOLR_KEYPASSWORD')) {
95             set_config('ssl_keypassword', TEST_SEARCH_SOLR_KEYPASSWORD, 'search_solr');
96         }
98         if (defined('TEST_SEARCH_SOLR_CAINFOCERT')) {
99             set_config('ssl_cainfo', TEST_SEARCH_SOLR_CAINFOCERT, 'search_solr');
100         }
102         set_config('fileindexing', 1, 'search_solr');
104         // We are only test indexing small string files, so setting this as low as we can.
105         set_config('maxindexfilekb', 1, 'search_solr');
107         // Inject search solr engine into the testable core search as we need to add the mock
108         // search component to it.
109         $searchengine = new \search_solr\engine();
110         $this->search = testable_core_search::instance($searchengine);
111         $areaid = \core_search\manager::generate_areaid('core_mocksearch', 'role_capabilities');
112         $this->search->add_search_area($areaid, new core_mocksearch\search\role_capabilities());
114         $this->setAdminUser();
116         // Cleanup before doing anything on it as the index it is out of this test control.
117         $this->search->delete_index();
119         // Add moodle fields if they don't exist.
120         $schema = new \search_solr\schema();
121         $schema->setup(false);
122     }
124     public function test_connection() {
125         $this->assertTrue($this->search->get_engine()->is_server_ready());
126     }
128     public function test_index() {
129         global $DB;
131         $noneditingteacherid = $DB->get_field('role', 'id', array('shortname' => 'teacher'));
133         // Data gets into the search engine.
134         $this->assertTrue($this->search->index());
136         // Not anymore as everything was already added.
137         sleep(1);
138         $this->assertFalse($this->search->index());
140         assign_capability('moodle/course:renameroles', CAP_ALLOW, $noneditingteacherid, context_system::instance()->id);
141         accesslib_clear_all_caches_for_unit_testing();
143         // Indexing again once there is new data.
144         $this->assertTrue($this->search->index());
145     }
147     /**
148      * Better keep this not very strict about which or how many results are returned as may depend on solr engine config.
149      *
150      * @return void
151      */
152     public function test_search() {
153         global $USER, $DB;
155         $noneditingteacherid = $DB->get_field('role', 'id', array('shortname' => 'teacher'));
157         $this->search->index();
159         $querydata = new stdClass();
160         $querydata->q = 'message';
161         $results = $this->search->search($querydata);
162         $this->assertCount(2, $results);
164         // Based on core_mocksearch\search\indexer.
165         $this->assertEquals($USER->id, $results[0]->get('userid'));
166         $this->assertEquals(\context_system::instance()->id, $results[0]->get('contextid'));
168         // Testing filters we don't purge cache in between assertions because cache key depends on the whole filters set
169         // and they are different.
170         sleep(1);
171         $beforeadding = time();
172         sleep(1);
173         assign_capability('moodle/course:renameroles', CAP_ALLOW, $noneditingteacherid, context_system::instance()->id);
174         accesslib_clear_all_caches_for_unit_testing();
175         $this->search->index();
177         // Timestart.
178         $querydata->timestart = $beforeadding;
179         $this->assertCount(1, $this->search->search($querydata));
181         // Timeend.
182         unset($querydata->timestart);
183         $querydata->timeend = $beforeadding;
184         $this->assertCount(2, $this->search->search($querydata));
186         // Title.
187         unset($querydata->timeend);
188         $querydata->title = 'moodle/course:renameroles roleid 1';
189         $this->assertCount(1, $this->search->search($querydata));
190     }
192     public function test_delete() {
193         $this->search->index();
195         $querydata = new stdClass();
196         $querydata->q = 'message';
198         $this->assertCount(2, $this->search->search($querydata));
200         $areaid = \core_search\manager::generate_areaid('core_mocksearch', 'role_capabilities');
201         $this->search->delete_index($areaid);
202         cache_helper::purge_by_definition('core', 'search_results');
203         $this->assertCount(0, $this->search->search($querydata));
204     }
206     public function test_alloweduserid() {
207         $engine = $this->search->get_engine();
208         $area = new core_mocksearch\search\role_capabilities();
210         // Get the first record for the recordset.
211         $recordset = $area->get_recordset_by_timestamp();
212         foreach ($recordset as $r) {
213             $record = $r;
214             break;
215         }
216         $recordset->close();
218         // Get the doc and insert the default doc.
219         $doc = $area->get_document($record);
220         $engine->add_document($doc);
222         $users = array();
223         $users[] = $this->getDataGenerator()->create_user();
224         $users[] = $this->getDataGenerator()->create_user();
225         $users[] = $this->getDataGenerator()->create_user();
227         // Add a record that only user 100 can see.
228         $originalid = $doc->get('id');
230         // Now add a custom doc for each user.
231         foreach ($users as $user) {
232             $doc = $area->get_document($record);
233             $doc->set('id', $originalid.'-'.$user->id);
234             $doc->set('owneruserid', $user->id);
235             $engine->add_document($doc);
236         }
238         $engine->area_index_complete($area->get_area_id());
240         $querydata = new stdClass();
241         $querydata->q = 'message';
242         $querydata->title = $doc->get('title');
244         // We are going to go through each user and see if they get the original and the owned doc.
245         foreach ($users as $user) {
246             $this->setUser($user);
248             $results = $this->search->search($querydata);
249             $this->assertCount(2, $results);
251             $owned = 0;
252             $notowned = 0;
254             // We don't know what order we will get the results in, so we are doing this.
255             foreach ($results as $result) {
256                 $owneruserid = $result->get('owneruserid');
257                 if (empty($owneruserid)) {
258                     $notowned++;
259                     $this->assertEquals(0, $owneruserid);
260                     $this->assertEquals($originalid, $result->get('id'));
261                 } else {
262                     $owned++;
263                     $this->assertEquals($user->id, $owneruserid);
264                     $this->assertEquals($originalid.'-'.$user->id, $result->get('id'));
265                 }
266             }
268             $this->assertEquals(1, $owned);
269             $this->assertEquals(1, $notowned);
270         }
272         // Now test a user with no owned results.
273         $otheruser = $this->getDataGenerator()->create_user();
274         $this->setUser($otheruser);
276         $results = $this->search->search($querydata);
277         $this->assertCount(1, $results);
279         $this->assertEquals(0, $results[0]->get('owneruserid'));
280         $this->assertEquals($originalid, $results[0]->get('id'));
281     }
283     public function test_highlight() {
284         global $PAGE;
286         $this->search->index();
288         $querydata = new stdClass();
289         $querydata->q = 'message';
291         $results = $this->search->search($querydata);
292         $this->assertCount(2, $results);
294         $result = reset($results);
296         $regex = '|'.\search_solr\engine::HIGHLIGHT_START.'message'.\search_solr\engine::HIGHLIGHT_END.'|';
297         $this->assertRegExp($regex, $result->get('content'));
299         $searchrenderer = $PAGE->get_renderer('core_search');
300         $exported = $result->export_for_template($searchrenderer);
302         $regex = '|<span class="highlight">message</span>|';
303         $this->assertRegExp($regex, $exported['content']);
304     }
306     public function test_index_file() {
307         // Very simple test.
308         $this->search->index();
309         $querydata = new stdClass();
310         $querydata->q = '"File contents"';
312         $this->assertCount(2, $this->search->search($querydata));
313     }
315     public function test_reindexing_files() {
316         // Get engine and area to work with.
317         $engine = $this->search->get_engine();
318         $areaid = \core_search\manager::generate_areaid('core_mocksearch', 'role_capabilities');
319         $area = \core_search\manager::get_search_area($areaid);
321         // Get a single record to make a doc from.
322         $recordset = $area->get_recordset_by_timestamp(0);
323         $record = $recordset->current();
324         $recordset->close();
326         $doc = $area->get_document($record);
328         // Now we are going to make some files.
329         $fs = get_file_storage();
330         $syscontext = \context_system::instance();
332         $files = array();
333         $filerecord = array(
334             'contextid' => $syscontext->id,
335             'component' => 'core',
336             'filearea'  => 'unittest',
337             'itemid'    => 0,
338             'filepath'  => '/',
339         );
341         // We make enough so that we pass the 500 files threashold. That is the boundary when getting files.
342         $boundary = 500;
343         $top = (int)($boundary * 1.1);
344         for ($i = 0; $i < $top; $i++) {
345             $filerecord['filename']  = 'searchfile'.$i;
346             $file = $fs->create_file_from_string($filerecord, 'Some FileContents'.$i);
347             $doc->add_stored_file($file);
348             $files[] = $file;
349         }
351         // Add the doc with lots of files, then commit.
352         $engine->add_document($doc, true);
353         $engine->area_index_complete($area->get_area_id());
355         // Indexes we are going to check. 0 means we will delete, 1 means we will keep.
356         $checkfiles = array(
357             0 => 0,                        // Check the begining of the set.
358             1 => 1,
359             2 => 0,
360             ($top - 3) => 0,               // Check the end of the set.
361             ($top - 2) => 1,
362             ($top - 1) => 0,
363             ($boundary - 2) => 0,          // Check at the boundary between fetch groups.
364             ($boundary - 1) => 0,
365             $boundary => 0,
366             ($boundary + 1) => 0,
367             ((int)($boundary * 0.5)) => 1, // Make sure we keep some middle ones.
368             ((int)($boundary * 1.05)) => 1
369         );
371         $querydata = new stdClass();
373         // First, check that all the files are currently there.
374         foreach ($checkfiles as $key => $unused) {
375             $querydata->q = 'FileContents'.$key;
376             $this->assertCount(1, $this->search->search($querydata));
377             $querydata->q = 'searchfile'.$key;
378             $this->assertCount(1, $this->search->search($querydata));
379         }
381         // Remove the files we want removed from the files array.
382         foreach ($checkfiles as $key => $keep) {
383             if (!$keep) {
384                 unset($files[$key]);
385             }
386         }
388         // And make us a new file to add.
389         $filerecord['filename']  = 'searchfileNew';
390         $files[] = $fs->create_file_from_string($filerecord, 'Some FileContentsNew');
391         $checkfiles['New'] = 1;
393         $doc = $area->get_document($record);
394         foreach($files as $file) {
395             $doc->add_stored_file($file);
396         }
398         // Reindex the document with the changed files.
399         $engine->add_document($doc, true);
400         $engine->area_index_complete($area->get_area_id());
401         cache_helper::purge_by_definition('core', 'search_results');
403         // Go through our check array, and see if the file is there or not.
404         foreach ($checkfiles as $key => $keep) {
405             $querydata->q = 'FileContents'.$key;
406             $this->assertCount($keep, $this->search->search($querydata));
407             $querydata->q = 'searchfile'.$key;
408             $this->assertCount($keep, $this->search->search($querydata));
409         }
411         // Now check that we get one result when we search from something in all of them.
412         $querydata->q = 'Some';
413         $this->assertCount(1, $this->search->search($querydata));
414     }
416     public function test_index_filtered_file() {
417         // Get engine and area to work with.
418         $engine = $this->search->get_engine();
419         $areaid = \core_search\manager::generate_areaid('core_mocksearch', 'role_capabilities');
420         $area = \core_search\manager::get_search_area($areaid);
422         // Get a single record to make a doc from.
423         $recordset = $area->get_recordset_by_timestamp(0);
424         $record = $recordset->current();
425         $recordset->close();
427         $doc = $area->get_document($record);
429         // Now we are going to make some files.
430         $fs = get_file_storage();
431         $syscontext = \context_system::instance();
433         $files = array();
434         $filerecord = array(
435             'contextid' => $syscontext->id,
436             'component' => 'core',
437             'filearea'  => 'unittest',
438             'itemid'    => 0,
439             'filepath'  => '/',
440             'filename'  => 'largefile'
441         );
443         // We need to make a file greater than 1kB in size, which is the lowest filter size.
444         $contents = 'Some LargeFindContent to find.';
445         for ($i = 0; $i < 200; $i++) {
446             $contents .= ' The quick brown fox jumps over the lazy dog.';
447         }
449         $this->assertGreaterThan(1024, strlen($contents));
451         $file = $fs->create_file_from_string($filerecord, $contents);
452         $doc->add_stored_file($file);
454         $filerecord['filename'] = 'smallfile';
455         $file = $fs->create_file_from_string($filerecord, 'Some SmallFindContent to find.');
456         $doc->add_stored_file($file);
458         $engine->add_document($doc, true);
459         $engine->area_index_complete($area->get_area_id());
461         $querydata = new stdClass();
462         // We shouldn't be able to find the large file contents.
463         $querydata->q = 'LargeFindContent';
464         $this->assertCount(0, $this->search->search($querydata));
466         // But we should be able to find the filename.
467         $querydata->q = 'largefile';
468         $this->assertCount(1, $this->search->search($querydata));
470         // We should be able to find the small file contents.
471         $querydata->q = 'SmallFindContent';
472         $this->assertCount(1, $this->search->search($querydata));
474         // And we should be able to find the filename.
475         $querydata->q = 'smallfile';
476         $this->assertCount(1, $this->search->search($querydata));
477     }
479     public function test_delete_by_id() {
480         // First get files in the index.
481         $this->search->index();
482         $engine = $this->search->get_engine();
484         $querydata = new stdClass();
486         // Then search to make sure they are there.
487         $querydata->q = '"File contents"';
488         $results = $this->search->search($querydata);
489         $this->assertCount(2, $results);
491         $first = reset($results);
492         $deleteid = $first->get('id');
494         $engine->delete_by_id($deleteid);
495         cache_helper::purge_by_definition('core', 'search_results');
497         // Check that we don't get a result for it anymore.
498         $results = $this->search->search($querydata);
499         $this->assertCount(1, $results);
500         $result = reset($results);
501         $this->assertNotEquals($deleteid, $result->get('id'));
502     }