thinking-sphinx 3.0.5 → 3.0.6

data/spec/internal/app/indices/product_index.rb

@@ -1,5 +1,5 @@
 ThinkingSphinx::Index.define :product, :with => :real_time do
-  indexes name
+  indexes name, :sortable => true
 
   has category_ids, :type => :integer, :multi => true
 end

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -65,6 +65,16 @@ describe ThinkingSphinx::ActiveRecord::Base do
         options[:classes].should == [sub_model, model]
     end
 
+    it "respects provided middleware" do
+      model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
+        options[:middleware].should == ThinkingSphinx::Middlewares::RAW_ONLY
+    end
+
+    it "respects provided masks" do
+      model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
+        masks.should == [ThinkingSphinx::Masks::PaginationMask]
+    end
+
     it "applies the default scope if there is one" do
       model.stub :default_sphinx_scope => :default,
         :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}

data/spec/thinking_sphinx/active_record/callbacks/update_callbacks_spec.rb

@@ -5,8 +5,8 @@ module ThinkingSphinx
 end
 
 require 'active_support/core_ext/string/inflections'
-require 'mysql2/error'
 require 'thinking_sphinx/callbacks'
+require 'thinking_sphinx/errors'
 require 'thinking_sphinx/active_record/callbacks/update_callbacks'
 
 describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
@@ -64,7 +64,8 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
     end
 
     it "doesn't care if the update fails at Sphinx's end" do
-      connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+      connection.stub(:execute).
+        and_raise(ThinkingSphinx::ConnectionError.new(''))
 
       lambda { callbacks.after_update }.should_not raise_error
     end

data/spec/thinking_sphinx/active_record/database_adapters/mysql_adapter_spec.rb

@@ -43,7 +43,7 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter do
   describe '#group_concatenate' do
     it "group concatenates the clause with the given separator" do
       adapter.group_concatenate('foo', ',').
-        should == "GROUP_CONCAT(foo SEPARATOR ',')"
+        should == "GROUP_CONCAT(DISTINCT foo SEPARATOR ',')"
     end
   end
 end

data/spec/thinking_sphinx/active_record/database_adapters/postgresql_adapter_spec.rb

@@ -30,7 +30,7 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
 
     it "converts to bigint unix timestamps" do
       ThinkingSphinx::Configuration.instance.settings['64bit_timestamps'] = true
-      
+
       adapter.cast_to_timestamp('created_at').
         should == 'extract(epoch from created_at)::bigint'
     end
@@ -52,7 +52,7 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
   describe '#group_concatenate' do
     it "group concatenates the clause with the given separator" do
       adapter.group_concatenate('foo', ',').
-        should == "array_to_string(array_agg(foo), ',')"
+        should == "array_to_string(array_agg(DISTINCT foo), ',')"
     end
   end
 end

data/spec/thinking_sphinx/active_record/field_spec.rb

@@ -10,6 +10,19 @@ describe ThinkingSphinx::ActiveRecord::Field do
     column.stub! :to_a => [column]
   end
 
+  describe '#columns' do
+    it 'returns the provided Column object' do
+      field.columns.should == [column]
+    end
+
+    it 'translates symbols to Column objects' do
+      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).with(:title).
+        and_return(column)
+
+      ThinkingSphinx::ActiveRecord::Field.new model, :title
+    end
+  end
+
   describe '#file?' do
     it "defaults to false" do
       field.should_not be_file

data/spec/thinking_sphinx/active_record/property_sql_presenter_spec.rb

@@ -222,6 +222,19 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
         presenter.to_select.should == "CONCAT_WS(',', CAST(articles.created_at AS varchar), CAST(articles.created_at AS varchar)) AS created_at"
       end
 
+      it "double-casts and concatenates multiple columns for timestamp attributes" do
+        adapter.stub :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+        adapter.stub :cast_to_string do |clause|
+          "CAST(#{clause} AS varchar)"
+        end
+
+        attribute.stub :columns => [column, column], :type => :timestamp
+
+        presenter.to_select.should == "CONCAT_WS(',', CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar), CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar)) AS created_at"
+      end
+
       it "returns nil for query sourced attributes" do
         attribute.stub :source_type => :query
 

data/spec/thinking_sphinx/active_record/sql_builder_spec.rb

