thinking-sphinx 3.1.4 → 6.0.0

data/spec/support/mysql.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# New versions of MySQL don't allow NULL values for primary keys, but old
+# versions of Rails do. To use both at the same time, we need to update Rails'
+# default primary key type to no longer have a default NULL value.
+#
+class PatchAdapter
+  def call
+    return unless using_mysql? && using_rails_pre_4_1?
+
+    require 'active_record/connection_adapters/abstract_mysql_adapter'
+    ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::
+      NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
+  end
+
+  def using_mysql?
+    ENV.fetch('DATABASE', 'mysql2') == 'mysql2'
+  end
+
+  def using_rails_pre_4_1?
+    ActiveRecord::VERSION::STRING.to_f < 4.1
+  end
+end
+
+PatchAdapter.new.call

data/spec/support/sphinx_yaml_helpers.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 module SphinxYamlHelpers
   def write_configuration(hash)
-    File.stub :read => {'test' => hash}.to_yaml, :exists? => true
+    allow(File).to receive(:read).and_return({'test' => hash}.to_yaml)
+    allow(File).to receive(:exist?).and_wrap_original do |original, path|
+      next true if path.to_s == File.absolute_path("config/thinking_sphinx.yml", Rails.root.to_s)
+
+      original.call(path)
+    end
   end
 end
 

data/spec/thinking_sphinx/active_record/association_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Association do
@@ -6,7 +8,7 @@ describe ThinkingSphinx::ActiveRecord::Association do
 
   describe '#stack' do
     it "returns the column's stack and name" do
-      association.stack.should == [:users, :post]
+      expect(association.stack).to eq([:users, :post])
     end
   end
 end

data/spec/thinking_sphinx/active_record/attribute/type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module ActiveRecord
     class Attribute; end
@@ -23,52 +25,55 @@ describe ThinkingSphinx::ActiveRecord::Attribute::Type do
     before :each do
       column.__stack << :foo
 
-      model.stub :reflect_on_association => association
+      allow(model).to receive(:reflect_on_association).and_return(association)
     end
 
     it "returns true if there are has_many associations" do
-      association.stub :macro => :has_many
+      allow(association).to receive(:macro).and_return(:has_many)
 
-      type.should be_multi
+      expect(type).to be_multi
     end
 
     it "returns true if there are has_and_belongs_to_many associations" do
-      association.stub :macro => :has_and_belongs_to_many
+      allow(association).to receive(:macro).and_return(:has_and_belongs_to_many)
 
-      type.should be_multi
+      expect(type).to be_multi
     end
 
     it "returns false if there are no associations" do
       column.__stack.clear
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns false if there are only belongs_to associations" do
-      association.stub :macro => :belongs_to
+      allow(association).to receive(:macro).and_return(:belongs_to)
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns false if there are only has_one associations" do
-      association.stub :macro => :has_one
+      allow(association).to receive(:macro).and_return(:has_one)
 
-      type.should_not be_multi
+      expect(type).not_to be_multi
     end
 
     it "returns true if deeper associations have many" do
       column.__stack << :bar
       deep_association = double(:klass => double, :macro => :has_many)
-      association.stub :macro => :belongs_to,
-        :klass => double(:reflect_on_association => deep_association)
 
-      type.should be_multi
+      allow(association).to receive(:macro).and_return(:belongs_to)
+      allow(association).to receive(:klass).and_return(
+        double(:reflect_on_association => deep_association)
+      )
+
+      expect(type).to be_multi
     end
 
     it "respects the provided setting" do
       attribute.options[:multi] = true
 
-      type.should be_multi
+      expect(type).to be_multi
     end
   end
 
@@ -76,79 +81,79 @@ describe ThinkingSphinx::ActiveRecord::Attribute::Type do
     it "returns the type option provided" do
       attribute.options[:type] = :datetime
 
-      type.type.should == :datetime
+      expect(type.type).to eq(:datetime)
     end
 
     it "detects integer types from the database" do
-      db_column.stub!(:type => :integer, :sql_type => 'integer(11)')
+      allow(db_column).to receive_messages(:type => :integer, :sql_type => 'integer(11)')
 
-      type.type.should == :integer
+      expect(type.type).to eq(:integer)
     end
 
     it "detects boolean types from the database" do
-      db_column.stub!(:type => :boolean)
+      allow(db_column).to receive_messages(:type => :boolean)
 
-      type.type.should == :boolean
+      expect(type.type).to eq(:boolean)
     end
 
     it "detects datetime types from the database as timestamps" do
-      db_column.stub!(:type => :datetime)
+      allow(db_column).to receive_messages(:type => :datetime)
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it "detects date types from the database as timestamps" do
-      db_column.stub!(:type => :date)
+      allow(db_column).to receive_messages(:type => :date)
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it "detects string types from the database" do
-      db_column.stub!(:type => :string)
+      allow(db_column).to receive_messages(:type => :string)
 
