thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/index_set_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx; end
+
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation'
+require 'thinking_sphinx/index_set'
+
+describe ThinkingSphinx::IndexSet do
+  let(:set)           { ThinkingSphinx::IndexSet.new options, configuration }
+  let(:configuration) { double('configuration', :preload_indices => true,
+    :indices => []) }
+  let(:ar_base)       { double('ActiveRecord::Base') }
+  let(:options)       { {} }
+
+  before :each do
+    stub_const 'ActiveRecord::Base', ar_base
+  end
+
+  def class_double(name, methods = {}, *superclasses)
+    klass = double 'class', :name => name, :class => Class
+
+    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
+      expect(configuration).to receive(:preload_indices)
+
+      set.to_a
+    end
+
+    it "returns all non-distributed indices when no models or indices are specified" do
+      article_core = double 'index', :name => 'article_core',
+        :distributed? => false
+      user_core    = double 'index', :name => 'user_core',
+        :distributed? => false
+      distributed  = double 'index', :name => 'user', :distributed? => true
+
+      configuration.indices.replace [article_core, user_core, distributed]
+
+      expect(set.to_a).to eq([article_core, user_core])
+    end
+
+    it "uses indices for the given classes" do
+      configuration.indices.replace [
+        article_index, opinion_article_index, page_index
+      ]
+
+      options[:classes] = [class_double('Article', :column_names => [])]
+
+      expect(set.to_a).to eq([article_index])
+    end
+
+    it "uses indices for the given instance's class" do
+      configuration.indices.replace [
+        article_index, opinion_article_index, page_index
+      ]
+
+      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
+      ]
+
+      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
+      article_core = double('index', :name => 'article_core')
+      user_core    = double('index', :name => 'user_core')
+      configuration.indices.replace [article_core, user_core]
+
+      options[:indices] = ['article_core']
+
+      expect(set.to_a).to eq([article_core])
+    end
+
+    it "selects from the full index set those with matching references" do
+      configuration.indices.replace [
+        double('index', :reference => :article, :distributed? => false),
+        double('index', :reference => :book,    :distributed? => false),
+        double('index', :reference => :page,    :distributed? => false)
+      ]
+
+      options[:references] = [:book, :article]
+
+      expect(set.to_a.length).to eq(2)
+    end
+  end
+end

data/spec/thinking_sphinx/index_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Index do
+  let(:configuration)  { Struct.new(:indices, :settings).new([], {}) }
+  
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => configuration
+  end
+  
+  describe '.define' do
+    let(:index)   { double('index', :definition_block= => nil) }
+    
+    context 'with ActiveRecord' do
+      before :each do
+        allow(ThinkingSphinx::ActiveRecord::Index).to receive_messages :new => index
+      end
+
+      it "creates an ActiveRecord index" do
+        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
+        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)
+
+        expect(configuration.indices).to include(index)
+      end
+
+      it "sets the block in the index" do
+        expect(index).to receive(:definition_block=).with instance_of(Proc)
+
+        ThinkingSphinx::Index.define(:user, :with => :active_record) do
+          indexes name
+        end
+      end
+
+      context 'with a delta' do
+        let(:delta_index) { double('delta index', :definition_block= => nil) }
+        let(:processor)   { double('delta processor') }
+
+        before :each do
+          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
+          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
+          expect(ThinkingSphinx::ActiveRecord::Index).to receive(:new).
+            with(:user,
+              hash_including(:delta? => true,  :delta_processor => processor)
+            ).once.
+            and_return delta_index
+
+          ThinkingSphinx::Index.define :user,
+            :with  => :active_record,
+            :delta => true
+        end
+
+        it "appends both indices to the collection" do
+          ThinkingSphinx::Index.define :user,
+            :with  => :active_record,
+            :delta => true
+
+          expect(configuration.indices).to include(index)
+          expect(configuration.indices).to include(delta_index)
+        end
+
+        it "sets the block in the index" do
+          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,
+            :delta => true) do
+            indexes name
+          end
+        end
+      end
+    end
+
+    context 'with Real-Time' do
+      before :each do
+        allow(ThinkingSphinx::RealTime::Index).to receive_messages :new => index
+      end
+
+      it "creates a real-time index" do
+        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
+        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)
+
+        expect(configuration.indices).to include(index)
+      end
+
+      it "sets the block in the index" do
+        expect(index).to receive(:definition_block=).with instance_of(Proc)
+
+        ThinkingSphinx::Index.define(:user, :with => :real_time) do
+          indexes name
+        end
+      end
+    end
+  end
+  
+  describe '#initialize' do
+    it "is fine with no defaults from settings" do
+      expect(ThinkingSphinx::Index.new(:user, {}).options).to eq({})
+    end
+    
+    it "respects defaults from settings" do
+      configuration.settings['index_options'] = {'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

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Masks; end
+end
+
+require 'active_support/core_ext/object/blank'
+require 'thinking_sphinx/masks/pagination_mask'
+
+describe ThinkingSphinx::Masks::PaginationMask do
+  let(:search) { double('search', :options => {}, :meta => {},
+    :per_page => 20, :current_page => 1) }
+  let(:mask)   { ThinkingSphinx::Masks::PaginationMask.new search }
+
+  describe '#first_page?' do
+    it "returns true when on the first page" do
+      expect(mask).to be_first_page
+    end
+
+    it "returns false on other pages" do
+      allow(search).to receive_messages :current_page => 2
+
+      expect(mask).not_to be_first_page
+    end
+  end
+
+  describe '#last_page?' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "is true when there's no more pages" do
+      allow(search).to receive_messages :current_page => 3
+
+      expect(mask).to be_last_page
+    end
+
+    it "is false when there's still more pages" do
+      expect(mask).not_to be_last_page
+    end
+  end
+
+  describe '#next_page' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "should return one more than the current page" do
+      expect(mask.next_page).to eq(2)
+    end
+
+    it "should return nil if on the last page" do
+      allow(search).to receive_messages :current_page => 3
+
+      expect(mask.next_page).to be_nil
+    end
+  end
+
+  describe '#next_page?' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "is true when there is a second page" do
+      expect(mask.next_page?).to be_truthy
+    end
+
+    it "is false when there's no more pages" do
+      allow(search).to receive_messages :current_page => 3
+
+      expect(mask.next_page?).to be_falsey
+    end
+  end
+
+  describe '#previous_page' do
+    before :each do
+      search.meta['total'] = '44'
+    end
+
+    it "should return one less than the current page" do
+      allow(search).to receive_messages :current_page => 2
+
+      expect(mask.previous_page).to eq(1)
+    end
+
+    it "should return nil if on the first page" do
+      expect(mask.previous_page).to be_nil
+    end
+  end
+
+  describe '#total_entries' do
+    before :each do
+      search.meta['total_found'] = '12'
+    end
+
+    it "returns the total found from the search request metadata" do
+      expect(mask.total_entries).to eq(12)
+    end
+  end
+
+  describe '#total_pages' do
+    before :each do
+      search.meta['total']       = '40'
+      search.meta['total_found'] = '44'
+    end
+
+    it "uses the total available from the search request metadata" do
+      expect(mask.total_pages).to eq(2)
+    end
+
+    it "should allow for custom per_page values" do
+      allow(search).to receive_messages :per_page => 40
+
+      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
+
+      expect(mask.total_pages).to eq(0)
+    end
+  end
+end