thinking-sphinx 3.0.0 → 3.0.1

data/spec/thinking_sphinx/active_record/associations_spec.rb

@@ -16,7 +16,8 @@ describe ThinkingSphinx::ActiveRecord::Associations do
     double 'join',
       :join_type=         => nil,
       :aliased_table_name => table_alias,
-      :reflection         => double('reflection')
+      :reflection         => double('reflection'),
+      :conditions         => []
   end
 
   def model_double(table_name = nil)

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

@@ -46,7 +46,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      config.stub :indices_for_references => [index]
+      ThinkingSphinx::IndexSet.stub :new => [index]
     end
 
     context 'without delta indices' do
@@ -72,7 +72,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
       before :each do
         ThinkingSphinx::Deltas.stub :suspended? => false
 
-        config.stub :indices_for_references => [core_index, delta_index]
+        ThinkingSphinx::IndexSet.stub :new => [core_index, delta_index]
       end
 
       it "only indexes delta indices" do
@@ -127,7 +127,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      config.stub :indices_for_references => [index]
+      ThinkingSphinx::IndexSet.stub :new => [index]
     end
 
     it "sets delta to true if there are delta indices" do

data/spec/thinking_sphinx/active_record/column_spec.rb

@@ -8,6 +8,29 @@ describe ThinkingSphinx::ActiveRecord::Column do
     end
   end
 
+  describe '#__replace' do
+    let(:base)         { [:a, :b] }
+    let(:replacements) { [[:a, :c], [:a, :d]] }
+
+    it "returns itself when it's a string column" do
+      column = ThinkingSphinx::ActiveRecord::Column.new('foo')
+      column.__replace(base, replacements).collect(&:__path).
+        should == [['foo']]
+    end
+
+    it "returns itself when the base of the stack does not match" do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:b, :c)
+      column.__replace(base, replacements).collect(&:__path).
+        should == [[:b, :c]]
+    end
+
+    it "returns an array of new columns " do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:a, :b, :e)
+      column.__replace(base, replacements).collect(&:__path).
+        should == [[:a, :c, :e], [:a, :d, :e]]
+    end
+  end
+
   describe '#__stack' do
     it "returns all but the top item" do
       column = ThinkingSphinx::ActiveRecord::Column.new(:users, :posts, :id)

data/spec/thinking_sphinx/active_record/database_adapters_spec.rb

@@ -89,6 +89,24 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
         adapter_type_for(model).should == :postgresql
     end
 
+    it "translates a JDBC adapter with MySQL connection string to MySQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == :mysql
+    end
+
+    it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
+
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model).should == :postgresql
+    end
+
     it "returns other JDBC adapters without translation" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
       connection.stub(:config => {:adapter => 'jdbcmssql'})

