thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/masks/scopes_mask_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Masks; end
+end
+
+require 'thinking_sphinx/masks/scopes_mask'
+
+describe ThinkingSphinx::Masks::ScopesMask do
+  let(:search) { double('search', :options => {}, :per_page => 20,
+    :populated? => false) }
+  let(:mask)   { ThinkingSphinx::Masks::ScopesMask.new search }
+
+  before :each do
+    allow(FileUtils).to receive_messages :mkdir_p => true
+  end
+
+  describe '#search' do
+    it "replaces the query if one is supplied" do
+      expect(search).to receive(:query=).with('bar')
+
+      mask.search('bar')
+    end
+
+    it "keeps the existing query when only options are offered" do
+      expect(search).not_to receive(:query=)
+
+      mask.search :with => {:foo => :bar}
+    end
+
+    it "merges conditions" do
+      search.options[:conditions] = {:foo => 'bar'}
+
+      mask.search :conditions => {:baz => 'qux'}
+
+      expect(search.options[:conditions]).to eq({:foo => 'bar', :baz => 'qux'})
+    end
+
+    it "merges filters" do
+      search.options[:with] = {:foo => :bar}
+
+      mask.search :with => {:baz => :qux}
+
+      expect(search.options[:with]).to eq({:foo => :bar, :baz => :qux})
+    end
+
+    it "merges exclusive filters" do
+      search.options[:without] = {:foo => :bar}
+
+      mask.search :without => {:baz => :qux}
+
+      expect(search.options[:without]).to eq({:foo => :bar, :baz => :qux})
+    end
+
+    it "appends excluded ids" do
+      search.options[:without_ids] = [1, 3]
+
+      mask.search :without_ids => [5, 7]
+
+      expect(search.options[:without_ids]).to eq([1, 3, 5, 7])
+    end
+
+    it "replaces the retry_stale option" do
+      search.options[:retry_stale] = true
+
+      mask.search :retry_stale => 6
+
+      expect(search.options[:retry_stale]).to eq(6)
+    end
+
+    it "returns the original search object" do
+      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
+      expect(search).to receive(:query=).with('bar')
+
+      mask.search_for_ids('bar')
+    end
+
+    it "keeps the existing query when only options are offered" do
+      expect(search).not_to receive(:query=)
+
+      mask.search_for_ids :with => {:foo => :bar}
+    end
+
+    it "merges conditions" do
+      search.options[:conditions] = {:foo => 'bar'}
+
+      mask.search_for_ids :conditions => {:baz => 'qux'}
+
+      expect(search.options[:conditions]).to eq({:foo => 'bar', :baz => 'qux'})
+    end
+
+    it "merges filters" do
+      search.options[:with] = {:foo => :bar}
+
+      mask.search_for_ids :with => {:baz => :qux}
+
+      expect(search.options[:with]).to eq({:foo => :bar, :baz => :qux})
+    end
+
+    it "merges exclusive filters" do
+      search.options[:without] = {:foo => :bar}
+
+      mask.search_for_ids :without => {:baz => :qux}
+
+      expect(search.options[:without]).to eq({:foo => :bar, :baz => :qux})
+    end
+
+    it "appends excluded ids" do
+      search.options[:without_ids] = [1, 3]
+
+      mask.search_for_ids :without_ids => [5, 7]
+
+      expect(search.options[:without_ids]).to eq([1, 3, 5, 7])
+    end
+
+    it "replaces the retry_stale option" do
+      search.options[:retry_stale] = true
+
+      mask.search_for_ids :retry_stale => 6
+
+      expect(search.options[:retry_stale]).to eq(6)
+    end
+
+    it "adds the ids_only option" do
+      mask.search_for_ids
+
+      expect(search.options[:ids_only]).to be_truthy
+    end
+
+    it "returns the original search object" do
+      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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Middlewares; end
+  class  Search; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/active_record_translator'
+require 'thinking_sphinx/search/stale_ids_exception'
+
+describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
+  let(:app)        { double('app', :call => true) }
+  let(:middleware) {
+    ThinkingSphinx::Middlewares::ActiveRecordTranslator.new app }
+  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}
+  end
+
+  describe '#call' do
+    before :each do
+      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)
+      allow(model).to receive_messages :where => [instance]
+
+      context[:results] << raw_result(24, model_name)
+
+      middleware.call [context]
+
+      expect(context[:results]).to eq([instance])
+    end
+
+    it "only queries the model once for the given search results" do
+      model_name = double('article', :constantize => model)
+      instance_a = double('instance', :id => 24)
+      instance_b = double('instance', :id => 42)
+      context[:results] << raw_result(24, model_name)
+      context[:results] << raw_result(42, model_name)
+
+      expect(model).to receive(:where).once.and_return([instance_a, instance_b])
+
+      middleware.call [context]
+    end
+
+    it "handles multiple models" do
+      article_model = double('article model', :primary_key => :id)
+      article_name  = double('article name', :constantize => article_model)
+      article       = double('article instance', :id => 24)
+
+      user_model    = double('user model', :primary_key => :id)
+      user_name     = double('user name', :constantize => user_model)
+      user          = double('user instance', :id => 12)
+
+      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)
+
+      expect(article_model).to receive(:where).once.and_return([article])
+      expect(user_model).to receive(:where).once.and_return([user])
+
+      middleware.call [context]
+    end
+
+    it "sorts the results according to Sphinx order, not database order" do
+      model_name = double('article', :constantize => model)
+      instance_1 = double('instance 1', :id => 1)
+      instance_2 = double('instance 2', :id => 2)
+
+      context[:results] << raw_result(2, model_name)
+      context[:results] << raw_result(1, model_name)
+
+      allow(model).to receive_messages(:where => [instance_1, instance_2])
+
+      middleware.call [context]
+
+      expect(context[:results]).to eq([instance_2, instance_1])
+    end
+
+    it "returns objects in database order if a SQL order clause is supplied" do
+      model_name = double('article', :constantize => model)
+      instance_1 = double('instance 1', :id => 1)
+      instance_2 = double('instance 2', :id => 2)
+
+      context[:results] << raw_result(2, model_name)
+      context[:results] << raw_result(1, model_name)
+
+      allow(model).to receive_messages(:order => model, :where => [instance_1, instance_2])
+      search.options[:sql] = {:order => 'name DESC'}
+
+      middleware.call [context]
+
+      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
+        allow(model).to receive_messages :unscoped => relation
+
+        context[:results] << raw_result(1, model_name)
+      end
+
+      it "passes through SQL include options to the relation" do
+        search.options[:sql] = {:include => :association}
+
+        expect(relation).to receive(:includes).with(:association).
+          and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL join options to the relation" do
+        search.options[:sql] = {:joins => :association}
+
+        expect(relation).to receive(:joins).with(:association).and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL order options to the relation" do
+        search.options[:sql] = {:order => 'name DESC'}
+
+        expect(relation).to receive(:order).with('name DESC').and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL select options to the relation" do
+        search.options[:sql] = {:select => :column}
+
+        expect(relation).to receive(:select).with(:column).and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL group options to the relation" do
+        search.options[:sql] = {:group => :column}
+
+        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
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/geographer_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Middlewares; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/geographer'
+require 'thinking_sphinx/float_formatter'
+
+describe ThinkingSphinx::Middlewares::Geographer do
+  let(:app)        { double('app', :call => true) }
+  let(:middleware) { ThinkingSphinx::Middlewares::Geographer.new app }
+  let(:context)    { {:sphinxql => sphinx_sql, :indices => [], :panes => []} }
+  let(:sphinx_sql) { double('sphinx_sql') }
+  let(:search)     { double('search', :options => {}) }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Panes::DistancePane', double
+
+    allow(context).to receive_messages :search => search
+  end
+
+  describe '#call' do
+    context 'no geodistance location provided' do
+      before :each do
+        search.options[:geo] = nil
+      end
+
+      it "doesn't add anything if :geo is nil" do
+        expect(sphinx_sql).not_to receive(:prepend_values)
+
+        middleware.call [context]
+      end
+    end
+
+    context 'geodistance location provided' do
+      before :each do
+        search.options[:geo] = [0.1, 0.2]
+      end
+
+      it "adds the geodist function when given a :geo option" do
+        expect(sphinx_sql).to receive(:prepend_values).
+          with('GEODIST(0.1, 0.2, lat, lng) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
+
+      it "adds the distance pane" do
+        allow(sphinx_sql).to receive_messages :prepend_values => sphinx_sql
+
+        middleware.call [context]
+
+        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'
+
+        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)
+
+        middleware.call [context]
+      end
+
+      it "uses latitude if any index has that but not lat as an attribute" do
+        context[:indices] << double('index',
+          :unique_attribute_names => ['latitude'], :name => 'an_index')
+
+        expect(sphinx_sql).to receive(:prepend_values).
+          with('GEODIST(0.1, 0.2, latitude, lng) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
+
+      it "uses latitude if any index has that but not lat as an attribute" do
+        context[:indices] << double('index',
+          :unique_attribute_names => ['longitude'], :name => 'an_index')
+
+        expect(sphinx_sql).to receive(:prepend_values).
+          with('GEODIST(0.1, 0.2, lat, longitude) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
+
+      it "handles very small values" do
+        search.options[:geo] = [0.0000001, 0.00000000002]
+
+        expect(sphinx_sql).to receive(:prepend_values).
+          with('GEODIST(0.0000001, 0.00000000002, lat, lng) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/glazier_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Middlewares; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/glazier'
+
+describe ThinkingSphinx::Middlewares::Glazier do
+  let(:app)           { double('app', :call => true) }
+  let(:middleware)    { ThinkingSphinx::Middlewares::Glazier.new app }
+  let(:context)       { {:results => [result], :indices => [index],
+    :meta => {}, :raw => [raw_result], :panes => []} }
+  let(:result)        { double 'result', :id => 10, :class => model }
+  let(:model)         { double 'model', :name => 'Article' }
+  let(:index)         { double 'index', :name => 'foo_core', :model => model,
+    :primary_key => :id }
+  let(:search)        { double 'search', :options => {} }
+  let(:glazed_result) { double 'glazed result' }
+  let(:raw_result) {
+    {'sphinx_internal_class' => 'Article', 'sphinx_internal_id' => 10} }
+
+  describe '#call' do
+    before :each do
+      stub_const 'ThinkingSphinx::Search::Glaze', double(:new => glazed_result)
+
+      allow(context).to receive_messages :search => search
+    end
+
+    context 'No panes provided' do
+      before :each do
+        context[:panes].clear
+      end
+
+      it "leaves the results as they are" do
+        middleware.call [context]
+
+        expect(context[:results]).to eq([result])
+      end
+    end
+
+    context 'Panes provided' do
+      let(:pane_class) { double('pane class') }
+
+      before :each do
+        context[:panes] << pane_class
+      end
+
+      it "replaces each result with a glazed version" do
+        middleware.call [context]
+
+        expect(context[:results]).to eq([glazed_result])
+      end
+
+      it "creates a glazed result for each result" do
+        expect(ThinkingSphinx::Search::Glaze).to receive(:new).
+          with(context, result, raw_result, [pane_class]).
+          and_return(glazed_result)
+
+        middleware.call [context]
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/inquirer_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module Middlewares; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/inquirer'
+
+describe ThinkingSphinx::Middlewares::Inquirer do
+  let(:app)            { double('app', :call => true) }
+  let(:middleware)     { ThinkingSphinx::Middlewares::Inquirer.new app }
+  let(:context)        { {:sphinxql => sphinx_sql} }
+  let(:sphinx_sql)     { double('sphinx_sql',
+    :to_sql => 'SELECT * FROM index') }
+  let(:batch_inquirer) { double('batcher', :append_query => true,
+    :results => [[:raw], [{'Variable_name' => 'meta', 'Value' => 'value'}]]) }
+
+  before :each do
+    batch_class = double
+    allow(batch_class).to receive(:new).and_return(batch_inquirer)
+
+    stub_const 'Riddle::Query', double(:meta => 'SHOW META')
+    stub_const 'ThinkingSphinx::Search::BatchInquirer', batch_class
+  end
+
+  describe '#call' do
+    it "passes through the SphinxQL from a Riddle::Query::Select object" do
+      expect(batch_inquirer).to receive(:append_query).with('SELECT * FROM index')
+      expect(batch_inquirer).to receive(:append_query).with('SHOW META')
+
+      middleware.call [context]
+    end
+
+    it "sets up the raw results" do
+      middleware.call [context]
+
+      expect(context[:raw]).to eq([:raw])
+    end
+
+    it "sets up the meta results as a hash" do
+      middleware.call [context]
+
+      expect(context[:meta]).to eq({'meta' => 'value'})
+    end
+
+    it "uses the raw values as the initial results" do
+      middleware.call [context]
+
+      expect(context[:results]).to eq([:raw])
+    end
+
+    context "with mysql2 result" do
+      class FakeResult
+        include Enumerable
+        def each; [{"fake" => "value"}].each { |m| yield m }; end
+      end
+
+      let(:batch_inquirer) { double('batcher', :append_query => true,
+        :results => [
+          FakeResult.new, [{'Variable_name' => 'meta', 'Value' => 'value'}]
+        ])
+      }
+
+      it "converts the results into an array" do
+        middleware.call [context]
+
+        expect(context[:results]).to be_a Array
+      end
+    end
+  end
+end