thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::FacetSearch do
@@ -25,19 +27,19 @@ 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[:column]    => 5,
-        ThinkingSphinx::SphinxQL.group_by[:column] => 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
 
   describe '#[]' do
     it "populates facet results" do
-      facet_search[:price_bracket].should == {3 => 5}
+      expect(facet_search[:price_bracket]).to eq({3 => 5})
     end
   end
 
@@ -45,17 +47,17 @@ describe ThinkingSphinx::FacetSearch do
     it "queries on each facet with a grouped search in a batch" do
       facet_search.populate
 
-      batch.searches.detect { |search|
+      expect(batch.searches.detect { |search|
         search.options[:group_by] == 'price_bracket'
-      }.should_not be_nil
+      }).not_to be_nil
     end
 
     it "limits query for a facet to just indices that have that facet" do
       facet_search.populate
 
-      batch.searches.detect { |search|
+      expect(batch.searches.detect { |search|
         search.options[:indices] == ['foo_core']
-      }.should_not be_nil
+      }).not_to be_nil
     end
 
     it "limits facets to the specified set" do
@@ -63,25 +65,25 @@ describe ThinkingSphinx::FacetSearch do
 
       facet_search.populate
 
-      batch.searches.collect { |search|
+      expect(batch.searches.collect { |search|
         search.options[:group_by]
-      }.should == ['category_id']
+      }).to eq(['category_id'])
     end
 
     it "aliases the class facet from sphinx_internal_class" do
-      property_a.stub :name => 'sphinx_internal_class'
+      allow(property_a).to receive_messages :name => 'sphinx_internal_class'
 
       facet_search.populate
 
-      facet_search[:class].should == {'Foo' => 5}
+      expect(facet_search[:class]).to eq({'Foo' => 5})
     end
 
     it "uses the @groupby value for MVAs" do
-      property_a.stub :name => 'tag_ids', :multi? => true
+      allow(property_a).to receive_messages :name => 'tag_ids', :multi? => true
 
       facet_search.populate
 
-      facet_search[:tag_ids].should == {2 => 5}
+      expect(facet_search[:tag_ids]).to eq({2 => 5})
     end
 
     [:max_matches, :limit].each do |setting|
@@ -89,7 +91,7 @@ describe ThinkingSphinx::FacetSearch do
         facet_search.populate
 
         batch.searches.each { |search|
-          search.options[setting].should == 1000
+          expect(search.options[setting]).to eq(1000)
         }
       end
 
@@ -99,7 +101,7 @@ describe ThinkingSphinx::FacetSearch do
         facet_search.populate
 
         batch.searches.each { |search|
-          search.options[setting].should == 1234
+          expect(search.options[setting]).to eq(1234)
         }
       end
     end
@@ -111,7 +113,7 @@ describe ThinkingSphinx::FacetSearch do
         facet_search.populate
 
         batch.searches.each { |search|
-          search.options[setting].should == 42
+          expect(search.options[setting]).to eq(42)
         }
       end
 
@@ -122,8 +124,8 @@ describe ThinkingSphinx::FacetSearch do
         facet_search.populate
 
         batch.searches.each do |search|
-          search.options[setting].should == 10
-          search.options[:max_matches].should == 500
+          expect(search.options[setting]).to eq(10)
+          expect(search.options[:max_matches]).to eq(500)
         end
       end
     end

data/spec/thinking_sphinx/hooks/guard_presence_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ThinkingSphinx::Hooks::GuardPresence do
+  let(:subject) do
+    ThinkingSphinx::Hooks::GuardPresence.new configuration, stream
+  end
+  let(:configuration) { double "configuration", :indices_location => "/path" }
+  let(:stream)        { double "stream", :puts => nil }
+
+  describe "#call" do
+    it "outputs nothing if no guard files exist" do
+      allow(Dir).to receive(:[]).with('/path/ts-*.tmp').and_return([])
+
+      expect(stream).not_to receive(:puts)
+
+      subject.call
+    end
+
+    it "outputs a warning if a guard file exists" do
+      allow(Dir).to receive(:[]).with('/path/ts-*.tmp').
+        and_return(['/path/ts-foo.tmp'])
+
+      expect(stream).to receive(:puts)
+
+      subject.call
+    end
+  end
+end

data/spec/thinking_sphinx/index_set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx; end
 
 require 'active_support/core_ext/string/inflections'
@@ -15,15 +17,31 @@ describe ThinkingSphinx::IndexSet do
     stub_const 'ActiveRecord::Base', ar_base
   end
 
-  def class_double(name, *superclasses)
+  def class_double(name, methods = {}, *superclasses)
     klass = double 'class', :name => name, :class => Class