data/spec/thinking_sphinx/active_record/filtered_reflection_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::FilteredReflection do
+  describe '.clone_with_filter' do
+    let(:reflection) { double('Reflection', :macro => :has_some,
+      :options => options, :active_record => double, :name => 'baz',
+      :foreign_type => :foo_type) }
+    let(:options)    { {:polymorphic => true} }
+    let(:filtered_reflection) { double }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.stub(
+        :new => filtered_reflection
+      )
+
+      reflection.active_record.stub_chain(:connection, :quote_column_name).
+        and_return('"foo_type"')
+    end
+
+    it "uses the existing reflection's macro" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new).
+        with(:has_some, anything, anything, anything)
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "uses the supplied name" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new).
+        with(anything, 'foo_bar', anything, anything)
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "uses the existing reflection's parent" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new).
+        with(anything, anything, anything, reflection.active_record)
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "removes the polymorphic setting from the options" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:polymorphic].should be_nil
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "adds the class name option" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:class_name].should == 'Bar'
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "sets the foreign key if necessary" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:foreign_key].should == 'baz_id'
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "respects supplied foreign keys" do
+      options[:foreign_key] = 'qux_id'
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:foreign_key].should == 'qux_id'
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "sets conditions if there are none" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == "::ts_join_alias::.\"foo_type\" = 'Bar'"
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "appends to the conditions array" do
+      options[:conditions] = ['existing']
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == ['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"]
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "extends the conditions hash" do
+      options[:conditions] = {:x => :y}
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == {:x => :y, :foo_type => 'Bar'}
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "appends to the conditions string" do
+      options[:conditions] = 'existing'
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == "existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'"
+      end
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "returns the new reflection" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+        reflection, 'foo_bar', 'Bar'
+      ).should == filtered_reflection
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Polymorpher do
+  let(:polymorpher) { ThinkingSphinx::ActiveRecord::Polymorpher.new source,
+    column, class_names }
+  let(:source)      { double 'Source', :model => outer, :fields => [field],
+    :attributes => [attribute] }
+  let(:column)      { double 'Column', :__name => :foo, :__stack => [:a, :b],
+    :__path => [:a, :b, :foo] }
+  let(:class_names) { %w( Article Animal ) }
+  let(:field)       { double :rebase => true }
+  let(:attribute)   { double :rebase => true }
+  let(:outer)       { double :reflections => {:a => double(:klass => inner)} }
+  let(:inner)       { double :reflections => {:b => double(:klass => model)} }
+  let(:model)       { double 'Model', :reflections => {:foo => reflection} }
+  let(:reflection)  { double 'Polymorphic Reflection' }
+
+  describe '#morph!' do
+    let(:article_reflection) { double 'Article Reflection' }
+    let(:animal_reflection)  { double 'Animal Reflection' }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.
+        stub(:clone_with_filter).
+        and_return(article_reflection, animal_reflection)
+    end
+
+    it "creates a new reflection for each class" do
+      ThinkingSphinx::ActiveRecord::FilteredReflection.
+        unstub :clone_with_filter
+
+      ThinkingSphinx::ActiveRecord::FilteredReflection.
+        should_receive(:clone_with_filter).
+        with(reflection, :foo_article, 'Article').
+        and_return(article_reflection)
+      ThinkingSphinx::ActiveRecord::FilteredReflection.
+        should_receive(:clone_with_filter).
+        with(reflection, :foo_animal, 'Animal').
+        and_return(animal_reflection)
+
+      polymorpher.morph!
+    end
+
+    it "adds the new reflections to the end-of-stack model" do
+      polymorpher.morph!
+
+      model.reflections[:foo_article].should == article_reflection
+      model.reflections[:foo_animal].should  == animal_reflection
+    end
+
+    it "rebases each field" do
+      field.should_receive(:rebase).with([:a, :b, :foo],
+        :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
+
+      polymorpher.morph!
+    end
+
+    it "rebases each attribute" do
+      attribute.should_receive(:rebase).with([:a, :b, :foo],
+        :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
+
+      polymorpher.morph!
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/property_sql_presenter_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
-  let(:adapter)      { double('adapter') }
-  let(:associations) {
-    double('associations', :alias_for => 'articles', :aggregate_for? => false)
-  }
+  let(:adapter)      { double 'adapter' }
+  let(:associations) { double 'associations', :alias_for => 'articles',
+    :aggregate_for? => false, :model_for => model }
+  let(:model)        { double :column_names => ['title', 'created_at'] }
 
   before :each do
     adapter.stub(:quote) { |column| column }
@@ -83,6 +83,18 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
         presenter.to_select.
           should == "CONCAT_WS(' ', articles.title, articles.title) AS title"
       end
+
+      it "does not include columns that don't exist" do
+        adapter.stub :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+
+        field.stub!(:columns => [column, double('column', :string? => false,
+          :__stack => [], :__name => 'body')])
+
+        presenter.to_select.
+          should == "CONCAT_WS(' ', articles.title) AS title"
+      end
     end
   end
 
@@ -157,6 +169,18 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
         presenter.to_select.
           should == 'UNIX_TIMESTAMP(articles.created_at) AS created_at'
       end
+
+      it "does not include columns that don't exist" do
+        adapter.stub :concatenate do |clause, separator|
+          "CONCAT_WS('#{separator}', #{clause})"
+        end
+
+        attribute.stub!(:columns => [column, double('column',
+          :string? => false, :__stack => [], :__name => 'updated_at')])
+
+        presenter.to_select.
+          should == "CONCAT_WS(' ', articles.created_at) AS created_at"
+      end
     end
   end
 end

data/spec/thinking_sphinx/active_record/sql_builder_spec.rb

@@ -34,13 +34,23 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
     end
 
     it "adds source associations to the joins of the query" do
-      source.associations << double('association', :stack => [:user, :posts])
+      source.associations << double('association',
+        :stack => [:user, :posts], :string? => false)
 
       associations.should_receive(:add_join_to).with([:user, :posts])
 
       builder.sql_query
     end
 
+    it "adds string joins directly to the relation" do
+      source.associations << double('association',
+        :to_s => 'my string', :string? => true)
+
+      relation.should_receive(:joins).with(['my string']).and_return(relation)
+
+      builder.sql_query
+    end
+
     context 'MySQL adapter' do
       before :each do
         source.stub! :type => 'mysql'

data/spec/thinking_sphinx/configuration_spec.rb

@@ -94,6 +94,18 @@ describe ThinkingSphinx::Configuration do
       config.searchd.query_log.
         should == File.join(Rails.root, 'log', 'test.searchd.query.log')
     end
+
+    it "sets indexer settings if within thinking_sphinx.yml" do
+      write_configuration 'mem_limit' => '128M'
+
+      config.indexer.mem_limit.should == '128M'
+    end
+
+    it "sets searchd settings if within thinking_sphinx.yml" do
+      write_configuration 'workers' => 'none'
+
+      config.searchd.workers.should == 'none'
+    end
   end
 
   describe '#next_offset' do
@@ -311,4 +323,16 @@ describe ThinkingSphinx::Configuration do
       end
     end
   end
+
+  describe '#version' do
+    it "defaults to 2.0.6" do
+      config.version.should == '2.0.6'
+    end
+
+    it "respects supplied YAML versions" do
+      write_configuration 'version' => '2.0.4'
+
+      config.version.should == '2.0.4'
+    end
+  end
 end

data/spec/thinking_sphinx/connection_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Connection do
+  describe '.take' do
+    let(:pool)             { double }
+    let(:connection)       { double }
+    let(:error)            { Mysql2::Error.new '' }
+    let(:translated_error) { ThinkingSphinx::SphinxError.new }
+
+    before :each do
+      ThinkingSphinx::Connection.stub :pool => pool
+      ThinkingSphinx::SphinxError.stub :new_from_mysql => translated_error
+      pool.stub(:take).and_yield(connection)
+    end
+
+    it "yields a connection from the pool" do
+      ThinkingSphinx::Connection.take do |c|
+        c.should == connection
+      end
+    end
+
+    it "retries errors once" do
+      tries = 0
+
+      lambda {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 2
+        end
+      }.should_not raise_error
+    end
+
+    it "retries errors twice" do
+      tries = 0
+
+      lambda {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 3
+        end
+      }.should_not raise_error
+    end
+
+    it "raises a translated error if it fails three times" do
+      tries = 0
+
+      lambda {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 4
+        end
+      }.should raise_error(translated_error)
+    end
+
+    [ThinkingSphinx::SyntaxError, ThinkingSphinx::ParseError].each do |klass|
+      context klass.name do
+        let(:translated_error) { klass.new }
+
+        it "raises the error" do
+          lambda {
+            ThinkingSphinx::Connection.take { |c| raise error }
+          }.should raise_error(translated_error)
+        end
+
+        it "does not yield the connection more than once" do
+          yields = 0
+
+          begin
+            ThinkingSphinx::Connection.take do |c|
+              yields += 1
+              raise error
+            end
+          rescue klass
+            #
+          end
+
+          yields.should == 1
+        end
+      end
+    end
+  end
+end