thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/masks/scopes_mask_spec.rb

@@ -0,0 +1,68 @@
+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) }
+  let(:mask)   { ThinkingSphinx::Masks::ScopesMask.new search }
+
+  describe '#search' do
+    it "replaces the query if one is supplied" do
+      search.should_receive(:query=).with('bar')
+
+      mask.search('bar')
+    end
+
+    it "keeps the existing query when only options are offered" do
+      search.should_not_receive(:query=)
+
+      mask.search :with => {:foo => :bar}
+    end
+
+    it "merges conditions" do
+      search.options[:conditions] = {:foo => 'bar'}
+
+      mask.search :conditions => {:baz => 'qux'}
+
+      search.options[:conditions].should == {:foo => 'bar', :baz => 'qux'}
+    end
+
+    it "merges filters" do
+      search.options[:with] = {:foo => :bar}
+
+      mask.search :with => {:baz => :qux}
+
+      search.options[:with].should == {:foo => :bar, :baz => :qux}
+    end
+
+    it "merges exclusive filters" do
+      search.options[:without] = {:foo => :bar}
+
+      mask.search :without => {:baz => :qux}
+
+      search.options[:without].should == {:foo => :bar, :baz => :qux}
+    end
+
+    it "appends excluded ids" do
+      search.options[:without_ids] = [1, 3]
+
+      mask.search :without_ids => [5, 7]
+
+      search.options[:without_ids].should == [1, 3, 5, 7]
+    end
+
+    it "replaces the retry_stale option" do
+      search.options[:retry_stale] = true
+
+      mask.search :retry_stale => 6
+
+      search.options[:retry_stale].should == 6
+    end
+
+    it "returns the original search object" do
+      mask.search.object_id.should == search.object_id
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/active_record_translator_spec.rb

@@ -0,0 +1,132 @@
+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') }
+  let(:search)     { double('search', :options => {}) }
+
+  def raw_result(id, model_name)
+    {'sphinx_internal_id' => id, 'sphinx_internal_class' => model_name}
+  end
+
+  describe '#call' do
+    before :each do
+      context.stub :search => search
+      model.stub :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]
+
+      context[:results] << raw_result(24, model_name)
+
+      middleware.call [context]
+
+      context[:results].should == [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)
+
+      model.should_receive(:where).once.and_return([instance_a, instance_b])
+
+      middleware.call [context]
+    end
+
+    it "handles multiple models" do
+      article_model = double('article model')
+      article_name  = double('article name', :constantize => article_model)
+      article       = double('article instance', :id => 24)
+
+      user_model    = double('user model')
+      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
+
+      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])
+
+      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 1', :id => 2)
+
+      context[:results] << raw_result(2, model_name)
+      context[:results] << raw_result(1, model_name)
+
+      model.stub(:where => [instance_1, instance_2])
+
+      middleware.call [context]
+
+      context[:results].should == [instance_2, instance_1]
+    end
+
+    context 'SQL options' do
+      let(:relation) { double('relation', :where => []) }
+
+      before :each do
+        model.stub :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).
+          and_return(relation)
+
+        middleware.call [context]
+      end
+
+      it "passes through SQL join options to the relation" do
+        search.options[:sql] = {:joins => :association}
+
+        relation.should_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'}
+
+        relation.should_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}
+
+        relation.should_receive(:select).with(:column).and_return(relation)
+
+        middleware.call [context]
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/geographer_spec.rb