-      type.type.should == :string
+      expect(type.type).to eq(:string)
     end
 
     it "detects text types from the database as strings" do
-      db_column.stub!(:type => :text)
+      allow(db_column).to receive_messages(:type => :text)
 
-      type.type.should == :string
+      expect(type.type).to eq(:string)
     end
 
     it "detects float types from the database" do
-      db_column.stub!(:type => :float)
+      allow(db_column).to receive_messages(:type => :float)
 
-      type.type.should == :float
+      expect(type.type).to eq(:float)
     end
 
     it "detects decimal types from the database as floats" do
-      db_column.stub!(:type => :decimal)
+      allow(db_column).to receive_messages(:type => :decimal)
 
-      type.type.should == :float
+      expect(type.type).to eq(:float)
     end
 
     it "detects big ints as big ints" do
-      db_column.stub :type => :bigint
+      allow(db_column).to receive_messages :type => :bigint
 
-      type.type.should == :bigint
+      expect(type.type).to eq(:bigint)
     end
 
     it "detects large integers as big ints" do
-      db_column.stub :type => :integer, :sql_type => 'bigint(20)'
+      allow(db_column).to receive_messages :type => :integer, :sql_type => 'bigint(20)'
 
-      type.type.should == :bigint
+      expect(type.type).to eq(:bigint)
     end
 
     it "detects JSON" do
-      db_column.stub :type => :json
+      allow(db_column).to receive_messages :type => :json
 
-      type.type.should == :json
+      expect(type.type).to eq(:json)
     end
 
     it "respects provided type setting" do
       attribute.options[:type] = :timestamp
 
-      type.type.should == :timestamp
+      expect(type.type).to eq(:timestamp)
     end
 
     it 'raises an error if the database column does not exist' do

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Base do
@@ -16,34 +18,34 @@ describe ThinkingSphinx::ActiveRecord::Base do
 
   describe '.facets' do
     it "returns a new search object" do
-      model.facets.should be_a(ThinkingSphinx::FacetSearch)
+      expect(model.facets).to be_a(ThinkingSphinx::FacetSearch)
     end
 
     it "passes through arguments to the search object" do
-      model.facets('pancakes').query.should == 'pancakes'
+      expect(model.facets('pancakes').query).to eq('pancakes')
     end
 
     it "scopes the search to a given model" do
-      model.facets('pancakes').options[:classes].should == [model]
+      expect(model.facets('pancakes').options[:classes]).to eq([model])
     end
 
     it "merges the :classes option with the model" do
