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 List::Util qw( all );
  27
  28 use Koha::Database;
  29 use Koha::SearchEngine::Elasticsearch::QueryBuilder;
  30
  31 my $schema = Koha::Database->new->schema;
  32 $schema->storage->txn_begin;
  33
  34 my $se = Test::MockModule->new( 'Koha::SearchEngine::Elasticsearch' );
  35 $se->mock( 'get_elasticsearch_mappings', sub {
  36     my ($self) = @_;
  37
  38     my %all_mappings;
  39
  40     my $mappings = {
  41         data => {
  42             properties => {
  43                 title => {
  44                     type => 'text'
  45                 },
  46                 title__sort => {
  47                     type => 'text'
  48                 },
  49                 subject => {
  50                     type => 'text',
  51                     facet => 1
  52                 },
  53                 itemnumber => {
  54                     type => 'integer'
  55                 },
  56                 sortablenumber => {
  57                     type => 'integer'
  58                 },
  59                 sortablenumber__sort => {
  60                     type => 'integer'
  61                 },
  62                 Heading => {
  63                     type => 'text'
  64                 },
  65                 Heading__sort => {
  66                     type => 'text'
  67                 }
  68             }
  69         }
  70     };
  71     $all_mappings{$self->index} = $mappings;
  72
  73     my $sort_fields = {
  74         $self->index => {
  75             title => 1,
  76             subject => 0,
  77             itemnumber => 0,
  78             sortablenumber => 1,
  79             mainentry => 1
  80         }
  81     };
  82     $self->sort_fields($sort_fields->{$self->index});
  83
  84     return $all_mappings{$self->index};
  85 });
  86
  87 my $cache = Koha::Caches->get_instance();
  88 my $clear_search_fields_cache = sub {
  89     $cache->clear_from_cache('elasticsearch_search_fields_staff_client');
  90     $cache->clear_from_cache('elasticsearch_search_fields_opac');
  91 };
  92
  93 subtest 'build_authorities_query_compat() tests' => sub {
  94     plan tests => 55;
  95
  96     my $qb;
  97
  98     ok(
  99         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'authorities' }),
 100         'Creating new query builder object for authorities'
 101     );
 102
 103     my $koha_to_index_name = $Koha::SearchEngine::Elasticsearch::QueryBuilder::koha_to_index_name;
 104     my $search_term = 'a';
 105     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
 106         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
 107         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
 108             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
 109                 "a*");
 110         } else {
 111             is( $query->{query}->{bool}->{must}[0]->{query_string}->{query},
 112                 "a*");
 113         }
 114         is( $query->{query}->{bool}->{must}[0]->{query_string}->{analyze_wildcard}, JSON::true, 'Set analyze_wildcard true' );
 115     }
 116
 117     $search_term = 'Donald Duck';
 118     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
 119         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
 120         is( $query->{query}->{bool}->{must}[0]->{query_string}->{query}, "(Donald*) AND (Duck*)" );
 121         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
 122             isa_ok( $query->{query}->{bool}->{must}[0]->{query_string}->{fields}, 'ARRAY')
 123         } else {
 124             is( $query->{query}->{bool}->{must}[0]->{query_string}->{default_field}, $koha_to_index_name->{$koha_name} );
 125         }
 126     }
 127
 128     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
 129         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['is'], [$search_term], 'AUTH_TYPE', 'asc' );
 130         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
 131             is(
 132                 $query->{query}->{bool}->{must}[0]->{multi_match}->{query},
 133                 "Donald Duck"
 134             );
 135             my $all_matches = all { /\.ci_raw$/ }
 136                 @{$query->{query}->{bool}->{must}[0]->{multi_match}->{fields}};
 137             ok( $all_matches, 'Correct fields parameter for "is" query in "any" or "all"' );
 138         } else {
 139             is(
 140                 $query->{query}->{bool}->{must}[0]->{term}->{$koha_to_index_name->{$koha_name} . ".ci_raw"},
 141                 "Donald Duck"
 142             );
 143         }
 144     }
 145
 146     foreach my $koha_name ( keys %{ $koha_to_index_name } ) {
 147         my $query = $qb->build_authorities_query_compat( [ $koha_name ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'asc' );
 148         if ( $koha_name eq 'all' || $koha_name eq 'any' ) {
 149             my $all_matches = all { (%{$_->{prefix}})[0] =~ /\.ci_raw$/ && (%{$_->{prefix}})[1] eq "Donald Duck" }
 150                 @{$query->{query}->{bool}->{must}[0]->{bool}->{should}};
 151             ok( $all_matches, "Correct multiple prefix query" );
 152         } else {
 153             is( $query->{query}->{bool}->{must}[0]->{prefix}->{$koha_to_index_name->{$koha_name} . ".ci_raw"}, "Donald Duck" );
 154         }
 155     }
 156
 157     # Sorting
 158     my $query = $qb->build_authorities_query_compat( [ 'mainentry' ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'HeadingAsc' );
 159     is_deeply(
 160         $query->{sort},
 161         [
 162             {
 163                 'heading__sort' => 'asc'
 164             }
 165         ],
 166         "ascending sort parameter properly formed"
 167     );
 168     $query = $qb->build_authorities_query_compat( [ 'mainentry' ],  undef, undef, ['start'], [$search_term], 'AUTH_TYPE', 'HeadingDsc' );
 169     is_deeply(
 170         $query->{sort},
 171         [
 172             {
 173                 'heading__sort' => 'desc'
 174             }
 175         ],
 176         "descending sort parameter properly formed"
 177     );
 178
 179     # Authorities type
 180     $query = $qb->build_authorities_query_compat( [ 'mainentry' ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
 181     is_deeply(
 182         $query->{query}->{bool}->{filter},
 183         { term => { 'authtype.raw' => 'AUTH_TYPE' } },
 184         "authorities type code is used as filter"
 185     );
 186
 187     # Failing case
 188     throws_ok {
 189         $qb->build_authorities_query_compat( [ 'tomas' ],  undef, undef, ['contains'], [$search_term], 'AUTH_TYPE', 'asc' );
 190     }
 191     'Koha::Exceptions::WrongParameter',
 192         'Exception thrown on invalid value in the marclist param';
 193 };
 194
 195 subtest 'build_query tests' => sub {
 196     plan tests => 48;
 197
 198     my $qb;
 199
 200     ok(
 201         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
 202         'Creating new query builder object for biblios'
 203     );
 204
 205     my @sort_by = 'title_asc';
 206     my @sort_params = $qb->_convert_sort_fields(@sort_by);
 207     my %options;
 208     $options{sort} = \@sort_params;
 209     my $query = $qb->build_query('test', %options);
 210
 211     is_deeply(
 212         $query->{sort},
 213         [
 214             {
 215             'title__sort' => {
 216                     'order' => 'asc'
 217                 }
 218             }
 219         ],
 220         "sort parameter properly formed"
 221     );
 222
 223     t::lib::Mocks::mock_preference('FacetMaxCount','37');
 224     $query = $qb->build_query('test', %options);
 225     ok( defined $query->{aggregations}{ccode}{terms}{size},'we need to ask for a size or we get only 5 facet' );
 226     is( $query->{aggregations}{ccode}{terms}{size}, 37,'we ask for the size as defined by the syspref FacetMaxCount');
 227
 228     t::lib::Mocks::mock_preference('DisplayLibraryFacets','both');
 229     $query = $qb->build_query();
 230     ok( defined $query->{aggregations}{homebranch},
 231         'homebranch added to facets if DisplayLibraryFacets=both' );
 232     ok( defined $query->{aggregations}{holdingbranch},
 233         'holdingbranch added to facets if DisplayLibraryFacets=both' );
 234     t::lib::Mocks::mock_preference('DisplayLibraryFacets','holding');
 235     $query = $qb->build_query();
 236     ok( !defined $query->{aggregations}{homebranch},
 237         'homebranch not added to facets if DisplayLibraryFacets=holding' );
 238     ok( defined $query->{aggregations}{holdingbranch},
 239         'holdingbranch added to facets if DisplayLibraryFacets=holding' );
 240     t::lib::Mocks::mock_preference('DisplayLibraryFacets','home');
 241     $query = $qb->build_query();
 242     ok( defined $query->{aggregations}{homebranch},
 243         'homebranch added to facets if DisplayLibraryFacets=home' );
 244     ok( !defined $query->{aggregations}{holdingbranch},
 245         'holdingbranch not added to facets if DisplayLibraryFacets=home' );
 246
 247     t::lib::Mocks::mock_preference( 'QueryAutoTruncate', '' );
 248
 249     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'] );
 250     is(
 251         $query->{query}{query_string}{query},
 252         "(donald duck)",
 253         "query not altered if QueryAutoTruncate disabled"
 254     );
 255
 256     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'], ['title'] );
 257     is(
 258         $query->{query}{query_string}{query},
 259         '(title:(donald duck))',
 260         'multiple words in a query term are enclosed in parenthesis'
 261     );
 262
 263     ( undef, $query ) = $qb->build_query_compat( ['AND'], ['donald duck', 'disney'], ['title', 'author'] );
 264     is(
 265         $query->{query}{query_string}{query},
 266         '(title:(donald duck)) AND (author:disney)',
 267         'multiple query terms are enclosed in parenthesis while a single one is not'
 268     );
 269
 270     my ($simple_query, $query_cgi, $query_desc);
 271     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['"donald duck"', 'walt disney'], ['ti', 'au'] );
 272     is($query_cgi, 'idx=ti&q=%22donald%20duck%22&idx=au&q=walt%20disney', 'query cgi ok for multiterm query');
 273     is($query_desc, '(title:("donald duck")) (author:(walt disney))', 'query desc ok for multiterm query');
 274
 275     ( undef, $query ) = $qb->build_query_compat( undef, ['2019'], ['yr,st-year'] );
 276     is(
 277         $query->{query}{query_string}{query},
 278         '(date-of-publication:2019)',
 279         'Year in an st-year search is handled properly'
 280     );
 281
 282     ( undef, $query ) = $qb->build_query_compat( undef, ['2018-2019'], ['yr,st-year'] );
 283     is(
 284         $query->{query}{query_string}{query},
 285         '(date-of-publication:[2018 TO 2019])',
 286         'Year range in an st-year search is handled properly'
 287     );
 288
 289     ( undef, $query ) = $qb->build_query_compat( undef, ['-2019'], ['yr,st-year'] );
 290     is(
 291         $query->{query}{query_string}{query},
 292         '(date-of-publication:[* TO 2019])',
 293         'Open start year in year range of an st-year search is handled properly'
 294     );
 295
 296     ( undef, $query ) = $qb->build_query_compat( undef, ['2019-'], ['yr,st-year'] );
 297     is(
 298         $query->{query}{query_string}{query},
 299         '(date-of-publication:[2019 TO *])',
 300         'Open end year in year range of an st-year search is handled properly'
 301     );
 302
 303     ( undef, $query ) = $qb->build_query_compat( undef, ['2019-'], ['yr,st-year'], ['yr,st-numeric=-2019'] );
 304     is(
 305         $query->{query}{query_string}{query},
 306         '(date-of-publication:[2019 TO *]) AND copydate:[* TO 2019]',
 307         'Open end year in year range of an st-year search is handled properly'
 308     );
 309
 310     # Enable auto-truncation
 311     t::lib::Mocks::mock_preference( 'QueryAutoTruncate', '1' );
 312
 313     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'] );
 314     is(
 315         $query->{query}{query_string}{query},
 316         "(donald* duck*)",
 317         "simple query is auto truncated when QueryAutoTruncate enabled"
 318     );
 319
 320     # Ensure reserved words are not truncated
 321     ( undef, $query ) = $qb->build_query_compat( undef,
 322         ['donald or duck and mickey not mouse'] );
 323     is(
 324         $query->{query}{query_string}{query},
 325         "(donald* or duck* and mickey* not mouse*)",
 326         "reserved words are not affected by QueryAutoTruncate"
 327     );
 328
 329     ( undef, $query ) = $qb->build_query_compat( undef, ['donald* duck*'] );
 330     is(
 331         $query->{query}{query_string}{query},
 332         "(donald* duck*)",
 333         "query with '*' is unaltered when QueryAutoTruncate is enabled"
 334     );
 335
 336     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck and the mouse'] );
 337     is(
 338         $query->{query}{query_string}{query},
 339         "(donald* duck* and the* mouse*)",
 340         "individual words are all truncated and stopwords ignored"
 341     );
 342
 343     ( undef, $query ) = $qb->build_query_compat( undef, ['*'] );
 344     is(
 345         $query->{query}{query_string}{query},
 346         "(*)",
 347         "query of just '*' is unaltered when QueryAutoTruncate is enabled"
 348     );
 349
 350     ( undef, $query ) = $qb->build_query_compat( undef, ['"donald duck"'], undef, ['available'] );
 351     is(
 352         $query->{query}{query_string}{query},
 353         '("donald duck") AND onloan:false',
 354         "query with quotes is unaltered when QueryAutoTruncate is enabled"
 355     );
 356
 357
 358     ( undef, $query ) = $qb->build_query_compat( undef, ['"donald duck" and "the mouse"'] );
 359     is(
 360         $query->{query}{query_string}{query},
 361         '("donald duck" and "the mouse")',
 362         "all quoted strings are unaltered if more than one in query"
 363     );
 364
 365     ( undef, $query ) = $qb->build_query_compat( undef, ['barcode:123456'] );
 366     is(
 367         $query->{query}{query_string}{query},
 368         '(barcode:123456*)',
 369         "query of specific field is truncated"
 370     );
 371
 372     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number:"123456"'] );
 373     is(
 374         $query->{query}{query_string}{query},
 375         '(local-number:"123456")',
 376         "query of specific field including hyphen and quoted is not truncated, field name is converted to lower case"
 377     );
 378
 379     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number:123456'] );
 380     is(
 381         $query->{query}{query_string}{query},
 382         '(local-number:123456*)',
 383         "query of specific field including hyphen and not quoted is truncated, field name is converted to lower case"
 384     );
 385
 386     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number.raw:123456'] );
 387     is(
 388         $query->{query}{query_string}{query},
 389         '(local-number.raw:123456*)',
 390         "query of specific field including period and not quoted is truncated, field name is converted to lower case"
 391     );
 392
 393     ( undef, $query ) = $qb->build_query_compat( undef, ['Local-number.raw:"123456"'] );
 394     is(
 395         $query->{query}{query_string}{query},
 396         '(local-number.raw:"123456")',
 397         "query of specific field including period and quoted is not truncated, field name is converted to lower case"
 398     );
 399
 400     ( undef, $query ) = $qb->build_query_compat( undef, ['J.R.R'] );
 401     is(
 402         $query->{query}{query_string}{query},
 403         '(J.R.R*)',
 404         "query including period is truncated but not split at periods"
 405     );
 406
 407     ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'] );
 408     is(
 409         $query->{query}{query_string}{query},
 410         '(title:"donald duck")',
 411         "query of specific field is not truncated when surrounded by quotes"
 412     );
 413
 414     ( undef, $query ) = $qb->build_query_compat( undef, ['donald duck'], ['title'] );
 415     is(
 416         $query->{query}{query_string}{query},
 417         '(title:(donald* duck*))',
 418         'words of a multi-word term are properly truncated'
 419     );
 420
 421     ( undef, $query ) = $qb->build_query_compat( ['AND'], ['donald duck', 'disney'], ['title', 'author'] );
 422     is(
 423         $query->{query}{query_string}{query},
 424         '(title:(donald* duck*)) AND (author:disney*)',
 425         'words of a multi-word term and single-word term are properly truncated'
 426     );
 427
 428     ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef, undef, undef, undef, { suppress => 1 } );
 429     is(
 430         $query->{query}{query_string}{query},
 431         '(title:"donald duck") AND suppress:0',
 432         "query of specific field is added AND suppress:0"
 433     );
 434
 435     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef, undef, undef, undef, { suppress => 0 } );
 436     is(
 437         $query->{query}{query_string}{query},
 438         '(title:"donald duck")',
 439         "query of specific field is not added AND suppress:0"
 440     );
 441     is($query_cgi, 'idx=&q=title%3A%22donald%20duck%22', 'query cgi');
 442     is($query_desc, 'title:"donald duck"', 'query desc ok');
 443
 444     # Scan queries
 445     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['new'], ['au'], undef, undef, 1 );
 446     is(
 447         $query->{query}{query_string}{query},
 448         '*',
 449         "scan query is properly formed"
 450     );
 451     is_deeply(
 452         $query->{aggregations}{'author'}{'terms'},
 453         {
 454             field => 'author__facet',
 455             order => { '_term' => 'asc' },
 456             include => '[nN][eE][wW].*'
 457         },
 458         "scan aggregation request is properly formed"
 459     );
 460     is($query_cgi, 'idx=au&q=new&scan=1', 'query cgi');
 461     is($query_desc, 'new', 'query desc ok');
 462
 463     ( undef, $query, $simple_query, $query_cgi, $query_desc ) = $qb->build_query_compat( undef, ['new'], [], undef, undef, 1 );
 464     is(
 465         $query->{query}{query_string}{query},
 466         '*',
 467         "scan query is properly formed"
 468     );
 469     is_deeply(
 470         $query->{aggregations}{'subject'}{'terms'},
 471         {
 472             field => 'subject__facet',
 473             order => { '_term' => 'asc' },
 474             include => '[nN][eE][wW].*'
 475         },
 476         "scan aggregation request is properly formed"
 477     );
 478     is($query_cgi, 'idx=&q=new&scan=1', 'query cgi');
 479     is($query_desc, 'new', 'query desc ok');
 480 };
 481
 482
 483 subtest 'build query from form subtests' => sub {
 484     plan tests => 5;
 485
 486     my $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'authorities' }),
 487     #when searching for authorities from a record the form returns marclist with blanks for unentered terms
 488     my @marclist = ('mainmainentry','mainentry','match', 'all');
 489     my @values   = ( undef,         'Hamilton',  undef,   undef);
 490     my @operator = ( 'contains', 'contains', 'contains', 'contains');
 491
 492     my $query = $qb->build_authorities_query_compat( \@marclist, undef,
 493                     undef, \@operator , \@values, 'AUTH_TYPE', 'asc' );
 494     is($query->{query}->{bool}->{must}[0]->{query_string}->{query}, "Hamilton*","Expected search is populated");
 495     is( scalar @{ $query->{query}->{bool}->{must} }, 1,"Only defined search is populated");
 496
 497     @values[2] = 'Jefferson';
 498     $query = $qb->build_authorities_query_compat( \@marclist, undef,
 499                     undef, \@operator , \@values, 'AUTH_TYPE', 'asc' );
 500     is($query->{query}->{bool}->{must}[0]->{query_string}->{query}, "Hamilton*","First index searched as expected");
 501     is($query->{query}->{bool}->{must}[1]->{query_string}->{query}, "Jefferson*","Second index searched when populated");
 502     is( scalar @{ $query->{query}->{bool}->{must} }, 2,"Only defined searches are populated");
 503
 504
 505 };
 506
 507 subtest 'build_query with weighted fields tests' => sub {
 508     plan tests => 4;
 509
 510     $se->mock( '_load_elasticsearch_mappings', sub {
 511         return {
 512             biblios => {
 513                 abstract => {
 514                     label => 'abstract',
 515                     type => 'string',
 516                     opac => 1,
 517                     staff_client => 0,
 518                     mappings => [{
 519                         marc_field => '520',
 520                         marc_type => 'marc21',
 521                     }]
 522                 },
 523                 acqdate => {
 524                     label => 'acqdate',
 525                     type => 'string',
 526                     opac => 0,
 527                     staff_client => 1,
 528                     mappings => [{
 529                         marc_field => '952d',
 530                         marc_type => 'marc21',
 531                         search => 0,
 532                     }, {
 533                         marc_field => '9955',
 534                         marc_type => 'marc21',
 535                         search => 0,
 536                     }]
 537                 },
 538                 title => {
 539                     label => 'title',
 540                     type => 'string',
 541                     opac => 0,
 542                     staff_client => 1,
 543                     mappings => [{
 544                         marc_field => '130',
 545                         marc_type => 'marc21'
 546                     }]
 547                 },
 548                 subject => {
 549                     label => 'subject',
 550                     type => 'string',
 551                     opac => 0,
 552                     staff_client => 1,
 553                     mappings => [{
 554                         marc_field => '600a',
 555                         marc_type => 'marc21'
 556                     }]
 557                 }
 558             }
 559         };
 560     });
 561
 562     my $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new( { index => 'biblios' } );
 563     Koha::SearchFields->search({})->delete;
 564     Koha::SearchEngine::Elasticsearch->reset_elasticsearch_mappings();
 565
 566     my $search_field;
 567     $search_field = Koha::SearchFields->find({ name => 'title' });
 568     $search_field->update({ weight => 25.0 });
 569     $search_field = Koha::SearchFields->find({ name => 'subject' });
 570     $search_field->update({ weight => 15.5 });
 571     $clear_search_fields_cache->();
 572
 573     my ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef,
 574     undef, undef, undef, { weighted_fields => 1 });
 575
 576     my $fields = $query->{query}{query_string}{fields};
 577
 578     is(@{$fields}, 2, 'Search field with no searchable mappings has been excluded');
 579
 580     my @found = grep { $_ eq 'title^25.00' } @{$fields};
 581     is(@found, 1, 'Search field title has correct weight');
 582
 583     @found = grep { $_ eq 'subject^15.50' } @{$fields};
 584     is(@found, 1, 'Search field subject has correct weight');
 585
 586     ( undef, $query ) = $qb->build_query_compat( undef, ['title:"donald duck"'], undef, undef,
 587     undef, undef, undef, { weighted_fields => 1, is_opac => 1 });
 588
 589     $fields = $query->{query}{query_string}{fields};
 590
 591     is_deeply(
 592         $fields,
 593         ['abstract'],
 594         'Only OPAC search fields are used when opac search is performed'
 595     );
 596 };
 597
 598 subtest "_convert_sort_fields() tests" => sub {
 599     plan tests => 3;
 600
 601     my $qb;
 602
 603     ok(
 604         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
 605         'Creating new query builder object for biblios'
 606     );
 607
 608     my @sort_by = $qb->_convert_sort_fields(qw( call_number_asc author_dsc ));
 609     is_deeply(
 610         \@sort_by,
 611         [
 612             { field => 'local-classification', direction => 'asc' },
 613             { field => 'author',  direction => 'desc' }
 614         ],
 615         'sort fields should have been split correctly'
 616     );
 617
 618     # We could expect this to pass, but direction is undef instead of 'desc'
 619     @sort_by = $qb->_convert_sort_fields(qw( call_number_asc author_desc ));
 620     is_deeply(
 621         \@sort_by,
 622         [
 623             { field => 'local-classification', direction => 'asc' },
 624             { field => 'author',  direction => 'desc' }
 625         ],
 626         'sort fields should have been split correctly'
 627     );
 628 };
 629
 630 subtest "_sort_field() tests" => sub {
 631     plan tests => 5;
 632
 633     my $qb;
 634
 635     ok(
 636         $qb = Koha::SearchEngine::Elasticsearch::QueryBuilder->new({ 'index' => 'biblios' }),
 637         'Creating new query builder object for biblios'
 638     );
 639
 640     my $f = $qb->_sort_field('title');
 641     is(
 642         $f,
 643         'title__sort',
 644         'title sort mapped correctly'
 645     );
 646
 647     $f = $qb->_sort_field('subject');
 648     is(
 649         $f,
 650         'subject.raw',
 651         'subject sort mapped correctly'
 652     );
 653
 654     $f = $qb->_sort_field('itemnumber');
 655     is(
 656         $f,
 657         'itemnumber',
 658         'itemnumber sort mapped correctly'
 659     );
 660
 661     $f = $qb->_sort_field('sortablenumber');
 662     is(
 663         $f,
 664         'sortablenumber__sort',
 665         'sortablenumber sort mapped correctly'
 666     );
 667 };
 668
 669 $schema->storage->txn_rollback;