@@ -4,14 +4,15 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
   let(:source)       { double('source', :model => model, :offset => 3,
     :fields => [], :attributes => [], :disable_range? => false,
     :delta_processor => nil, :conditions => [], :groupings => [],
-    :adapter => adapter, :associations => [], :primary_key => :id) }
+    :adapter => adapter, :associations => [], :primary_key => :id,
+    :options => {}) }
   let(:model)        { double('model', :connection => connection,
     :descends_from_active_record? => true, :column_names => [],
     :inheritance_column => 'type', :unscoped => relation,
     :quoted_table_name => '`users`', :name => 'User') }
   let(:connection)   { double('connection') }
   let(:relation)     { double('relation') }
-  let(:config)       { double('config', :indices => indices) }
+  let(:config)       { double('config', :indices => indices, :settings => {}) }
   let(:indices)      { double('indices', :count => 5) }
   let(:presenter)    { double('presenter', :to_select => '`name` AS `name`',
     :to_group => '`name`') }
@@ -395,6 +396,55 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
         builder.sql_query
       end
 
+      context 'group by shortcut' do
+        before :each do
+          source.options[:minimal_group_by?] = true
+        end
+
+        it "groups by the primary key" do
+          relation.should_receive(:group) do |string|
+            string.should match(/"users"."id"/)
+            relation
+          end
+
+          builder.sql_query
+        end
+
+        it "does not group by fields" do
+          source.fields << double('field')
+
+          relation.should_receive(:group) do |string|
+            string.should_not match(/"name"/)
+            relation
+          end
+
+          builder.sql_query
+        end
+
+        it "does not group by attributes" do
+          source.attributes << double('attribute')
+          presenter.stub!(:to_group => '"created_at"')
+
+          relation.should_receive(:group) do |string|
+            string.should_not match(/"created_at"/)
+            relation
+          end
+
+          builder.sql_query
+        end
+
+        it "groups by source groupings" do
+          source.groupings << '"latitude"'
+
+          relation.should_receive(:group) do |string|
+            string.should match(/"latitude"/)
+            relation
+          end
+
+          builder.sql_query
+        end
+      end
+
       context 'STI model' do
         before :each do
           model.column_names << 'type'
@@ -546,6 +596,16 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
 
       builder.sql_query_pre.should_not include('SET UTF8')
     end
+
+    it "adds a time-zone query by default" do
+      expect(builder.sql_query_pre).to include('SET TIME ZONE')
+    end
+
+    it "does not add a time-zone query if requested" do
+      config.settings['skip_time_zone'] = true
+
+      expect(builder.sql_query_pre).to_not include('SET TIME ZONE')
+    end
   end
 
   describe 'sql_query_range' do

data/spec/thinking_sphinx/configuration_spec.rb

@@ -40,7 +40,7 @@ describe ThinkingSphinx::Configuration do
       config = ThinkingSphinx::Configuration.instance
       config.settings['foo'].should == 'bugs'
 
-      config.framework = double :environment => 'production', :root => '/tmp/'
+      config.framework = double :environment => 'production', :root => Pathname.new(__FILE__).join('..', '..', 'internal')
       config.settings['foo'].should == 'bar'
     end
   end

data/spec/thinking_sphinx/deletion_spec.rb

@@ -41,7 +41,8 @@ describe ThinkingSphinx::Deletion do
       end
 
       it "doesn't care about Sphinx errors" do
