thinking-sphinx 3.1.0 → 3.1.1

data/spec/acceptance/specifying_sql_spec.rb

@@ -175,7 +175,7 @@ describe 'separate queries for MVAs' do
     declaration, query = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s?$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVAs" do
@@ -191,7 +191,7 @@ describe 'separate queries for MVAs' do
     declaration, query = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "respects has_many :through joins for MVA queries" do
@@ -207,7 +207,7 @@ describe 'separate queries for MVAs' do
     declaration, query = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "can handle multiple joins for MVA queries" do
@@ -225,15 +225,10 @@ describe 'separate queries for MVAs' do
     declaration, query = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s?$/)
+    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.articles.\..user_id. IS NOT NULL\)\s?$/)
   end
 
-  it "can handle HABTM joins for MVA queries" do
-    pending "Efficient HABTM queries are tricky."
-    # We don't really have any need for other tables, but that doesn't lend
-    # itself nicely to Thinking Sphinx's DSL, nor ARel SQL generation. This is
-    # a low priority - manual SQL queries for this situation may work better.
-
+  it "can handle simple HABTM joins for MVA queries" do
     index = ThinkingSphinx::ActiveRecord::Index.new(:book)
     index.definition_block = Proc.new {
       indexes title
@@ -248,7 +243,7 @@ describe 'separate queries for MVAs' do
     declaration, query = attribute.split(/;\s+/)
 
     declaration.should == 'uint genre_ids from query'
-    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .genres.\..id. AS .genre_ids. FROM .books_genres. INNER JOIN .genres. ON .genres.\..id. = .books_genres.\..genre_id.\s?$/)
+    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres.\s?$/)
   end
 
   it "generates an appropriate range SQL queries for an MVA" do
@@ -264,7 +259,7 @@ describe 'separate queries for MVAs' do
     declaration, query, range = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\)$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
     range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
@@ -281,10 +276,29 @@ describe 'separate queries for MVAs' do
     declaration, query, range = attribute.split(/;\s+/)
 
     declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\)$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
     range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
+  it "can handle ranged queries for simple HABTM joins for MVA queries" do
+    index = ThinkingSphinx::ActiveRecord::Index.new(:book)
+    index.definition_block = Proc.new {
+      indexes title
+      has genres.id, :as => :genre_ids, :source => :ranged_query
+    }
+    index.render
+    source = index.sources.first
+
+    attribute = source.sql_attr_multi.detect { |attribute|
+      attribute[/genre_ids/]
+    }
+    declaration, query, range = attribute.split(/;\s+/)
+
+    declaration.should == 'uint genre_ids from ranged-query'
+    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres. WHERE \(.books_genres.\..book_id. BETWEEN \$start AND \$end\)$/)
+    range.should match(/^SELECT MIN\(.books_genres.\..book_id.\), MAX\(.books_genres.\..book_id.\) FROM .books_genres.$/)
+  end
+
   it "respects custom SQL snippets as the query value" do
     index.definition_block = Proc.new {
       indexes title
@@ -355,7 +369,7 @@ describe 'separate queries for field' do
     declaration, query = field.split(/;\s+/)
 
     declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "respects has_many :through joins for MVF queries" do
@@ -368,7 +382,7 @@ describe 'separate queries for field' do
     declaration, query = field.split(/;\s+/)
 
     declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "can handle multiple joins for MVF queries" do
@@ -383,7 +397,7 @@ describe 'separate queries for field' do
     declaration, query = field.split(/;\s+/)
 
     declaration.should == 'tags from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? ORDER BY .articles.\..user_id. ASC\s?$/)
+    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.articles.\..user_id. IS NOT NULL\)\s? ORDER BY .articles.\..user_id. ASC\s?$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVFs" do
@@ -396,7 +410,7 @@ describe 'separate queries for field' do
     declaration, query, range = field.split(/;\s+/)
 
     declaration.should == 'tags from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\)\s? ORDER BY .taggings.\..article_id. ASC$/)
+    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC$/)
     range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 

data/spec/internal/app/indices/car_index.rb

