thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/interfaces/sql_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::SQL do
+  let(:interface)     { ThinkingSphinx::Interfaces::SQL.new(
+    configuration, {:verbose => true}, stream
+  ) }
+  let(:commander) { double :call => true }
+  let(:configuration) { double 'configuration', :preload_indices => true,
+    :render => true, :indices => [double(:index, :type => 'plain')] }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Commander', commander
+  end
+
+  describe '#clear' do
+    let(:users_index) { double(:type => 'plain') }
+    let(:parts_index) { double(:type => 'plain') }
+    let(:rt_index)    { double(:type => 'rt') }
+
+    before :each do
+      allow(configuration).to receive(:indices).
+        and_return([users_index, parts_index, rt_index])
+    end
+
+    it "invokes the clear_sql command" do
+      expect(commander).to receive(:call).with(
+        :clear_sql,
+        configuration,
+        {:verbose => true, :indices => [users_index, parts_index]},
+        stream
+      )
+
+      interface.clear
+    end
+  end
+
+  describe '#index' do
+    it "invokes the prepare command" do
+      expect(commander).to receive(:call).with(
+        :prepare, configuration, {:verbose => true}, stream
+      )
+
+      interface.index
+    end
+
+    it "renders the configuration to a file by default" do
+      expect(commander).to receive(:call).with(
+        :configure, configuration, {:verbose => true}, stream
+      )
+
+      interface.index
+    end
+
+    it "does not render the configuration if requested" do
+      expect(commander).not_to receive(:call).with(
+        :configure, configuration, {:verbose => true}, stream
+      )
+
+      interface.index false
+    end
+
+    it "executes the index command" do
+      expect(commander).to receive(:call).with(
+        :index_sql, configuration, {:verbose => true, :indices => nil}, stream
+      )
+
+      interface.index
+    end
+
+    context "with options[:index_names]" do
+      let(:users_index) { double(:name => 'users', :type => 'plain') }
+      let(:parts_index) { double(:name => 'parts', :type => 'plain') }
+      let(:rt_index)    { double(:type => 'rt') }
+      let(:interface)   { ThinkingSphinx::Interfaces::SQL.new(
+        configuration, {:index_names => ['users']}, stream
+      ) }
+
+      before :each do
+        allow(configuration).to receive(:indices).
+          and_return([users_index, parts_index, rt_index])
+      end
+
+      it 'invokes the index command for matching indices' do
+        expect(commander).to receive(:call).with(
+          :index_sql,
+          configuration,
+          {:index_names => ['users'], :indices => ['users']},
+          stream
+        )
+
+        interface.index
+      end
+    end
+  end
+
+  describe '#merge' do
+    it "invokes the merge command" do
+      expect(commander).to receive(:call).with(
+        :merge_and_update, configuration, {:verbose => true}, stream
+      )
+
+      interface.merge
+    end
+
+    context "with options[:index_names]" do
+      let(:interface)   { ThinkingSphinx::Interfaces::SQL.new(
+        configuration, {:index_names => ['users']}, stream
+      ) }
+
+      it 'invokes the merge command with the index_names option' do
+        expect(commander).to receive(:call).with(
+          :merge_and_update, configuration, {:index_names => ['users']}, stream
+        )
+
+        interface.merge
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/masks/pagination_mask_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Masks; end
 end
@@ -12,13 +14,13 @@ describe ThinkingSphinx::Masks::PaginationMask do
 
   describe '#first_page?' do
     it "returns true when on the first page" do
-      mask.should be_first_page
+      expect(mask).to be_first_page
     end
 
     it "returns false on other pages" do
-      search.stub :current_page => 2
+      allow(search).to receive_messages :current_page => 2
 
-      mask.should_not be_first_page
+      expect(mask).not_to be_first_page
     end
   end
 
@@ -28,13 +30,13 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "is true when there's no more pages" do
-      search.stub :current_page => 3
+      allow(search).to receive_messages :current_page => 3
 
-      mask.should be_last_page
+      expect(mask).to be_last_page
     end
 
     it "is false when there's still more pages" do
-      mask.should_not be_last_page
+      expect(mask).not_to be_last_page
     end
   end
 
@@ -44,13 +46,13 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "should return one more than the current page" do
-      mask.next_page.should == 2
+      expect(mask.next_page).to eq(2)
     end
 
     it "should return nil if on the last page" do
-      search.stub :current_page => 3
+      allow(search).to receive_messages :current_page => 3
 
-      mask.next_page.should be_nil
+      expect(mask.next_page).to be_nil
     end
   end
 
@@ -60,13 +62,13 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "is true when there is a second page" do
-      mask.next_page?.should be_true
+      expect(mask.next_page?).to be_truthy
     end
 
     it "is false when there's no more pages" do