-        connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+        connection.stub(:execute).
+          and_raise(ThinkingSphinx::ConnectionError.new(''))
 
         lambda {
           ThinkingSphinx::Deletion.perform index, instance
@@ -62,7 +63,8 @@ describe ThinkingSphinx::Deletion do
       end
 
       it "doesn't care about Sphinx errors" do
-        connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+        connection.stub(:execute).
+          and_raise(ThinkingSphinx::ConnectionError.new(''))
 
         lambda {
           ThinkingSphinx::Deletion.perform index, instance

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -57,7 +57,8 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     end
 
     it "doesn't care about Sphinx errors" do
-      connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+      connection.stub(:execute).
+        and_raise(ThinkingSphinx::ConnectionError.new(''))
 
       lambda { delta.delete index, instance }.should_not raise_error
     end

data/spec/thinking_sphinx/deltas_spec.rb

@@ -11,7 +11,7 @@ describe ThinkingSphinx::Deltas do
       klass = Class.new
       ThinkingSphinx::Deltas.processor_for(klass).should == klass
     end
-    
+
     it "instantiates a class from the name as a string" do
       ThinkingSphinx::Deltas.
         processor_for('ThinkingSphinx::Deltas::DefaultDelta').
@@ -20,10 +20,13 @@ describe ThinkingSphinx::Deltas do
   end
 
   describe '.suspend' do
-    let(:config)     { double('config', :indices_for_references => [index]) }
-    let(:index)      { double('index', :name => 'user_core',
-      :delta_processor => processor) }
-    let(:processor)  { double('processor', :index => true) }
+    let(:config)      { double('config',
+      :indices_for_references => [core_index, delta_index]) }
+    let(:core_index)  { double('index', :name => 'user_core',
+      :delta_processor => processor, :delta? => false) }
+    let(:delta_index) { double('index', :name => 'user_core',
+      :delta_processor => processor, :delta? => true) }
+    let(:processor)   { double('processor', :index => true) }
 
     before :each do
       ThinkingSphinx::Configuration.stub :instance => config
@@ -54,7 +57,15 @@ describe ThinkingSphinx::Deltas do
     end
 
     it "processes the delta indices for the given reference" do
-      processor.should_receive(:index).with(index)
+      processor.should_receive(:index).with(delta_index)
+
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+    end
+
+    it "does not process the core indices for the given reference" do
+      processor.should_not_receive(:index).with(core_index)
 
       ThinkingSphinx::Deltas.suspend :user do
         #

data/spec/thinking_sphinx/errors_spec.rb

@@ -26,6 +26,13 @@ describe ThinkingSphinx::SphinxError do
         should be_a(ThinkingSphinx::QueryError)
     end
 
+    it "translates connection errors" do
+      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+
+      ThinkingSphinx::SphinxError.new_from_mysql(error).
+        should be_a(ThinkingSphinx::ConnectionError)
+    end
+
     it "defaults to sphinx errors" do
       error.stub :message => 'index foo: unknown error: something is wrong'
 

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -29,12 +29,12 @@ 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,
-        '@count'                => 5,
-        '@groupby'              => 2
+        'sphinx_internal_class'           => 'Foo',
+        'price_bracket'                   => 3,
+        'tag_ids'                         => '1,2',
+        'category_id'                     => 11,
+        ThinkingSphinx::SphinxQL.count    => 5,
+        ThinkingSphinx::SphinxQL.group_by => 2
       }]
     end
   end

data/spec/thinking_sphinx/masks/scopes_mask_spec.rb

@@ -65,4 +65,68 @@ describe ThinkingSphinx::Masks::ScopesMask do
       mask.search.object_id.should == 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')
+
+      mask.search_for_ids('bar')
+    end
+
+    it "keeps the existing query when only options are offered" do
+      search.should_not_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'}
+
+      search.options[:conditions].should == {:foo => 'bar', :baz => 'qux'}
+    end
+
+    it "merges filters" do
+      search.options[:with] = {:foo => :bar}
+
+      mask.search_for_ids :with => {:baz => :qux}
+
+      search.options[:with].should == {:foo => :bar, :baz => :qux}
+    end
+
+    it "merges exclusive filters" do
+      search.options[:without] = {:foo => :bar}
+
+      mask.search_for_ids :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_for_ids :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_for_ids :retry_stale => 6
+
+      search.options[:retry_stale].should == 6
+    end
+
+    it "adds the ids_only option" do
+      mask.search_for_ids
+
+      search.options[:ids_only].should be_true
+    end
+
+    it "returns the original search object" do
+      mask.search_for_ids.object_id.should == search.object_id
+    end
+  end
 end

data/spec/thinking_sphinx/middlewares/active_record_translator_spec.rb

@@ -73,7 +73,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
     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)
+      instance_2 = double('instance 2', :id => 2)
 
       context[:results] << raw_result(2, model_name)
       context[:results] << raw_result(1, model_name)
@@ -85,6 +85,22 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results].should == [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)
+
+      model.stub(:order => model, :where => [instance_1, instance_2])
+      search.options[:sql] = {:order => 'name DESC'}
+
+      middleware.call [context]
+
+      context[:results].should == [instance_1, instance_2]
+    end
+
     context 'SQL options' do
       let(:relation) { double('relation', :where => []) }
 

data/spec/thinking_sphinx/middlewares/geographer_spec.rb

@@ -4,6 +4,7 @@ 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) }
@@ -84,6 +85,16 @@ describe ThinkingSphinx::Middlewares::Geographer do
 
         middleware.call [context]
       end
+
+      it "handles very small values" do
+        search.options[:geo] = [0.0000001, 0.00000000002]
+
+        sphinx_sql.should_receive(:values).
+          with('GEODIST(0.0000001, 0.00000000002, lat, lng) AS geodist').
+          and_return(sphinx_sql)
+
+        middleware.call [context]
+      end
     end
   end
 end