@@ -0,0 +1,5 @@
+ThinkingSphinx::Index.define :car, :with => :real_time do
+  indexes name, :sortable => true
+
+  has manufacturer_id, :type => :integer
+end

data/spec/internal/app/models/car.rb

@@ -0,0 +1,5 @@
+class Car < ActiveRecord::Base
+  belongs_to :manufacturer
+
+  after_save ThinkingSphinx::RealTime.callback_for(:car)
+end

data/spec/internal/app/models/category.rb

@@ -1,3 +1,4 @@
 class Category < ActiveRecord::Base
-  #
+  has_many :categorisations
+  has_many :products, :through => :categorisations
 end

data/spec/internal/app/models/manufacturer.rb

@@ -0,0 +1,3 @@
+class Manufacturer < ActiveRecord::Base
+  has_many :cars
+end

data/spec/internal/db/schema.rb

@@ -17,6 +17,15 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  create_table(:manufacturers, :force => true) do |t|
+    t.string  :name
+  end
+
+  create_table(:cars, :force => true) do |t|
+    t.integer :manufacturer_id
+    t.string  :name
+  end
+
   create_table(:books, :force => true) do |t|
     t.string  :title
     t.string  :author

data/spec/thinking_sphinx/active_record/attribute/type_spec.rb

@@ -4,6 +4,7 @@ module ThinkingSphinx
   end
 end
 
+require 'thinking_sphinx/errors'
 require 'thinking_sphinx/active_record/attribute/type'
 
 describe ThinkingSphinx::ActiveRecord::Attribute::Type do
@@ -143,5 +144,11 @@ describe ThinkingSphinx::ActiveRecord::Attribute::Type do
 
       type.type.should == :timestamp
     end
+
+    it 'raises an error if the database column does not exist' do
+      model.columns.clear
+
+      expect { type.type }.to raise_error(ThinkingSphinx::MissingColumnError)
+    end
   end
 end

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -48,6 +48,12 @@ describe ThinkingSphinx::ActiveRecord::Base do
   end
 
   describe '.search' do
+    let(:stack) { double('stack', :call => true) }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Middlewares::DEFAULT', stack
+    end
+
     it "returns a new search object" do
       model.search.should be_a(ThinkingSphinx::Search)
     end
@@ -60,6 +66,17 @@ describe ThinkingSphinx::ActiveRecord::Base do
       model.search('pancakes').options[:classes].should == [model]
     end
 
+    it "passes through options to the search object" do
+      model.search('pancakes', populate: true).
+        options[:populate].should be_true
+    end
+
+    it "should automatically populate when :populate is set to true" do
+      stack.should_receive(:call).and_return(true)
+
+      model.search('pancakes', populate: true)
+    end
+
     it "merges the :classes option with the model" do
       model.search('pancakes', :classes => [sub_model]).
         options[:classes].should == [sub_model, model]

data/spec/thinking_sphinx/active_record/callbacks/update_callbacks_spec.rb

@@ -20,7 +20,8 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
       :indices_for_references => [index]) }
     let(:connection)    { double('connection', :execute => '') }
     let(:index)         { double 'index', :name => 'article_core',
-      :sources => [source], :document_id_for_key => 3, :distributed? => false }
+      :sources => [source], :document_id_for_key => 3, :distributed? => false,
+      :type => 'plain'}
     let(:source)        { double('source', :attributes => []) }
 
     before :each do

data/spec/thinking_sphinx/configuration_spec.rb

@@ -128,6 +128,10 @@ describe ThinkingSphinx::Configuration do
   end
 
   describe '#initialize' do
+    before :each do
+      FileUtils.rm_rf Rails.root.join('log')
+    end
+
     it "sets the daemon pid file within log for the Rails app" do
       config.searchd.pid_file.
         should == File.join(Rails.root, 'log', 'test.sphinx.pid')
@@ -154,6 +158,19 @@ describe ThinkingSphinx::Configuration do
 
       config.searchd.workers.should == 'none'
     end