@@ -0,0 +1,89 @@
+module ThinkingSphinx
+  module Middlewares; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/geographer'
+
+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
+
+    context.stub :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
+        sphinx_sql.should_not_receive(: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
+        sphinx_sql.should_receive(: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
+        sphinx_sql.stub :values => sphinx_sql
+
+        middleware.call [context]
+
+        context[:panes].should 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(: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')
+
+        sphinx_sql.should_receive(: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')
+
+        sphinx_sql.should_receive(:values).
+          with('GEODIST(0.1, 0.2, lat, longitude) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/glazier_spec.rb

@@ -0,0 +1,62 @@
+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 => double(:name => 'Article')) }
+  let(:index)         { double('index', :name => 'foo_core') }
+  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)
+
+      context.stub :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]
+
+        context[:results].should == [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]
+
+        context[:results].should == [glazed_result]
+      end
+
+      it "creates a glazed result for each result" do
+        ThinkingSphinx::Search::Glaze.should_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,55 @@
+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
+    context.stub(:log) do |notification, message, &block|
+      block.call unless block.nil?
+    end
+
+    batch_class = double
+    batch_class.stub(: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
+      batch_inquirer.should_receive(:append_query).with('SELECT * FROM index')
+      batch_inquirer.should_receive(:append_query).with('SHOW META')
+
+      middleware.call [context]
+    end
+
+    it "sets up the raw results" do
+      middleware.call [context]
+
+      context[:raw].should == [:raw]
+    end
+
+    it "sets up the meta results as a hash" do
+      middleware.call [context]
+
+      context[:meta].should == {'meta' => 'value'}
+    end
+
+    it "uses the raw values as the initial results" do
+      middleware.call [context]
+
+      context[:results].should == [:raw]
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/sphinxql_spec.rb

@@ -0,0 +1,271 @@
+module ThinkingSphinx
+  module Middlewares; end
+end
+
+module ActiveRecord
+  class Base; end
+end
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/sphinxql'
+
+describe ThinkingSphinx::Middlewares::SphinxQL do
+  let(:app)           { double('app', :call => true) }
+  let(:middleware)    { ThinkingSphinx::Middlewares::SphinxQL.new app }
+  let(:context)       { {} }
+  let(:search)        { double('search', :query => '', :options => {},
+    :offset => 0, :per_page => 5) }
+  let(:index_set)     { [] }
+  let(:sphinx_sql)    { double('sphinx_sql', :from => true, :offset => true,
+    :limit => true, :where => true, :matching => true) }
+  let(:query)         { double('query') }
+
+  before :each do
+    stub_const 'Riddle::Query::Select', double(:new => sphinx_sql)
+    stub_const 'ThinkingSphinx::Search::Query', double(:new => query)
+    stub_const 'ThinkingSphinx::Masks::GroupEnumeratorsMask', double
+    stub_const 'ThinkingSphinx::IndexSet', double(:new => index_set)
+
+    context.stub :search => search
+  end
+
+  describe '#call' do
+    it "uses the indexes for the FROM clause" do
+      index_set.replace [
+        double('index', :name => 'article_core'),
+        double('index', :name => 'user_core')
+      ]
+
+      sphinx_sql.should_receive(:from).with('`article_core`', '`user_core`').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "finds index objects for the given models and indices options" do
+      klass = double(:column_names => [], :inheritance_column => 'type',
+        :name => 'User')
+      search.options[:classes] = [klass]
+      search.options[:indices] = ['user_core']
+
+      ThinkingSphinx::IndexSet.should_receive(:new).
+        with([klass], ['user_core']).and_return(index_set)
+
+      middleware.call [context]
+    end
+
+    it "generates a Sphinx query from the provided keyword and conditions" do
+      search.stub :query => 'tasty'
+      search.options[:conditions] = {:title => 'pancakes'}
+
+      ThinkingSphinx::Search::Query.should_receive(:new).
+        with('tasty', {:title => 'pancakes'}, anything).and_return(query)
+
+      middleware.call [context]
+    end
+
+    it "matches on the generated query" do
+      query.stub :to_s => 'waffles'
+
+      sphinx_sql.should_receive(:matching).with('waffles')
+
+      middleware.call [context]
+    end
+
+    it "requests a starred query if the :star option is set to true" do
+      search.options[:star] = true
+
+      ThinkingSphinx::Search::Query.should_receive(:new).
+        with(anything, anything, true).and_return(query)
+
+      middleware.call [context]
+    end
+
+    it "appends field conditions for the class when searching on 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 => []
+
+      search.options[:classes] = [submodel]
+
+      ThinkingSphinx::Search::Query.should_receive(:new).with(anything,
+        hash_including(:sphinx_internal_class => '(Lion)'), anything).
+        and_return(query)
+
+      middleware.call [context]
+    end
+
+    it "does not query the database for subclasses if :skip_sti is set to true" do
+      model = double('model', :connection => double,
+        :ancestors => [ActiveRecord::Base], :name => 'Animal')
+
+      search.options[:classes]  = [model]
+      search.options[:skip_sti] = true
+
+      model.connection.should_not_receive(:select_values)
+
+      middleware.call [context]
+    end
+
+    it "filters out deleted values by default" do
+      sphinx_sql.should_receive(:where).with(:sphinx_deleted => false).
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends boolean attribute filters to the query" do
+      search.options[:with] = {:visible => true}
+
+      sphinx_sql.should_receive(:where).with(hash_including(:visible => true)).
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends exclusive filters to the query" do
+      search.options[:without] = {:tag_ids => [2, 4, 8]}
+
+      sphinx_sql.should_receive(:where_not).
+        with(hash_including(:tag_ids => [2, 4, 8])).and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends the without_ids option as an exclusive filter" do
+      search.options[:without_ids] = [1, 4, 9]
+
+      sphinx_sql.should_receive(:where_not).
+        with(hash_including(:sphinx_internal_id => [1, 4, 9])).
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends MVA matches with all values" do
+      search.options[:with_all] = {:tag_ids => [1, 7]}
+
+      sphinx_sql.should_receive(:where_all).
+        with(:tag_ids => [1, 7]).and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends MVA matches without all of the given values" do
+      search.options[:without_all] = {:tag_ids => [1, 7]}
+
+      sphinx_sql.should_receive(:where_not_all).
+        with(:tag_ids => [1, 7]).and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends order clauses to the query" do
+      search.options[:order] = 'created_at ASC'
+
+      sphinx_sql.should_receive(:order_by).with('created_at ASC').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "presumes attributes given as symbols should be sorted ascendingly" do
+      search.options[:order] = :updated_at
+
+      sphinx_sql.should_receive(:order_by).with('updated_at ASC').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "appends a group by clause to the query" do
+      search.options[:group_by] = :foreign_id
+      search.stub :masks => []
+      sphinx_sql.stub :values => sphinx_sql
+
+      sphinx_sql.should_receive(:group_by).with('foreign_id').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "adds the group enumerator mask when using :group_by" do
+      search.options[:group_by] = :foreign_id
+      search.stub :masks => []
+      sphinx_sql.stub :group_by => sphinx_sql, :values => sphinx_sql
+
+      middleware.call [context]
+
+      search.masks.should include(ThinkingSphinx::Masks::GroupEnumeratorsMask)
+    end
+
+    it "appends a sort within group clause to the query" do
+      search.options[:order_group_by] = :title
+
+      sphinx_sql.should_receive(:order_within_group_by).with('title ASC').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "uses the provided offset" do
+      search.stub :offset => 50
+
+      sphinx_sql.should_receive(:offset).with(50).and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "uses the provided limit" do
+      search.stub :per_page => 24
+
+      sphinx_sql.should_receive(:limit).with(24).and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "adds the provided select statement" do
+      search.options[:select] = 'foo as bar'
+
+      sphinx_sql.should_receive(:values).with('foo as bar').
+        and_return(sphinx_sql)
+
+      middleware.call [context]
+    end
+
+    it "uses any provided field weights" do
+      search.options[:field_weights] = {:title => 3}
+
+      sphinx_sql.should_receive(:with_options) do |options|
+        options[:field_weights].should == {:title => 3}
+        sphinx_sql
+      end
+
+      middleware.call [context]
+    end
+
+    it "uses any given ranker option" do
+      search.options[:ranker] = 'proximity'
+
+      sphinx_sql.should_receive(:with_options) do |options|
+        options[:ranker].should == 'proximity'
+        sphinx_sql
+      end
+
+      middleware.call [context]
+    end
+  end
+end