-      search.stub :current_page => 3
+      allow(search).to receive_messages :current_page => 3
 
-      mask.next_page?.should be_false
+      expect(mask.next_page?).to be_falsey
     end
   end
 
@@ -76,13 +78,13 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "should return one less than the current page" do
-      search.stub :current_page => 2
+      allow(search).to receive_messages :current_page => 2
 
-      mask.previous_page.should == 1
+      expect(mask.previous_page).to eq(1)
     end
 
     it "should return nil if on the first page" do
-      mask.previous_page.should be_nil
+      expect(mask.previous_page).to be_nil
     end
   end
 
@@ -92,7 +94,7 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "returns the total found from the search request metadata" do
-      mask.total_entries.should == 12
+      expect(mask.total_entries).to eq(12)
     end
   end
 
@@ -103,19 +105,19 @@ describe ThinkingSphinx::Masks::PaginationMask do
     end
 
     it "uses the total available from the search request metadata" do
-      mask.total_pages.should == 2
+      expect(mask.total_pages).to eq(2)
     end
 
     it "should allow for custom per_page values" do
-      search.stub :per_page => 40
+      allow(search).to receive_messages :per_page => 40
 
-      mask.total_pages.should == 1
+      expect(mask.total_pages).to eq(1)
     end
 
     it "should return 0 if there is no index and therefore no results" do
       search.meta.clear
 
-      mask.total_pages.should == 0
+      expect(mask.total_pages).to eq(0)
     end
   end
 end

data/spec/thinking_sphinx/masks/scopes_mask_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Masks; end
 end
@@ -10,18 +12,18 @@ describe ThinkingSphinx::Masks::ScopesMask do
   let(:mask)   { ThinkingSphinx::Masks::ScopesMask.new search }
 
   before :each do
-    FileUtils.stub :mkdir_p => true
+    allow(FileUtils).to receive_messages :mkdir_p => true
   end
 
   describe '#search' do
     it "replaces the query if one is supplied" do
-      search.should_receive(:query=).with('bar')
+      expect(search).to receive(:query=).with('bar')
 
       mask.search('bar')
     end
 
     it "keeps the existing query when only options are offered" do
-      search.should_not_receive(:query=)
+      expect(search).not_to receive(:query=)
 
       mask.search :with => {:foo => :bar}
     end
@@ -31,7 +33,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search :conditions => {:baz => 'qux'}
 
-      search.options[:conditions].should == {:foo => 'bar', :baz => 'qux'}
+      expect(search.options[:conditions]).to eq({:foo => 'bar', :baz => 'qux'})
     end
 
     it "merges filters" do
@@ -39,7 +41,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search :with => {:baz => :qux}
 
-      search.options[:with].should == {:foo => :bar, :baz => :qux}
+      expect(search.options[:with]).to eq({:foo => :bar, :baz => :qux})
     end
 
     it "merges exclusive filters" do
@@ -47,7 +49,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search :without => {:baz => :qux}
 
-      search.options[:without].should == {:foo => :bar, :baz => :qux}
+      expect(search.options[:without]).to eq({:foo => :bar, :baz => :qux})
     end
 
     it "appends excluded ids" do
@@ -55,7 +57,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search :without_ids => [5, 7]
 
-      search.options[:without_ids].should == [1, 3, 5, 7]
+      expect(search.options[:without_ids]).to eq([1, 3, 5, 7])
     end
 
     it "replaces the retry_stale option" do
@@ -63,23 +65,23 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search :retry_stale => 6
 
-      search.options[:retry_stale].should == 6
+      expect(search.options[:retry_stale]).to eq(6)
     end
 
     it "returns the original search object" do
-      mask.search.object_id.should == search.object_id
+      expect(mask.search.object_id).to eq(search.object_id)
     end
   end
 
   describe '#search_for_ids' do
     it "replaces the query if one is supplied" do
-      search.should_receive(:query=).with('bar')
+      expect(search).to receive(:query=).with('bar')
 
       mask.search_for_ids('bar')
     end
 
     it "keeps the existing query when only options are offered" do
-      search.should_not_receive(:query=)
+      expect(search).not_to receive(:query=)
 
       mask.search_for_ids :with => {:foo => :bar}
     end
@@ -89,7 +91,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search_for_ids :conditions => {:baz => 'qux'}
 
-      search.options[:conditions].should == {:foo => 'bar', :baz => 'qux'}
+      expect(search.options[:conditions]).to eq({:foo => 'bar', :baz => 'qux'})
     end
 
     it "merges filters" do
@@ -97,7 +99,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search_for_ids :with => {:baz => :qux}
 
