Bug 22413: Improve query string and desc creation for Elasticsearch
[koha.git] / t / db_dependent / Koha / SearchEngine / Elasticsearch / QueryBuilder.t
1 #!/usr/bin/perl
2 #
3 # This file is part of Koha.
4 #
5 # Koha is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # Koha is distributed in the hope that it will be useful, but
11 # WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with Koha; if not, see <http://www.gnu.org/licenses>.
17
18 use Modern::Perl;
19
20 use C4::Context;
21 use Test::Exception;
22 use t::lib::Mocks;
23 use t::lib::TestBuilder;
24 use Test::More tests => 6;
25
26 use Koha::Database;
27 use Koha::SearchEngine::Elasticsearch::QueryBuilder;
28
29 my $schema = Koha::Database->new->schema;
30 $schema->storage->txn_begin;
31
32 my $se = Test::MockModule->new( 'Koha::SearchEngine::Elasticsearch' );
33 $se->mock( 'get_elasticsearch_mappings', sub {
34     my ($self) = @_;
35
36     my %all_mappings;
37
38     my $mappings = {
39         data => {
40             properties => {
41                 title => {
42                     type => 'text'
43                 },
44                 title__sort => {
45                     type => 'text'
46                 },
47                 subject => {
48                     type => 'text'
49                 },
50                 itemnumber => {
51                     type => 'integer'
52                 },
53                 sortablenumber => {
54                     type => 'integer'
55                 },
56                 sortablenumber__sort => {
57                     type => 'integer'
58                 },
59                 Heading => {
60                     type => 'text'
61                 },
62                 Heading__sort => {
63                     type => 'text'
64                 }
65             }
66         }
67     };
68     $all_mappings{$self->index} = $mappings;
69
70     my $sort_fields = {
71         $self->index => {
72             title => 1,
73             subject => 0,
74             itemnumber => 0,
75             sortablenumber => 1,
76             mainentry => 1
77         }
78     };
79     $self->sort_fields($sort_fields->{$self->index});
80
81     return $all_mappings{$self->index};
82 });
83
84 subtest 'build_authorities_query_compat() tests' => sub {
85     plan tests => 36;
86
87     my $qb;
88
89     ok(
90         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'authorities' }),
91         'Creating new query builder object for authorities'
92     );
93
94     my $koha_to_index_name = $Koha::SearchEngine::Elasticsearch::QueryBuilder::koha_to_index_name;
95     my $search_term = 'a';
96     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
97         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
98         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
99             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
100                 "a*");
101         } else {
102             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
103                 "a*");
104         }
105     }
106
107     $search_term = 'Donald Duck';
108     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
109         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
110         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
111             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
112                 "(Donald*) AND (Duck*)");
113         } else {
114             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
115                 "(Donald*) AND (Duck*)");
116         }
117     }
118
119     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
120         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['is'], [$search_term], 'AUTH_TYPE', 'asc' );
121         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
122             is( $query->{query}->{bool}->{must}[0]->{match_phrase}->{"_all.phrase"},
123                 "donald duck");
124         } else {
125             is( $query->{query}->{bool}->{must}[0]->{match_phrase}->{$koha_to_index_name->{$koha_name}.".phrase"},
126                 "donald duck");
127         }
128     }
129
130     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
131         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'asc' );
132         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
133             is( $query->{query}->{bool}->{must}[0]->{match_phrase_prefix}->{"_all.phrase"},
134                 "donald duck");
135         } else {
136             is( $query->{query}->{bool}->{must}[0]->{match_phrase_prefix}->{$koha_to_index_name->{$koha_name}.".phrase"},
137                 "donald duck");
138         }
139     }
140
141     # Sorting
142     my $query = $qb->build_authorities_query_compat( [ 'mainentry' ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'HeadingAsc' );
143     is_deeply(
144         $query->{sort},
145         [
146             {
147                 'heading__sort' => 'asc'
148             }
149         ],
150         "ascending sort parameter properly formed"
151     );
152     $query = $qb->build_authorities_query_compat( [ 'mainentry' ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'HeadingDsc' );
153     is_deeply(
154         $query->{sort},
155         [
156             {
157                 'heading__sort' => 'desc'
158             }
159         ],
160         "descending sort parameter properly formed"
161     );
162
163     # Failing case
164     throws_ok {
165         $qb->build_authorities_query_compat( [ 'tomas' ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
166     }
167     'Koha::Exceptions::WrongParameter',
168         'Exception thrown on invalid value in the marclist param';
169 };
170
171 subtest 'build_query tests' => sub {
172     plan tests => 33;
173
174     my $qb;
175
176     ok(
177         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
178         'Creating new query builder object for biblios'
179     );
180
181     my @sort_by = 'title_asc';
182     my @sort_params = $qb->_convert_sort_fields(@sort_by);
183     my %options;
184     $options{sort} = \@sort_params;
185     my $query = $qb->build_query('test', %options);
186
187     is_deeply(
188         $query->{sort},
189         [
190             {
191             'title__sort.phrase' => {
192                     'order' => 'asc'
193                 }
194             }
195         ],
196         "sort parameter properly formed"
197     );
198
199     t::lib::Mocks::mock_preference('DisplayLibraryFacets','both');
200     $query = $qb->build_query();
201     ok( defined $query->{aggregations}{homebranch},
202         'homebranch added to facets if DisplayLibraryFacets=both' );
203     ok( defined $query->{aggregations}{holdingbranch},
204         'holdingbranch added to facets if DisplayLibraryFacets=both' );
205     t::lib::Mocks::mock_preference('DisplayLibraryFacets','holding');
206     $query = $qb->build_query();
207     ok( !defined $query->{aggregations}{homebranch},
208         'homebranch not added to facets if DisplayLibraryFacets=holding' );
209     ok( defined $query->{aggregations}{holdingbranch},
210         'holdingbranch added to facets if DisplayLibraryFacets=holding' );
211     t::lib::Mocks::mock_preference('DisplayLibraryFacets','home');
212     $query = $qb->build_query();
213     ok( defined $query->{aggregations}{homebranch},
214         'homebranch added to facets if DisplayLibraryFacets=home' );
215     ok( !defined $query->{aggregations}{holdingbranch},
216         'holdingbranch not added to facets if DisplayLibraryFacets=home' );
217
218     t::lib::Mocks::mock_preference( 'QueryAutoTruncate', '' );
219
220     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'] );
221     is(
222         $query->{query}{query_string}{query},
223         "(donald duck)",
224         "query not altered if QueryAutoTruncate disabled"
225     );
226
227     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'], ['title'] );
228     is(
229         $query->{query}{query_string}{query},
230         '(title:(donald duck))',
231         'multiple words in a query term are enclosed in parenthesis'
232     );
233
234     ( undef, $query ) = $qb->build_query_compat( ['AND'], ['donald duck', 'disney'], ['title', 'author'] );
235     is(
236         $query->{query}{query_string}{query},
237         '(title:(donald duck)) AND (author:disney)',
238         'multiple query terms are enclosed in parenthesis while a single one is not'
239     );
240
241     my ($simple_query, $query_cgi, $query_desc);
242     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['"donald duck"', 'walt disney'], ['ti', 'au'] );
243     is($query_cgi, 'idx=ti&q=%22donald%20duck%22&idx=au&q=walt%20disney', 'query cgi ok for multiterm query');
244     is($query_desc, '(title:("donald duck")) (author:(walt disney))', 'query desc ok for multiterm query');
245
246     t::lib::Mocks::mock_preference( 'QueryAutoTruncate', '1' );
247
248     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'] );
249     is(
250         $query->{query}{query_string}{query},
251         "(donald* duck*)",
252         "simple query is auto truncated when QueryAutoTruncate enabled"
253     );
254
255     # Ensure reserved words are not truncated
256     ( undef, $query ) = $qb->build_query_compat( undef,
257         ['donald or duck and mickey not mouse'] );
258     is(
259         $query->{query}{query_string}{query},
260         "(donald* or duck* and mickey* not mouse*)",
261         "reserved words are not affected by QueryAutoTruncate"
262     );
263
264     ( undef, $query ) = $qb->build_query_compat( undef, ['donald* duck*'] );
265     is(
266         $query->{query}{query_string}{query},
267         "(donald* duck*)",
268         "query with '*' is unaltered when QueryAutoTruncate is enabled"
269     );
270
271     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck and the mouse'] );
272     is(
273         $query->{query}{query_string}{query},
274         "(donald* duck* and the* mouse*)",
275         "individual words are all truncated and stopwords ignored"
276     );
277
278     ( undef, $query ) = $qb->build_query_compat( undef, ['*'] );
279     is(
280         $query->{query}{query_string}{query},
281         "(*)",
282         "query of just '*' is unaltered when QueryAutoTruncate is enabled"
283     );
284
285     ( undef, $query ) = $qb->build_query_compat( undef, ['"donald duck"'] );
286     is(
287         $query->{query}{query_string}{query},
288         '("donald duck")',
289         "query with quotes is unaltered when QueryAutoTruncate is enabled"
290     );
291
292
293     ( undef, $query ) = $qb->build_query_compat( undef, ['"donald duck" and "the mouse"'] );
294     is(
295         $query->{query}{query_string}{query},
296         '("donald duck" and "the mouse")',
297         "all quoted strings are unaltered if more than one in query"
298     );
299
300     ( undef, $query ) = $qb->build_query_compat( undef, ['barcode:123456'] );
301     is(
302         $query->{query}{query_string}{query},
303         '(barcode:123456*)',
304         "query of specific field is truncated"
305     );
306
307     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number:"123456"'] );
308     is(
309         $query->{query}{query_string}{query},
310         '(local-number:"123456")',
311         "query of specific field including hyphen and quoted is not truncated, field name is converted to lower case"
312     );
313
314     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number:123456'] );
315     is(
316         $query->{query}{query_string}{query},
317         '(local-number:123456*)',
318         "query of specific field including hyphen and not quoted is truncated, field name is converted to lower case"
319     );
320
321     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number.raw:123456'] );
322     is(
323         $query->{query}{query_string}{query},
324         '(local-number.raw:123456*)',
325         "query of specific field including period and not quoted is truncated, field name is converted to lower case"
326     );
327
328     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number.raw:"123456"'] );
329     is(
330         $query->{query}{query_string}{query},
331         '(local-number.raw:"123456")',
332         "query of specific field including period and quoted is not truncated, field name is converted to lower case"
333     );
334
335     ( undef, $query ) = $qb->build_query_compat( undef, ['J.R.R'] );
336     is(
337         $query->{query}{query_string}{query},
338         '(J.R.R*)',
339         "query including period is truncated but not split at periods"
340     );
341
342     ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'] );
343     is(
344         $query->{query}{query_string}{query},
345         '(title:"donald duck")',
346         "query of specific field is not truncated when surrounded by quotes"
347     );
348
349     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'], ['title'] );
350     is(
351         $query->{query}{query_string}{query},
352         '(title:(donald* duck*))',
353         'words of a multi-word term are properly truncated'
354     );
355
356     ( undef, $query ) = $qb->build_query_compat( ['AND'], ['donald duck', 'disney'], ['title', 'author'] );
357     is(
358         $query->{query}{query_string}{query},
359         '(title:(donald* duck*)) AND (author:disney*)',
360         'words of a multi-word term and single-word term are properly truncated'
361     );
362
363     ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef, undef, undef, undef, { suppress => 1 } );
364     is(
365         $query->{query}{query_string}{query},
366         '(title:"donald duck") AND suppress:0',
367         "query of specific field is added AND suppress:0"
368     );
369
370     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef, undef, undef, undef, { suppress => 0 } );
371     is(
372         $query->{query}{query_string}{query},
373         '(title:"donald duck")',
374         "query of specific field is not added AND suppress:0"
375     );
376     is($query_cgi, 'idx=&q=title%3A%22donald%20duck%22', 'query cgi');
377     is($query_desc, 'title:"donald duck"', 'query desc ok');
378 };
379
380
381 subtest 'build query from form subtests' => sub {
382     plan tests => 5;
383
384     my $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'authorities' }),
385     #when searching for authorities from a record the form returns marclist with blanks for unentered terms
386     my @marclist = ('mainmainentry','mainentry','match', 'all');
387     my @values   = ( undef,         'Hamilton',  undef,   undef);
388     my @operator = ( 'contains', 'contains', 'contains', 'contains');
389
390     my $query = $qb->build_authorities_query_compat( \@marclist, undef,
391                     undef, \@operator , \@values, 'AUTH_TYPE', 'asc' );
392     is($query->{query}->{bool}->{must}[0]->{query_string}->{query}, "Hamilton*","Expected search is populated");
393     is( scalar @{ $query->{query}->{bool}->{must} }, 1,"Only defined search is populated");
394
395     @values[2] = 'Jefferson';
396     $query = $qb->build_authorities_query_compat( \@marclist, undef,
397                     undef, \@operator , \@values, 'AUTH_TYPE', 'asc' );
398     is($query->{query}->{bool}->{must}[0]->{query_string}->{query}, "Hamilton*","First index searched as expected");
399     is($query->{query}->{bool}->{must}[1]->{query_string}->{query}, "Jefferson*","Second index searched when populated");
400     is( scalar @{ $query->{query}->{bool}->{must} }, 2,"Only defined searches are populated");
401
402
403 };
404
405 subtest 'build_query with weighted fields tests' => sub {
406     plan tests => 4;
407
408     my $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new( { index => 'mydb' } );
409     my $db_builder = t::lib::TestBuilder->new();
410
411     Koha::SearchFields->search({})->delete;
412
413     $db_builder->build({
414         source => 'SearchField',
415         value => {
416             name    => 'acqdate',
417             label   => 'acqdate',
418             weight  => undef
419         }
420     });
421
422     $db_builder->build({
423         source => 'SearchField',
424         value => {
425             name    => 'title',
426             label   => 'title',
427             weight  => 25
428         }
429     });
430
431     $db_builder->build({
432         source => 'SearchField',
433         value => {
434             name    => 'subject',
435             label   => 'subject',
436             weight  => 15
437         }
438     });
439
440     my ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef,
441     undef, undef, undef, { weighted_fields => 1 });
442
443     my $fields = $query->{query}{query_string}{fields};
444     is(scalar(@$fields), 3, 'Search is done on 3 fields');
445     is($fields->[0], '_all', 'First search field is _all');
446     is($fields->[1], 'title^25.00', 'Second search field is title');
447     is($fields->[2], 'subject^15.00', 'Third search field is subject');
448 };
449
450 subtest "_convert_sort_fields() tests" => sub {
451     plan tests => 3;
452
453     my $qb;
454
455     ok(
456         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
457         'Creating new query builder object for biblios'
458     );
459
460     my @sort_by = $qb->_convert_sort_fields(qw( call_number_asc author_dsc ));
461     is_deeply(
462         \@sort_by,
463         [
464             { field => 'local-classification', direction => 'asc' },
465             { field => 'author',  direction => 'desc' }
466         ],
467         'sort fields should have been split correctly'
468     );
469
470     # We could expect this to pass, but direction is undef instead of 'desc'
471     @sort_by = $qb->_convert_sort_fields(qw( call_number_asc author_desc ));
472     is_deeply(
473         \@sort_by,
474         [
475             { field => 'local-classification', direction => 'asc' },
476             { field => 'author',  direction => 'desc' }
477         ],
478         'sort fields should have been split correctly'
479     );
480 };
481
482 subtest "_sort_field() tests" => sub {
483     plan tests => 5;
484
485     my $qb;
486
487     ok(
488         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
489         'Creating new query builder object for biblios'
490     );
491
492     my $f = $qb->_sort_field('title');
493     is(
494         $f,
495         'title__sort.phrase',
496         'title sort mapped correctly'
497     );
498
499     $f = $qb->_sort_field('subject');
500     is(
501         $f,
502         'subject.raw',
503         'subject sort mapped correctly'
504     );
505
506     $f = $qb->_sort_field('itemnumber');
507     is(
508         $f,
509         'itemnumber',
510         'itemnumber sort mapped correctly'
511     );
512
513     $f = $qb->_sort_field('sortablenumber');
514     is(
515         $f,
516         'sortablenumber__sort',
517         'sortablenumber sort mapped correctly'
518     );
519 };
520
521 $schema->storage->txn_rollback;