-    klass.stub :ancestors => ([klass] + superclasses + [ar_base])
+
+    allow(klass).to receive_messages(
+      :ancestors          => ([klass] + superclasses + [ar_base]),
+      :inheritance_column => :type
+    )
+    allow(klass).to receive_messages(methods)
+
     klass
   end
 
   describe '#to_a' do
+    let(:article_index) do
+      double(:reference => :article, :distributed? => false)
+    end
+    let(:opinion_article_index) do
+      double(:reference => :opinion_article, :distributed? => false)
+    end
+    let(:page_index) do
+      double(:reference => :page, :distributed? => false)
+    end
+
     it "ensures the indices are loaded" do
-      configuration.should_receive(:preload_indices)
+      expect(configuration).to receive(:preload_indices)
 
       set.to_a
     end
@@ -37,33 +55,56 @@ describe ThinkingSphinx::IndexSet do
 
       configuration.indices.replace [article_core, user_core, distributed]
 
-      set.to_a.should == [article_core, user_core]
+      expect(set.to_a).to eq([article_core, user_core])
     end
 
     it "uses indices for the given classes" do
       configuration.indices.replace [
-        double(:reference => :article,         :distributed? => false),
-        double(:reference => :opinion_article, :distributed? => false),
-        double(:reference => :page,            :distributed? => false)
+        article_index, opinion_article_index, page_index
       ]
 
-      options[:classes] = [class_double('Article')]
+      options[:classes] = [class_double('Article', :column_names => [])]
 
-      set.to_a.length.should == 1
+      expect(set.to_a).to eq([article_index])
     end
 
-    it "requests indices for any superclasses" do
+    it "uses indices for the given instance's class" do
       configuration.indices.replace [
-        double(:reference => :article,         :distributed? => false),
-        double(:reference => :opinion_article, :distributed? => false),
-        double(:reference => :page,            :distributed? => false)
+        article_index, opinion_article_index, page_index
       ]
 