-      search.options[:with].should == {:foo => :bar, :baz => :qux}
+      expect(search.options[:with]).to eq({:foo => :bar, :baz => :qux})
     end
 
     it "merges exclusive filters" do
@@ -105,7 +107,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search_for_ids :without => {:baz => :qux}
 
-      search.options[:without].should == {:foo => :bar, :baz => :qux}
+      expect(search.options[:without]).to eq({:foo => :bar, :baz => :qux})
     end
 
     it "appends excluded ids" do
@@ -113,7 +115,7 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search_for_ids :without_ids => [5, 7]
 
-      search.options[:without_ids].should == [1, 3, 5, 7]
+      expect(search.options[:without_ids]).to eq([1, 3, 5, 7])
     end
 
     it "replaces the retry_stale option" do
@@ -121,17 +123,17 @@ describe ThinkingSphinx::Masks::ScopesMask do
 
       mask.search_for_ids :retry_stale => 6
 
-      search.options[:retry_stale].should == 6
+      expect(search.options[:retry_stale]).to eq(6)
     end
 
     it "adds the ids_only option" do
       mask.search_for_ids
 
-      search.options[:ids_only].should be_true
+      expect(search.options[:ids_only]).to be_truthy
     end
 
     it "returns the original search object" do
-      mask.search_for_ids.object_id.should == search.object_id
+      expect(mask.search_for_ids.object_id).to eq(search.object_id)
     end
   end
 end

data/spec/thinking_sphinx/middlewares/active_record_translator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
   class  Search; end
@@ -11,9 +13,10 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
   let(:app)        { double('app', :call => true) }
   let(:middleware) {
     ThinkingSphinx::Middlewares::ActiveRecordTranslator.new app }
-  let(:context)    { {:raw => [], :results => []} }
+  let(:context)    { {:raw => [], :results => [] } }
   let(:model)      { double('model', :primary_key => :id) }
   let(:search)     { double('search', :options => {}) }
+  let(:configuration) { double('configuration', :settings => {:primary_key => :id}) }
 
   def raw_result(id, model_name)
     {'sphinx_internal_id' => id, 'sphinx_internal_class' => model_name}
@@ -21,20 +24,21 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
 
   describe '#call' do
     before :each do
-      context.stub :search => search
-      model.stub :unscoped => model
+      allow(context).to receive_messages :search => search
+      allow(context).to receive_messages :configuration => configuration
+      allow(model).to receive_messages :unscoped => model
     end
 
     it "translates records to ActiveRecord objects" do
       model_name = double('article', :constantize => model)
       instance   = double('instance', :id => 24)
-      model.stub :where => [instance]
+      allow(model).to receive_messages :where => [instance]
 
       context[:results] << raw_result(24, model_name)
 
       middleware.call [context]
 
-      context[:results].should == [instance]
+      expect(context[:results]).to eq([instance])
     end
 
     it "only queries the model once for the given search results" do
@@ -44,7 +48,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(24, model_name)
       context[:results] << raw_result(42, model_name)
 
-      model.should_receive(:where).once.and_return([instance_a, instance_b])
+      expect(model).to receive(:where).once.and_return([instance_a, instance_b])
 
       middleware.call [context]
     end
@@ -58,14 +62,14 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       user_name     = double('user name', :constantize => user_model)
       user          = double('user instance', :id => 12)
 
-      article_model.stub :unscoped => article_model
-      user_model.stub :unscoped => user_model
+      allow(article_model).to receive_messages :unscoped => article_model
+      allow(user_model).to receive_messages :unscoped => user_model
 
       context[:results] << raw_result(24, article_name)
       context[:results] << raw_result(12, user_name)
 
-      article_model.should_receive(:where).once.and_return([article])
-      user_model.should_receive(:where).once.and_return([user])
+      expect(article_model).to receive(:where).once.and_return([article])
+      expect(user_model).to receive(:where).once.and_return([user])
 
       middleware.call [context]
     end
@@ -78,11 +82,11 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(2, model_name)
       context[:results] << raw_result(1, model_name)
 
-      model.stub(:where => [instance_1, instance_2])
+      allow(model).to receive_messages(:where => [instance_1, instance_2])
 
       middleware.call [context]
 
-      context[:results].should == [instance_2, instance_1]
+      expect(context[:results]).to eq([instance_2, instance_1])
     end
 
     it "returns objects in database order if a SQL order clause is supplied" do
@@ -93,28 +97,40 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(2, model_name)
       context[:results] << raw_result(1, model_name)
 
-      model.stub(:order => model, :where => [instance_1, instance_2])
+      allow(model).to receive_messages(:order => model, :where => [instance_1, instance_2])
       search.options[:sql] = {:order => 'name DESC'}
 
       middleware.call [context]
 