+
+    it 'adds settings to indexer without common section' do
+      write_configuration 'lemmatizer_base' => 'foo'
+
+      expect(config.indexer.lemmatizer_base).to eq('foo')
+    end
+
+    it 'adds settings to common section if requested' do
+      write_configuration 'lemmatizer_base' => 'foo',
+        'common_sphinx_configuration' => true
+
+      expect(config.common.lemmatizer_base).to eq('foo')
+    end
   end
 
   describe '#next_offset' do
@@ -176,6 +193,13 @@ describe ThinkingSphinx::Configuration do
   end
 
   describe '#preload_indices' do
+    let(:distributor) { double :reconcile => true }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Configuration::DistributedIndices',
+        double(:new => distributor)
+    end
+
     it "searches each index path for ruby files" do
       config.index_paths.replace ['/path/to/indices', '/path/to/other/indices']
 
@@ -217,6 +241,20 @@ describe ThinkingSphinx::Configuration do
       config.preload_indices
       config.preload_indices
     end
+
+    it 'adds distributed indices' do
+      distributor.should_receive(:reconcile)
+
+      config.preload_indices
+    end
+
+    it 'does not add distributed indices if disabled' do
+      write_configuration('distributed_indices' => false)
+
+      distributor.should_not_receive(:reconcile)
+
+      config.preload_indices
+    end
   end
 
   describe '#render' do
@@ -373,8 +411,8 @@ describe ThinkingSphinx::Configuration do
   end
 
   describe '#version' do
-    it "defaults to 2.0.6" do
-      config.version.should == '2.0.6'
+    it "defaults to 2.1.4" do
+      config.version.should == '2.1.4'
     end
 
     it "respects supplied YAML versions" do

data/spec/thinking_sphinx/errors_spec.rb

@@ -33,6 +33,27 @@ describe ThinkingSphinx::SphinxError do
         should be_a(ThinkingSphinx::ConnectionError)
     end
 
+    it 'prefixes the connection error message' do
+      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+
+      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
+        should == "Error connecting to Sphinx via the MySQL protocol. Can't connect to MySQL server on '127.0.0.1' (61)"
+    end
+
+    it "translates jdbc connection errors" do
+      error.stub :message => "Communications link failure"
+
+      ThinkingSphinx::SphinxError.new_from_mysql(error).
+        should be_a(ThinkingSphinx::ConnectionError)
+    end
+
+    it 'prefixes the jdbc connection error message' do
+      error.stub :message => "Communications link failure"
+
+      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
+        should == "Error connecting to Sphinx via the MySQL protocol. Communications link failure"
+    end
+
     it "defaults to sphinx errors" do
       error.stub :message => 'index foo: unknown error: something is wrong'
 

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -26,12 +26,12 @@ describe ThinkingSphinx::FacetSearch do
   DumbSearch = ::Struct.new(:query, :options) do
     def raw
       [{
-        'sphinx_internal_class'           => 'Foo',
-        'price_bracket'                   => 3,
-        'tag_ids'                         => '1,2',
-        'category_id'                     => 11,
-        ThinkingSphinx::SphinxQL.count    => 5,
-        ThinkingSphinx::SphinxQL.group_by => 2
+        'sphinx_internal_class' => 'Foo',
+        'price_bracket'         => 3,
+        'tag_ids'               => '1,2',
+        'category_id'           => 11,
+        'sphinx_internal_count' => 5,
+        'sphinx_internal_group' => 2
       }]
     end
   end

data/spec/thinking_sphinx/middlewares/inquirer_spec.rb

@@ -15,10 +15,6 @@ describe ThinkingSphinx::Middlewares::Inquirer do
     :results => [[:raw], [{'Variable_name' => 'meta', 'Value' => 'value'}]]) }
 
   before :each do
-    context.stub(:log) do |notification, message, &block|
-      block.call unless block.nil?
-    end
-
     batch_class = double
     batch_class.stub(:new).and_return(batch_inquirer)
 

data/spec/thinking_sphinx/middlewares/sphinxql_spec.rb

@@ -6,6 +6,9 @@ module ActiveRecord
   class Base; end
 end
 