-      options[:classes] = [
-        class_double('OpinionArticle', class_double('Article'))
+      instance_class = class_double('Article', :column_names => [])
+
+      options[:instances] = [double(:instance, :class => instance_class)]
+
+      expect(set.to_a).to eq([article_index])
+    end
+
+    it "requests indices for any STI superclasses" do
+      configuration.indices.replace [
+        article_index, opinion_article_index, page_index
+      ]
+
+      article = class_double('Article', :column_names => [:type])
+      opinion = class_double('OpinionArticle', {:column_names => [:type]},
+        article)
+
+      options[:classes] = [opinion]
+
+      expect(set.to_a).to eq([article_index, opinion_article_index])
+    end
+
+    it "does not use MTI superclasses" do
+      configuration.indices.replace [
+        article_index, opinion_article_index, page_index
       ]
 
-      set.to_a.length.should == 2
+      article = class_double('Article', :column_names => [])
+      opinion = class_double('OpinionArticle', {:column_names => []}, article)
+
+      options[:classes] = [opinion]
+
+      expect(set.to_a).to eq([opinion_article_index])
     end
 
     it "uses named indices if names are provided" do
@@ -73,7 +114,7 @@ describe ThinkingSphinx::IndexSet do
 
       options[:indices] = ['article_core']
 
-      set.to_a.should == [article_core]
+      expect(set.to_a).to eq([article_core])
     end
 
     it "selects from the full index set those with matching references" do
@@ -85,7 +126,7 @@ describe ThinkingSphinx::IndexSet do
 
       options[:references] = [:book, :article]
 
-      set.to_a.length.should == 2
+      expect(set.to_a.length).to eq(2)
     end
   end
 end

data/spec/thinking_sphinx/index_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Index do
   let(:configuration)  { Struct.new(:indices, :settings).new([], {}) }
   
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => configuration
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => configuration
   end
   
   describe '.define' do
@@ -12,29 +14,29 @@ describe ThinkingSphinx::Index do
     
     context 'with ActiveRecord' do
       before :each do
-        ThinkingSphinx::ActiveRecord::Index.stub :new => index
+        allow(ThinkingSphinx::ActiveRecord::Index).to receive_messages :new => index
       end
 
       it "creates an ActiveRecord index" do
-        ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
-          with(:user, :with => :active_record).and_return index
+        expect(ThinkingSphinx::ActiveRecord::Index).to receive(:new).
+          with(:user, { :with => :active_record }).and_return index
 
         ThinkingSphinx::Index.define(:user, :with => :active_record)
       end
 
       it "returns the ActiveRecord index" do
-        ThinkingSphinx::Index.define(:user, :with => :active_record).
-          should == [index]
+        expect(ThinkingSphinx::Index.define(:user, :with => :active_record)).
+          to eq([index])
       end
 
       it "adds the index to the collection of indices" do
         ThinkingSphinx::Index.define(:user, :with => :active_record)
 
-        configuration.indices.should include(index)
+        expect(configuration.indices).to include(index)
       end
 
       it "sets the block in the index" do
-        index.should_receive(:definition_block=).with instance_of(Proc)
+        expect(index).to receive(:definition_block=).with instance_of(Proc)
 
         ThinkingSphinx::Index.define(:user, :with => :active_record) do
           indexes name
@@ -46,19 +48,19 @@ describe ThinkingSphinx::Index do
         let(:processor)   { double('delta processor') }
 
         before :each do
-          ThinkingSphinx::Deltas.stub :processor_for => processor
-          ThinkingSphinx::ActiveRecord::Index.stub(:new).
+          allow(ThinkingSphinx::Deltas).to receive_messages :processor_for => processor
+          allow(ThinkingSphinx::ActiveRecord::Index).to receive(:new).
             and_return(index, delta_index)
         end
 
         it "creates two indices with delta settings" do
-          ThinkingSphinx::ActiveRecord::Index.unstub :new
-          ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
+          allow(ThinkingSphinx::ActiveRecord::Index).to receive(:new).and_call_original
+          expect(ThinkingSphinx::ActiveRecord::Index).to receive(:new).
             with(:user,
               hash_including(:delta? => false, :delta_processor => processor)
             ).once.
             and_return index
-          ThinkingSphinx::ActiveRecord::Index.should_receive(:new).
+          expect(ThinkingSphinx::ActiveRecord::Index).to receive(:new).
             with(:user,
               hash_including(:delta? => true,  :delta_processor => processor)
             ).once.
@@ -74,13 +76,13 @@ describe ThinkingSphinx::Index do
             :with  => :active_record,
             :delta => true
 
-          configuration.indices.should include(index)
-          configuration.indices.should include(delta_index)
+          expect(configuration.indices).to include(index)
+          expect(configuration.indices).to include(delta_index)
         end
 
         it "sets the block in the index" do
-          index.should_receive(:definition_block=).with instance_of(Proc)
-          delta_index.should_receive(:definition_block=).with instance_of(Proc)
+          expect(index).to receive(:definition_block=).with instance_of(Proc)
+          expect(delta_index).to receive(:definition_block=).with instance_of(Proc)
 
           ThinkingSphinx::Index.define(:user,
             :with  => :active_record,
@@ -93,29 +95,29 @@ describe ThinkingSphinx::Index do
 
     context 'with Real-Time' do
       before :each do
-        ThinkingSphinx::RealTime::Index.stub :new => index
+        allow(ThinkingSphinx::RealTime::Index).to receive_messages :new => index
       end
 
       it "creates a real-time index" do
-        ThinkingSphinx::RealTime::Index.should_receive(:new).
-          with(:user, :with => :real_time).and_return index
+        expect(ThinkingSphinx::RealTime::Index).to receive(:new).
+          with(:user, { :with => :real_time }).and_return index
 
         ThinkingSphinx::Index.define(:user, :with => :real_time)
       end
 
       it "returns the ActiveRecord index" do
-        ThinkingSphinx::Index.define(:user, :with => :real_time).
-          should == [index]
+        expect(ThinkingSphinx::Index.define(:user, :with => :real_time)).
+          to eq([index])
       end
 
       it "adds the index to the collection of indices" do
         ThinkingSphinx::Index.define(:user, :with => :real_time)
 
-        configuration.indices.should include(index)
+        expect(configuration.indices).to include(index)
       end
 
       it "sets the block in the index" do
-        index.should_receive(:definition_block=).with instance_of(Proc)
+        expect(index).to receive(:definition_block=).with instance_of(Proc)
 
         ThinkingSphinx::Index.define(:user, :with => :real_time) do
           indexes name
@@ -126,13 +128,13 @@ describe ThinkingSphinx::Index do
   
   describe '#initialize' do
     it "is fine with no defaults from settings" do
-      ThinkingSphinx::Index.new(:user, {}).options.should == {}
+      expect(ThinkingSphinx::Index.new(:user, {}).options).to eq({})
     end
     
     it "respects defaults from settings" do
       configuration.settings['index_options'] = {'delta' => true}
       
-      ThinkingSphinx::Index.new(:user, {}).options.should == {:delta => true}
+      expect(ThinkingSphinx::Index.new(:user, {}).options).to eq({:delta => true})
     end
   end
 end

data/spec/thinking_sphinx/interfaces/daemon_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::Daemon do
+  let(:configuration) { double 'configuration' }
+  let(:stream)        { double 'stream', :puts => true }
+  let(:commander)     { double :call => nil }
+  let(:interface)     {
+    ThinkingSphinx::Interfaces::Daemon.new(configuration, {}, stream)
+  }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Commander', commander
+
+    allow(commander).to receive(:call).
+      with(:running, configuration, {}, stream).and_return(false)
+  end
+
+  describe '#start' do
+    it "starts the daemon" do
+      expect(commander).to receive(:call).with(
+        :start_detached, configuration, {}, stream
+      )
+
+      interface.start
+    end
+
+    it "raises an error if the daemon is already running" do
+      allow(commander).to receive(:call).
+        with(:running, configuration, {}, stream).and_return(true)
+
+      expect {
+        interface.start
+      }.to raise_error(ThinkingSphinx::SphinxAlreadyRunning)
+    end
+  end
+
+  describe '#status' do
+    it "reports when the daemon is running" do
+      allow(commander).to receive(:call).
+        with(:running, configuration, {}, stream).and_return(true)
+
+      expect(stream).to receive(:puts).
+        with('The Sphinx daemon searchd is currently running.')
+
+      interface.status
+    end
+
+    it "reports when the daemon is not running" do
+      allow(commander).to receive(:call).
+        with(:running, configuration, {}, stream).and_return(false)
+
+      expect(stream).to receive(:puts).
+        with('The Sphinx daemon searchd is not currently running.')
+
+      interface.status
+    end
+  end
+end

data/spec/thinking_sphinx/interfaces/real_time_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::SQL do
+  let(:interface)     { ThinkingSphinx::Interfaces::RealTime.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) { double 'configuration', :controller => controller,
+    :render => true, :indices_location => '/path/to/indices',
+    :preload_indices => true }
+  let(:controller)    { double 'controller', :running? => true }
+  let(:commander)     { double :call => true }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    stub_const "ThinkingSphinx::Commander", commander
+  end
+
+  describe '#clear' do
+    let(:plain_index) { double(:type => 'plain') }
+    let(:users_index) { double(:name => 'users', :type => 'rt', :render => true,
+      :path => '/path/to/my/index/users') }
+    let(:parts_index) { double(:name => 'parts', :type => 'rt', :render => true,
+      :path => '/path/to/my/index/parts') }
+
+    before :each do
+      allow(configuration).to receive_messages(
+        :indices => [plain_index, users_index, parts_index]
+      )
+    end
+
+    it 'prepares the indices' do
+      expect(commander).to receive(:call).with(
+        :prepare, configuration, {}, stream
+      )
+
+      interface.clear
+    end
+
+    it 'invokes the clear command' do
+      expect(commander).to receive(:call).with(
+        :clear_real_time,
+        configuration,
+        {:indices => [users_index, parts_index]},
+        stream
+      )
+
+      interface.clear
+    end
+
+    context "with options[:index_names]" do
+      let(:interface) { ThinkingSphinx::Interfaces::RealTime.new(
+        configuration, {:index_names => ['users']}, stream
+      ) }
+
+      it "removes each file for real-time indices that match :index_filter" do
+        expect(commander).to receive(:call).with(
+          :clear_real_time,
+          configuration,
+          {:index_names => ['users'], :indices => [users_index]},
+          stream
+        )
+
+        interface.clear
+      end
+    end
+  end
+
+  describe '#index' do
+    let(:plain_index) { double(:type => 'plain') }
+    let(:users_index) { double(name: 'users', :type => 'rt') }
+    let(:parts_index) { double(name: 'parts', :type => 'rt') }
+
+    before :each do
+      allow(configuration).to receive_messages(
+        :indices => [plain_index, users_index, parts_index]
+      )
+    end
+
+    it 'invokes the index command with real-time indices' do
+      expect(commander).to receive(:call).with(
+        :index_real_time,
+        configuration,
+        {:indices => [users_index, parts_index]},
+        stream
+      )
+
+      interface.index
+    end
+
+    context "with options[:index_names]" do
+      let(:interface) { ThinkingSphinx::Interfaces::RealTime.new(
+        configuration, {:index_names => ['users']}, stream
+      ) }
+
+      it 'invokes the index command for matching indices' do
+        expect(commander).to receive(:call).with(
+          :index_real_time,
+          configuration,
+          {:index_names => ['users'], :indices => [users_index]},
+          stream
+        )
+
+        interface.index
+      end
+    end
+  end
+end