-      model.facets('pancakes', :classes => [sub_model]).
-        options[:classes].should == [sub_model, model]
+      expect(model.facets('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
     end
 
     it "applies the default scope if there is one" do
-      model.stub :default_sphinx_scope => :default,
+      allow(model).to receive_messages :default_sphinx_scope => :default,
         :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
 
-      model.facets.options[:order].should == :created_at
+      expect(model.facets.options[:order]).to eq(:created_at)
     end
 
     it "does not apply a default scope if one is not set" do
-      model.stub :default_sphinx_scope => nil,
+      allow(model).to receive_messages :default_sphinx_scope => nil,
         :default => {:order => :created_at}
 
-      model.facets.options[:order].should be_nil
+      expect(model.facets.options[:order]).to be_nil
     end
   end
 
@@ -55,55 +57,55 @@ describe ThinkingSphinx::ActiveRecord::Base do
     end
 
     it "returns a new search object" do
-      model.search.should be_a(ThinkingSphinx::Search)
+      expect(model.search).to be_a(ThinkingSphinx::Search)
     end
 
     it "passes through arguments to the search object" do
-      model.search('pancakes').query.should == 'pancakes'
+      expect(model.search('pancakes').query).to eq('pancakes')
     end
 
     it "scopes the search to a given model" do
-      model.search('pancakes').options[:classes].should == [model]
+      expect(model.search('pancakes').options[:classes]).to eq([model])
     end
 
     it "passes through options to the search object" do
-      model.search('pancakes', populate: true).
-        options[:populate].should be_true
+      expect(model.search('pancakes', populate: true).
+        options[:populate]).to be_truthy
     end
 
     it "should automatically populate when :populate is set to true" do
-      stack.should_receive(:call).and_return(true)
+      expect(stack).to receive(:call).and_return(true)
 
       model.search('pancakes', populate: true)
     end
 
     it "merges the :classes option with the model" do
-      model.search('pancakes', :classes => [sub_model]).
-        options[:classes].should == [sub_model, model]
+      expect(model.search('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
     end
 
     it "respects provided middleware" do
-      model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
-        options[:middleware].should == ThinkingSphinx::Middlewares::RAW_ONLY
+      expect(model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
+        options[:middleware]).to eq(ThinkingSphinx::Middlewares::RAW_ONLY)
     end
 
     it "respects provided masks" do
-      model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
-        masks.should == [ThinkingSphinx::Masks::PaginationMask]
+      expect(model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
+        masks).to eq([ThinkingSphinx::Masks::PaginationMask])
     end
 
     it "applies the default scope if there is one" do
-      model.stub :default_sphinx_scope => :default,
+      allow(model).to receive_messages :default_sphinx_scope => :default,
         :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
 
-      model.search.options[:order].should == :created_at
+      expect(model.search.options[:order]).to eq(:created_at)
     end
 
     it "does not apply a default scope if one is not set" do
-      model.stub :default_sphinx_scope => nil,
+      allow(model).to receive_messages :default_sphinx_scope => nil,
         :default => {:order => :created_at}
 
-      model.search.options[:order].should be_nil
+      expect(model.search.options[:order]).to be_nil
     end
   end
 
@@ -112,18 +114,18 @@ describe ThinkingSphinx::ActiveRecord::Base do
       :populated? => false) }
 
     before :each do
-      ThinkingSphinx.stub :search => search
-      FileUtils.stub :mkdir_p => true
+      allow(ThinkingSphinx).to receive_messages :search => search
+      allow(FileUtils).to receive_messages :mkdir_p => true
     end
 
     it "returns the search object's total entries count" do
-      model.search_count.should == search.total_entries
+      expect(model.search_count).to eq(search.total_entries)
     end
 
     it "scopes the search to a given model" do
       model.search_count
 
-      search.options[:classes].should == [model]
+      expect(search.options[:classes]).to eq([model])
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
@@ -10,20 +12,20 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
     let(:callbacks) { double('callbacks', :after_destroy => nil) }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
-        stub :new => callbacks
+      allow(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive_messages :new => callbacks
     end
 
     it "builds an object from the instance" do
-      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
-        should_receive(:new).with(instance).and_return(callbacks)
+      expect(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive(:new).with(instance).and_return(callbacks)
 
       ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
         after_destroy(instance)
     end
 
     it "invokes after_destroy on the object" do
-      callbacks.should_receive(:after_destroy)
+      expect(callbacks).to receive(:after_destroy)
 
       ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
         after_destroy(instance)
@@ -32,26 +34,95 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
 
   describe '#after_destroy' do
     let(:index_set)  { double 'index set', :to_a => [index] }
-    let(:index)      { double('index', :name => 'foo_core',
+    let(:index)      { double('index', :name => 'foo_core', :primary_key => :id,
       :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
     let(:instance)   { double('instance', :id => 7, :new_record? => false) }
 
     before :each do
-      ThinkingSphinx::IndexSet.stub :new => index_set
+      allow(ThinkingSphinx::IndexSet).to receive_messages :new => index_set
     end
 
     it "performs the deletion for the index and instance" do
-      ThinkingSphinx::Deletion.should_receive(:perform).with(index, 7)
+      expect(ThinkingSphinx::Deletion).to receive(:perform).with(index, 7)
 
       callbacks.after_destroy
     end
 
     it "doesn't do anything if the instance is a new record" do
-      instance.stub :new_record? => true
+      allow(instance).to receive_messages :new_record? => true
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_destroy
+    end
+
+    it 'does nothing if callbacks are suspended' do
+      ThinkingSphinx::Callbacks.suspend!
 
-      ThinkingSphinx::Deletion.should_not_receive(:perform)
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
 
       callbacks.after_destroy
+
+      ThinkingSphinx::Callbacks.resume!
+    end
+  end
+
+  describe '.after_rollback' do
+    let(:callbacks) { double('callbacks', :after_rollback => nil) }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive_messages :new => callbacks
+    end
+
+    it "builds an object from the instance" do
+      expect(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive(:new).with(instance).and_return(callbacks)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_rollback(instance)
+    end
+
+    it "invokes after_rollback on the object" do
+      expect(callbacks).to receive(:after_rollback)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_rollback(instance)
+    end
+  end
+
+  describe '#after_rollback' do
+    let(:index_set)  { double 'index set', :to_a => [index] }
+    let(:index)      { double('index', :name => 'foo_core', :primary_key => :id,
+      :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
+    let(:instance)   { double('instance', :id => 7, :new_record? => false) }
+
+    before :each do
+      allow(ThinkingSphinx::IndexSet).to receive_messages :new => index_set
+    end
+
+    it "performs the deletion for the index and instance" do
+      expect(ThinkingSphinx::Deletion).to receive(:perform).with(index, 7)
+
+      callbacks.after_rollback
+    end
+
+    it "doesn't do anything if the instance is a new record" do
+      allow(instance).to receive_messages :new_record? => true
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_rollback
+    end
+
+    it 'does nothing if callbacks are suspended' do
+      ThinkingSphinx::Callbacks.suspend!
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_rollback
+
+      ThinkingSphinx::Callbacks.resume!
     end
   end
 end