-      context[:results].should == [instance_1, instance_2]
+      expect(context[:results]).to eq([instance_1, instance_2])
+    end
+
+    it "handles model without primary key" do
+      no_primary_key_model = double('no primary key model')
+      allow(no_primary_key_model).to receive_messages :unscoped => no_primary_key_model
+      model_name = double('article', :constantize => no_primary_key_model)
+      instance   = double('instance', :id => 1)
+      allow(no_primary_key_model).to receive_messages :where => [instance]
+
+      context[:results] << raw_result(1, model_name)
+
+      middleware.call [context]
     end
 
     context 'SQL options' do
       let(:relation) { double('relation', :where => []) }
+      let(:model_name) { double('article', :constantize => model) }
 
       before :each do
-        model.stub :unscoped => relation
+        allow(model).to receive_messages :unscoped => relation
 
-        model_name = double('article', :constantize => model)
         context[:results] << raw_result(1, model_name)
       end
 
       it "passes through SQL include options to the relation" do
         search.options[:sql] = {:include => :association}
 
-        relation.should_receive(:includes).with(:association).
+        expect(relation).to receive(:includes).with(:association).
           and_return(relation)
 
         middleware.call [context]
@@ -123,7 +139,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL join options to the relation" do
         search.options[:sql] = {:joins => :association}
 
-        relation.should_receive(:joins).with(:association).and_return(relation)
+        expect(relation).to receive(:joins).with(:association).and_return(relation)
 
         middleware.call [context]
       end
@@ -131,7 +147,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL order options to the relation" do
         search.options[:sql] = {:order => 'name DESC'}
 
-        relation.should_receive(:order).with('name DESC').and_return(relation)
+        expect(relation).to receive(:order).with('name DESC').and_return(relation)
 
         middleware.call [context]
       end
@@ -139,7 +155,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL select options to the relation" do
         search.options[:sql] = {:select => :column}
 
-        relation.should_receive(:select).with(:column).and_return(relation)
+        expect(relation).to receive(:select).with(:column).and_return(relation)
 
         middleware.call [context]
       end
@@ -147,7 +163,15 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL group options to the relation" do
         search.options[:sql] = {:group => :column}
 
-        relation.should_receive(:group).with(:column).and_return(relation)
+        expect(relation).to receive(:group).with(:column).and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL options defined by model to the relation" do
+        search.options[:sql] = {model_name => {:joins => :association}}
+
+        expect(relation).to receive(:joins).with(:association).and_return(relation)
 
         middleware.call [context]
       end

data/spec/thinking_sphinx/middlewares/geographer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
 end
@@ -16,7 +18,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
   before :each do
     stub_const 'ThinkingSphinx::Panes::DistancePane', double
 
-    context.stub :search => search
+    allow(context).to receive_messages :search => search
   end
 
   describe '#call' do
@@ -26,7 +28,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "doesn't add anything if :geo is nil" do
-        sphinx_sql.should_not_receive(:prepend_values)
+        expect(sphinx_sql).not_to receive(:prepend_values)
 
         middleware.call [context]
       end
@@ -38,7 +40,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "adds the geodist function when given a :geo option" do
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, lat, lng) AS geodist').
           and_return(sphinx_sql)
 
@@ -46,18 +48,18 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "adds the distance pane" do
-        sphinx_sql.stub :prepend_values => sphinx_sql
+        allow(sphinx_sql).to receive_messages :prepend_values => sphinx_sql
 
         middleware.call [context]
 
-        context[:panes].should include(ThinkingSphinx::Panes::DistancePane)
+        expect(context[:panes]).to include(ThinkingSphinx::Panes::DistancePane)
       end
 
       it "respects :latitude_attr and :longitude_attr options" do
         search.options[:latitude_attr]  = 'side_to_side'
         search.options[:longitude_attr] = 'up_or_down'
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, side_to_side, up_or_down) AS geodist').
           and_return(sphinx_sql)
 
@@ -68,7 +70,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
         context[:indices] << double('index',
           :unique_attribute_names => ['latitude'], :name => 'an_index')
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, latitude, lng) AS geodist').
           and_return(sphinx_sql)
 
@@ -79,7 +81,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
         context[:indices] << double('index',
           :unique_attribute_names => ['longitude'], :name => 'an_index')
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, lat, longitude) AS geodist').
           and_return(sphinx_sql)
 
@@ -89,7 +91,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       it "handles very small values" do
         search.options[:geo] = [0.0000001, 0.00000000002]
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.0000001, 0.00000000002, lat, lng) AS geodist').
           and_return(sphinx_sql)