thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/active_record/database_adapters_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
@@ -5,21 +7,21 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
 
   describe '.adapter_for' do
     it "returns a MysqlAdapter object for :mysql" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :mysql)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :mysql)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should be_a(
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to be_a(
           ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
         )
     end
 
     it "returns a PostgreSQLAdapter object for :postgresql" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :postgresql)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :postgresql)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should be_a(
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to be_a(
           ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
         )
     end
@@ -29,21 +31,21 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
       adapter_instance = double('adapter instance')
 
       ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = adapter_class
-      adapter_class.stub!(:new => adapter_instance)
+      allow(adapter_class).to receive_messages(:new => adapter_instance)
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model).
-        should == adapter_instance
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)).
+        to eq(adapter_instance)
 
       ThinkingSphinx::ActiveRecord::DatabaseAdapters.default = nil
     end
 
     it "raises an exception for other responses" do
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        stub(:adapter_type_for => :sqlite)
+      allow(ThinkingSphinx::ActiveRecord::DatabaseAdapters).
+        to receive_messages(:adapter_type_for => :sqlite)
 
-      lambda {
+      expect {
         ThinkingSphinx::ActiveRecord::DatabaseAdapters.adapter_for(model)
-      }.should raise_error
+      }.to raise_error(ThinkingSphinx::InvalidDatabaseAdapter)
     end
   end
 
@@ -53,74 +55,74 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters do
     let(:model)      { double('model', :connection => connection) }
 
     it "translates a normal MySQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a MySQL2 adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a normal PostgreSQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
     end
 
     it "translates a JDBC MySQL adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmysql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmysql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:mysql)
     end
 
     it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcpostgresql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcpostgresql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(: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',
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
                                   :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :mysql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(: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',
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbc',
                                   :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == :postgresql
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq(:postgresql)
     end
 
     it "returns other JDBC adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmssql'})
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      allow(connection).to receive_messages(:config => {:adapter => 'jdbcmssql'})
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).should == 'jdbcmssql'
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).to eq('jdbcmssql')
     end
 
     it "returns other unknown adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
+      allow(klass).to receive_messages(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
 
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-        adapter_type_for(model).
-        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
+      expect(ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        adapter_type_for(model)).
+        to eq('ActiveRecord::ConnectionAdapters::FooAdapter')
     end
   end
 end

data/spec/thinking_sphinx/active_record/field_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Field do
@@ -7,16 +9,16 @@ describe ThinkingSphinx::ActiveRecord::Field do
   let(:model)        { double('model') }
 
   before :each do
-    column.stub! :to_a => [column]
+    allow(column).to receive_messages :to_a => [column]
   end
 
   describe '#columns' do
     it 'returns the provided Column object' do
-      field.columns.should == [column]
+      expect(field.columns).to eq([column])
     end
 
     it 'translates symbols to Column objects' do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).with(:title).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).with(:title).
         and_return(column)
 
       ThinkingSphinx::ActiveRecord::Field.new model, :title
@@ -25,25 +27,25 @@ describe ThinkingSphinx::ActiveRecord::Field do
 
   describe '#file?' do
     it "defaults to false" do
-      field.should_not be_file
+      expect(field).not_to be_file
     end
 
     it "is true if file option is set" do
       field = ThinkingSphinx::ActiveRecord::Field.new model, column,
         :file => true
-      field.should be_file
+      expect(field).to be_file
     end
   end
 
   describe '#with_attribute?' do
     it "defaults to false" do
-      field.should_not be_with_attribute
+      expect(field).not_to be_with_attribute
     end
 
     it "is true if the field is sortable" do
       field = ThinkingSphinx::ActiveRecord::Field.new model, column,
         :sortable => true
-      field.should be_with_attribute
+      expect(field).to be_with_attribute
     end
   end
 end

data/spec/thinking_sphinx/active_record/filter_reflection_spec.rb

@@ -1,37 +1,67 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::FilterReflection do
   describe '.call' do
     let(:reflection) { double('Reflection', :macro => :has_some,
       :options => options, :active_record => double, :name => 'baz',
-      :foreign_type => :foo_type, :class => reflection_klass) }
+      :foreign_type => :foo_type, :class => original_klass,
+      :build_join_constraint => nil) }
     let(:options)    { {:polymorphic => true} }
     let(:filtered_reflection) { double 'filtered reflection' }
-    let(:reflection_klass)    { double :new => filtered_reflection,
-      :instance_method => initialize_method }
-    let(:initialize_method)   { double :arity => 4 }
+    let(:original_klass)      { double }
+    let(:subclass)            { double :include => true }
 
     before :each do
-      reflection.active_record.stub_chain(:connection, :quote_column_name).
+      allow(reflection.active_record).to receive_message_chain(:connection, :quote_column_name).
         and_return('"foo_type"')
+
+      if ActiveRecord::VERSION::STRING.to_f < 5.2
+        allow(original_klass).to receive(:new).and_return(filtered_reflection)
+      else
+        allow(Class).to receive(:new).with(original_klass).and_return(subclass)
+        allow(subclass).to receive(:new).and_return(filtered_reflection)
+      end
+    end
+
+    class ArgumentsWrapper
+      attr_reader :macro, :name, :scope, :options, :parent
+
+      def initialize(*arguments)
+        if ActiveRecord::VERSION::STRING.to_f < 4.0
+          @macro, @name, @options, @parent = arguments
+        elsif ActiveRecord::VERSION::STRING.to_f < 4.2
+          @macro, @name, @scope, @options, @parent = arguments
+        else
+          @name, @scope, @options, @parent = arguments
+        end
+      end
+    end
+
+    def reflection_klass
+      ActiveRecord::VERSION::STRING.to_f < 5.2 ? original_klass : subclass
+    end
+
+    def expected_reflection_arguments
+      expect(reflection_klass).to receive(:new) do |*arguments|
+        yield ArgumentsWrapper.new(*arguments)
+      end
     end
 
     it "uses the existing reflection's macro" do