+class SphinxQLSubclass
+end
+
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
@@ -185,6 +188,28 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
       middleware.call [context]
     end
 
+    it "ignores blank subclasses" do
+      db_connection = double('db connection', :select_values => [''],
+        :schema_cache => double('cache', :table_exists? => false))
+      supermodel = Class.new(ActiveRecord::Base) do
+        def self.name; 'Cat'; end
+        def self.inheritance_column; 'type'; end
+      end
+      supermodel.stub :connection => db_connection, :column_names => ['type']
+      submodel   = Class.new(supermodel) do
+        def self.name; 'Lion'; end
+        def self.inheritance_column; 'type'; end
+        def self.table_name; 'cats'; end
+      end
+      submodel.stub :connection => db_connection, :column_names => ['type'],
+        :descendants => []
+      index_set.first.stub :reference => :cat
+
+      search.options[:classes] = [submodel]
+
+      expect { middleware.call [context] }.to_not raise_error
+    end
+
     it "filters out deleted values by default" do
       sphinx_sql.should_receive(:where).with(:sphinx_deleted => false).
         and_return(sphinx_sql)

data/spec/thinking_sphinx/middlewares/stale_id_filter_spec.rb

@@ -15,7 +15,7 @@ describe ThinkingSphinx::Middlewares::StaleIdFilter do
 
   describe '#call' do
     before :each do
-      context.stub :search => search, :log => true
+      context.stub :search => search
     end
 
     context 'one stale ids exception' do
@@ -88,4 +88,4 @@ describe ThinkingSphinx::Middlewares::StaleIdFilter do
       end
     end
   end
-end
+end

data/spec/thinking_sphinx/real_time/callbacks/real_time_callbacks_spec.rb

@@ -5,7 +5,8 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
     ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new :article
   }
   let(:instance)   { double('instance', :id => 12) }
-  let(:config)     { double('config', :indices_for_references => [index]) }
+  let(:config)     { double('config', :indices_for_references => [index],
+    :settings => {}) }
   let(:index)      { double('index', :name => 'my_index', :is_a? => true,
     :document_id_for_key => 123, :fields => [], :attributes => [],
     :conditions => []) }

data/spec/thinking_sphinx/search_spec.rb

@@ -5,6 +5,34 @@ describe ThinkingSphinx::Search do
   let(:context)       { {:results => []} }
   let(:stack)         { double('stack', :call => true) }
 
+  let(:pagination_mask_methods) do
+    [:first_page?,
+     :last_page?,
+     :next_page,
+     :next_page?,
+     :page,
+     :per,
+     :previous_page,
+     :total_entries,
+     :total_count,
+     :count,
+     :total_pages,
+     :page_count,
+     :num_pages]
+  end
+
+  let(:scopes_mask_methods) do
+    [:facets,
+     :search,
+     :search_for_ids]
+  end
+
+  let(:group_enumerator_mask_methods) do
+    [:each_with_count,
+     :each_with_group,
+     :each_with_group_and_count]
+  end
+
   before :each do
     ThinkingSphinx::Search::Context.stub :new => context
 
@@ -141,6 +169,24 @@ describe ThinkingSphinx::Search do
     it "should respond to Search methods" do
       search.respond_to?(:per_page).should be_true
     end
+
+    it "should return true for methods delegated to pagination mask by method_missing" do
+      pagination_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
+
+    it "should return true for methods delegated to scopes mask by method_missing" do
+      scopes_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
+
+    it "should return true for methods delegated to group enumerators mask by method_missing" do
+      group_enumerator_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
   end
 
   describe '#to_a' do
@@ -153,4 +199,14 @@ describe ThinkingSphinx::Search do
       search.to_a.first.__id__.should == unglazed.__id__
     end
   end
+
+  it "correctly handles access to methods delegated to masks through 'method' call" do
+    [
+      pagination_mask_methods,
+      scopes_mask_methods,
+      group_enumerator_mask_methods
+    ].flatten.each do |method|
+      expect { search.method method }.to_not raise_exception
+    end
+  end
 end