-      reflection_klass.should_receive(:new).
-        with(:has_some, anything, anything, anything)
+      expect(reflection_klass).to receive(:new) do |macro, *args|
+        expect(macro).to eq(:has_some)
+      end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
         reflection, 'foo_bar', 'Bar'
       )
-    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+    end if ActiveRecord::VERSION::STRING.to_f < 4.2
 
     it "uses the supplied name" do
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new).
-          with('foo_bar', anything, anything, anything)
-      else
-        reflection_klass.should_receive(:new).
-          with(anything, 'foo_bar', anything, anything)
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.name).to eq('foo_bar')
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -40,12 +70,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end
 
     it "uses the existing reflection's parent" do
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new).
-          with(anything, anything, anything, reflection.active_record)
-      else
-        reflection_klass.should_receive(:new).
-          with(anything, anything, anything, reflection.active_record)
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.parent).to eq(reflection.active_record)
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -54,14 +80,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end
 
     it "removes the polymorphic setting from the options" do
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:polymorphic].should be_nil
-        end
-      else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:polymorphic].should be_nil
-        end
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:polymorphic]).to be_nil
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -70,14 +90,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end
 
     it "adds the class name option" do
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:class_name].should == 'Bar'
-        end
-      else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:class_name].should == 'Bar'
-        end
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:class_name]).to eq('Bar')
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -86,14 +100,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     end
 
     it "sets the foreign key if necessary" do
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:foreign_key].should == 'baz_id'
-        end
-      else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:foreign_key].should == 'baz_id'
-        end
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:foreign_key]).to eq('baz_id')
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -104,14 +112,8 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
     it "respects supplied foreign keys" do
       options[:foreign_key] = 'qux_id'
 
-      if defined?(ActiveRecord::Reflection::MacroReflection)
-        reflection_klass.should_receive(:new) do |name, scope, options, parent|
-          options[:foreign_key].should == 'qux_id'
-        end
-      else
-        reflection_klass.should_receive(:new) do |macro, name, options, parent|
-          options[:foreign_key].should == 'qux_id'
-        end
+      expected_reflection_arguments do |wrapper|
+        expect(wrapper.options[:foreign_key]).to eq('qux_id')
       end
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
@@ -119,56 +121,87 @@ describe ThinkingSphinx::ActiveRecord::FilterReflection do
       )
     end
 
-    it "sets conditions if there are none" do
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == "::ts_join_alias::.\"foo_type\" = 'Bar'"
+    if ActiveRecord::VERSION::STRING.to_f < 4.0
+      it "sets conditions if there are none" do
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq("::ts_join_alias::.\"foo_type\" = 'Bar'")
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
       end
 
-      ThinkingSphinx::ActiveRecord::FilterReflection.call(
-        reflection, 'foo_bar', 'Bar'
-      )
-    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+      it "appends to the conditions array" do
+        options[:conditions] = ['existing']
 
-    it "appends to the conditions array" do
-      options[:conditions] = ['existing']
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq(['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"])
+        end
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == ['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"]
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
       end
 
-      ThinkingSphinx::ActiveRecord::FilterReflection.call(
-        reflection, 'foo_bar', 'Bar'
-      )
-    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+      it "extends the conditions hash" do
+        options[:conditions] = {:x => :y}
 
-    it "extends the conditions hash" do
-      options[:conditions] = {:x => :y}
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq({:x => :y, :foo_type => 'Bar'})
+        end
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == {:x => :y, :foo_type => 'Bar'}
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
       end
 
+      it "appends to the conditions string" do
+        options[:conditions] = 'existing'
+
+        expect(reflection_klass).to receive(:new) do |macro, name, options, parent|
+          expect(options[:conditions]).to eq("existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'")
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+    else
+      it "does not add a conditions option" do
+        expected_reflection_arguments do |wrapper|
+          expect(wrapper.options.keys).not_to include(:conditions)
+        end
+
+        ThinkingSphinx::ActiveRecord::FilterReflection.call(
+          reflection, 'foo_bar', 'Bar'
+        )
+      end
+    end
+
+    it "includes custom behaviour in the subclass" do
+      expect(subclass).to receive(:include).with(ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection::BuildJoinConstraint)
+
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
         reflection, 'foo_bar', 'Bar'
       )
-    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+    end if ActiveRecord::VERSION::STRING.to_f > 5.1
 
-    it "appends to the conditions string" do
-      options[:conditions] = 'existing'
+    it "includes custom behaviour in the subclass" do
+      allow(reflection).to receive(:respond_to?).with(:build_join_constraint).
+        and_return(false)
 
-      reflection_klass.should_receive(:new) do |macro, name, options, parent|
-        options[:conditions].should == "existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'"
-      end
+      expect(subclass).to receive(:include).with(ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection::JoinScope)
 
       ThinkingSphinx::ActiveRecord::FilterReflection.call(
         reflection, 'foo_bar', 'Bar'
       )
-    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+    end if ActiveRecord::VERSION::STRING.to_f >= 6.0
 
     it "returns the new reflection" do
-      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection.call(
         reflection, 'foo_bar', 'Bar'
-      ).should == filtered_reflection
+      )).to eq(filtered_reflection)
     end
   end
 end