thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/active_record/interpreter_spec.rb

@@ -13,23 +13,23 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
   let(:block)   { Proc.new { } }
 
   before :each do
-    ThinkingSphinx::ActiveRecord::SQLSource.stub! :new => source
-    source.stub :model => model
+    allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages :new => source
+    allow(source).to receive_messages :model => model
   end
 
   describe '.translate!' do
     let(:instance) { double('interpreter', :translate! => true) }
 
     it "creates a new interpreter instance with the given block and index" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:new).
         with(index, block).and_return(instance)
 
       ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
     end
 
     it "calls translate! on the instance" do
-      ThinkingSphinx::ActiveRecord::Interpreter.stub!(:new => instance)
-      instance.should_receive(:translate!)
+      allow(ThinkingSphinx::ActiveRecord::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
 
       ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
     end
@@ -37,13 +37,13 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#group_by' do
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.group_by 'lat'
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.group_by 'lat'
       instance.group_by 'lng'
@@ -52,7 +52,7 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "appends a new grouping statement to the source" do
       instance.group_by 'lat'
 
-      source.groupings.should include('lat')
+      expect(source.groupings).to include('lat')
     end
   end
 
@@ -61,31 +61,31 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:attribute) { double('attribute') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Attribute.stub! :new => attribute
+      allow(ThinkingSphinx::ActiveRecord::Attribute).to receive_messages :new => attribute
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.has column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.has column
       instance.has column
     end
 
     it "creates a new attribute with the provided column" do
-      ThinkingSphinx::ActiveRecord::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
         with(model, column, {}).and_return(attribute)
 
       instance.has column
     end
 
     it "passes through options to the attribute" do
-      ThinkingSphinx::ActiveRecord::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
         with(model, column, :as => :other_name).and_return(attribute)
 
       instance.has column, :as => :other_name
@@ -94,15 +94,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "adds an attribute to the source" do
       instance.has column
 
-      source.attributes.should include(attribute)
+      expect(source.attributes).to include(attribute)
     end
 
     it "adds multiple attributes when passed multiple columns" do
       instance.has column, column
 
-      source.attributes.select { |saved_attribute|
+      expect(source.attributes.select { |saved_attribute|
         saved_attribute == attribute
-      }.length.should == 2
+      }.length).to eq(2)
     end
   end
 
@@ -111,31 +111,31 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:field)  { double('field') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Field.stub! :new => field
+      allow(ThinkingSphinx::ActiveRecord::Field).to receive_messages :new => field
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.indexes column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.indexes column
       instance.indexes column
     end
 
     it "creates a new field with the provided column" do
-      ThinkingSphinx::ActiveRecord::Field.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
         with(model, column, {}).and_return(field)
 
       instance.indexes column
     end
 
     it "passes through options to the field" do
-      ThinkingSphinx::ActiveRecord::Field.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
         with(model, column, :as => :other_name).and_return(field)
 
       instance.indexes column, :as => :other_name
@@ -144,15 +144,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "adds a field to the source" do
       instance.indexes column
 
-      source.fields.should include(field)
+      expect(source.fields).to include(field)
     end
 
     it "adds multiple fields when passed multiple columns" do
       instance.indexes column, column
 
-      source.fields.select { |saved_field|
+      expect(source.fields.select { |saved_field|
         saved_field == field
-      }.length.should == 2
+      }.length).to eq(2)
     end
   end
 
@@ -161,24 +161,24 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:association) { double('association') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Association.stub! :new => association
+      allow(ThinkingSphinx::ActiveRecord::Association).to receive_messages :new => association
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.join column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.join column
       instance.join column
     end
 
     it "creates a new association with the provided column" do
-      ThinkingSphinx::ActiveRecord::Association.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Association).to receive(:new).
         with(column).and_return(association)
 
       instance.join column
@@ -187,15 +187,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "adds an association to the source" do
       instance.join column
 
-      source.associations.should include(association)
+      expect(source.associations).to include(association)
     end
 
     it "adds multiple fields when passed multiple columns" do
       instance.join column, column
 
-      source.associations.select { |saved_assoc|
+      expect(source.associations.select { |saved_assoc|
         saved_assoc == association
-      }.length.should == 2
+      }.length).to eq(2)
     end
   end
 
@@ -203,15 +203,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:column) { double('column') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Column.stub!(:new => column)
+      allow(ThinkingSphinx::ActiveRecord::Column).to receive_messages(:new => column)
     end
 
     it "returns a new column for the given method" do
-      instance.id.should == column
+      expect(instance.id).to eq(column)
     end
 
     it "should initialise the column with the method name and arguments" do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).
         with(:users, :posts, :subject).and_return(column)
 
       instance.users(:posts, :subject)
@@ -220,26 +220,26 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#set_database' do
     before :each do
-      source.stub :set_database_settings => true
+      allow(source).to receive_messages :set_database_settings => true
 
       stub_const 'ActiveRecord::Base',
         double(:configurations => {'other' => {'baz' => 'qux'}})
     end
 
     it "sends through a hash if provided" do
-      source.should_receive(:set_database_settings).with(:foo => :bar)
+      expect(source).to receive(:set_database_settings).with(:foo => :bar)
 
       instance.set_database :foo => :bar
     end
 
     it "finds the environment settings if given a string key" do
-      source.should_receive(:set_database_settings).with(:baz => 'qux')
+      expect(source).to receive(:set_database_settings).with(:baz => 'qux')
 
       instance.set_database 'other'
     end
 
     it "finds the environment settings if given a symbol key" do
-      source.should_receive(:set_database_settings).with(:baz => 'qux')
+      expect(source).to receive(:set_database_settings).with(:baz => 'qux')
 
       instance.set_database :other
     end
@@ -247,19 +247,19 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#set_property' do
     before :each do
-      index.class.stub  :settings => [:morphology]
-      source.class.stub :settings => [:mysql_ssl_cert]
+      allow(index.class).to receive_messages  :settings => [:morphology]
+      allow(source.class).to receive_messages :settings => [:mysql_ssl_cert]
     end
 
     it 'saves other settings as index options' do
       instance.set_property :field_weights => {:name => 10}
 
-      index.options[:field_weights].should == {:name => 10}
+      expect(index.options[:field_weights]).to eq({:name => 10})
     end
 
     context 'index settings' do
       it "sets the provided setting" do
-        index.should_receive(:morphology=).with('stem_en')
+        expect(index).to receive(:morphology=).with('stem_en')
 
         instance.set_property :morphology => 'stem_en'
       end
@@ -267,24 +267,24 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
     context 'source settings' do
       before :each do
-        source.stub :mysql_ssl_cert= => true
+        allow(source).to receive_messages :mysql_ssl_cert= => true
       end
 
       it "adds a source to the index" do
-        index.should_receive(:append_source).and_return(source)
+        expect(index).to receive(:append_source).and_return(source)
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
 
       it "only adds a single source for the given context" do
-        index.should_receive(:append_source).once.and_return(source)
+        expect(index).to receive(:append_source).once.and_return(source)
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
 
       it "sets the provided setting" do
-        source.should_receive(:mysql_ssl_cert=).with('private.cert')
+        expect(source).to receive(:mysql_ssl_cert=).with('private.cert')
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
@@ -298,20 +298,20 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
       }
 
       interpreter = ThinkingSphinx::ActiveRecord::Interpreter.new index, block
-      interpreter.translate!.
-        should == interpreter.__id__
+      expect(interpreter.translate!).
+        to eq(interpreter.__id__)
     end
   end
 
   describe '#where' do
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.where 'id > 100'
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.where 'id > 100'
       instance.where 'id < 150'
@@ -320,7 +320,7 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "appends a new grouping statement to the source" do
       instance.where 'id > 100'
 
-      source.conditions.should include('id > 100')
+      expect(source.conditions).to include('id > 100')
     end
   end
 end

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -23,29 +23,29 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
     let(:animal_reflection)  { double 'Animal Reflection' }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        stub(:call).
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         and_return(article_reflection, animal_reflection)
 
-      model.stub(:reflect_on_association) do |name|
+      allow(model).to receive(:reflect_on_association) do |name|
         name == :foo ? reflection : nil
       end
 
       if ActiveRecord::Reflection.respond_to?(:add_reflection)
-        ActiveRecord::Reflection.stub :add_reflection
+        allow(ActiveRecord::Reflection).to receive :add_reflection
       end
     end
 
     it "creates a new reflection for each class" do
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        unstub :call
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).and_call_original
 
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        should_receive(:call).
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         with(reflection, :foo_article, 'Article').
         and_return(article_reflection)
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        should_receive(:call).
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         with(reflection, :foo_animal, 'Animal').
         and_return(animal_reflection)
 
@@ -54,9 +54,9 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
 
     it "adds the new reflections to the end-of-stack model" do
       if ActiveRecord::Reflection.respond_to?(:add_reflection)
-        ActiveRecord::Reflection.should_receive(:add_reflection).
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
           with(model, :foo_article, article_reflection)
-        ActiveRecord::Reflection.should_receive(:add_reflection).
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
           with(model, :foo_animal, animal_reflection)
 
         polymorpher.morph!
@@ -69,14 +69,14 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
     end
 
     it "rebases each field" do
-      field.should_receive(:rebase).with([:a, :b, :foo],
+      expect(field).to 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],
+      expect(attribute).to receive(:rebase).with([:a, :b, :foo],
         :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
 
       polymorpher.morph!

data/spec/thinking_sphinx/active_record/property_sql_presenter_spec.rb

@@ -7,7 +7,7 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
   let(:path)         { double :aggregate? => false, :model => model }
 
   before :each do
-    adapter.stub(:quote) { |column| column }
+    allow(adapter).to receive(:quote) { |column| column }
 
     stub_const 'Joiner::Path', double(:new => path)
   end
@@ -25,95 +25,95 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
 
     describe '#to_group' do
       it "returns the column name as a string" do
-        presenter.to_group.should == 'articles.title'
+        expect(presenter.to_group).to eq('articles.title')
       end
 
       it "gets the column's table alias from the associations object" do
-        column.stub!(:__stack => [:users, :posts])
+        allow(column).to receive_messages(:__stack => [:users, :posts])
 
-        associations.should_receive(:alias_for).with([:users, :posts]).
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
           and_return('posts')
 
         presenter.to_group
       end
 
       it "returns nil if the property is an aggregate" do
-        path.stub! :aggregate? => true
+        allow(path).to receive_messages :aggregate? => true
 
-        presenter.to_group.should be_nil
+        expect(presenter.to_group).to be_nil
       end
 
       it "returns nil if the field is sourced via a separate query" do
-        field.stub :source_type => 'query'
+        allow(field).to receive_messages :source_type => 'query'
 
-        presenter.to_group.should be_nil
+        expect(presenter.to_group).to be_nil
       end
     end
 
     describe '#to_select' do
       it "returns the column name as a string" do
-        presenter.to_select.should == 'articles.title AS title'
+        expect(presenter.to_select).to eq('articles.title AS title')
       end
 
       it "gets the column's table alias from the associations object" do
-        column.stub!(:__stack => [:users, :posts])
+        allow(column).to receive_messages(:__stack => [:users, :posts])
 
-        associations.should_receive(:alias_for).with([:users, :posts]).
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
           and_return('posts')
 
         presenter.to_select
       end
 
       it "returns the column name with an alias when provided" do
-        field.stub!(:name => :subject)
+        allow(field).to receive_messages(:name => :subject)
 
-        presenter.to_select.should == 'articles.title AS subject'
+        expect(presenter.to_select).to eq('articles.title AS subject')
       end
 
       it "groups and concatenates aggregated columns" do
-        adapter.stub :group_concatenate do |clause, separator|
+        allow(adapter).to receive :group_concatenate do |clause, separator|
           "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
         end
 
-        path.stub! :aggregate? => true
+        allow(path).to receive_messages :aggregate? => true
 
-        presenter.to_select.
-          should == "GROUP_CONCAT(articles.title SEPARATOR ' ') AS title"
+        expect(presenter.to_select).
+          to eq("GROUP_CONCAT(articles.title SEPARATOR ' ') AS title")
       end
 
       it "concatenates multiple columns" do
-        adapter.stub :concatenate do |clause, separator|
+        allow(adapter).to receive :concatenate do |clause, separator|
           "CONCAT_WS('#{separator}', #{clause})"
         end
 
-        field.stub!(:columns => [column, column])
+        allow(field).to receive_messages(:columns => [column, column])
 
-        presenter.to_select.
-          should == "CONCAT_WS(' ', articles.title, articles.title) AS title"
+        expect(presenter.to_select).
+          to eq("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|
+        allow(adapter).to receive :concatenate do |clause, separator|
           "CONCAT_WS('#{separator}', #{clause})"
         end
 
-        field.stub!(:columns => [column, double('column', :string? => false,
+        allow(field).to receive_messages(:columns => [column, double('column', :string? => false,
           :__stack => [], :__name => 'body')])
 
-        presenter.to_select.
-          should == "CONCAT_WS(' ', articles.title) AS title"
+        expect(presenter.to_select).
+          to eq("CONCAT_WS(' ', articles.title) AS title")
       end
 
       it "returns nil for query sourced fields" do
-        field.stub :source_type => :query
+        allow(field).to receive_messages :source_type => :query
 
-        presenter.to_select.should be_nil
+        expect(presenter.to_select).to be_nil
       end
 
       it "returns nil for ranged query sourced fields" do
-        field.stub :source_type => :ranged_query
+        allow(field).to receive_messages :source_type => :ranged_query
 
-        presenter.to_select.should be_nil
+        expect(presenter.to_select).to be_nil
       end
     end
   end
@@ -131,131 +131,131 @@ describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do
       :__name => 'created_at') }
 
     before :each do
-      adapter.stub :cast_to_timestamp do |clause|
+      allow(adapter).to receive :cast_to_timestamp do |clause|
         "UNIX_TIMESTAMP(#{clause})"
       end
     end
 
     describe '#to_group' do
       it "returns the column name as a string" do
-        presenter.to_group.should == 'articles.created_at'
+        expect(presenter.to_group).to eq('articles.created_at')
       end
 
       it "gets the column's table alias from the associations object" do
-        column.stub!(:__stack => [:users, :posts])
+        allow(column).to receive_messages(:__stack => [:users, :posts])
 
-        associations.should_receive(:alias_for).with([:users, :posts]).
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
           and_return('posts')
 
         presenter.to_group
       end
 
       it "returns nil if the column is a string" do
-        column.stub!(:string? => true)
+        allow(column).to receive_messages(:string? => true)
 
-        presenter.to_group.should be_nil
+        expect(presenter.to_group).to be_nil
       end
 
       it "returns nil if the property is an aggregate" do
-        path.stub! :aggregate? => true
+        allow(path).to receive_messages :aggregate? => true
 
-        presenter.to_group.should be_nil
+        expect(presenter.to_group).to be_nil
       end
 
       it "returns nil if the attribute is sourced via a separate query" do
-        attribute.stub :source_type => 'query'
+        allow(attribute).to receive_messages :source_type => 'query'
 
-        presenter.to_group.should be_nil
+        expect(presenter.to_group).to be_nil
       end
     end
 
     describe '#to_select' do
       it "returns the column name as a string" do
-        presenter.to_select.should == 'articles.created_at AS created_at'
+        expect(presenter.to_select).to eq('articles.created_at AS created_at')
       end
 
       it "gets the column's table alias from the associations object" do
-        column.stub!(:__stack => [:users, :posts])
+        allow(column).to receive_messages(:__stack => [:users, :posts])
 
-        associations.should_receive(:alias_for).with([:users, :posts]).
+        expect(associations).to receive(:alias_for).with([:users, :posts]).
           and_return('posts')
 
         presenter.to_select
       end
 
       it "returns the column name with an alias when provided" do
-        attribute.stub!(:name => :creation_timestamp)
+        allow(attribute).to receive_messages(:name => :creation_timestamp)
 
-        presenter.to_select.
-          should == 'articles.created_at AS creation_timestamp'
+        expect(presenter.to_select).
+          to eq('articles.created_at AS creation_timestamp')
       end
 
       it "ensures datetime attributes are converted to timestamps" do
-        attribute.stub :type => :timestamp
+        allow(attribute).to receive_messages :type => :timestamp
 
-        presenter.to_select.
-          should == 'UNIX_TIMESTAMP(articles.created_at) AS created_at'
+        expect(presenter.to_select).
+          to eq('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|
+        allow(adapter).to receive :concatenate do |clause, separator|
           "CONCAT_WS('#{separator}', #{clause})"
         end
-        adapter.stub :cast_to_string do |clause|
+        allow(adapter).to receive :cast_to_string do |clause|
           "CAST(#{clause} AS varchar)"
         end
 
-        attribute.stub!(:columns => [column, double('column',
+        allow(attribute).to receive_messages(:columns => [column, double('column',
           :string? => false, :__stack => [], :__name => 'updated_at')])
 
-        presenter.to_select.should == "CONCAT_WS(',', CAST(articles.created_at AS varchar)) AS created_at"
+        expect(presenter.to_select).to eq("CONCAT_WS(',', CAST(articles.created_at AS varchar)) AS created_at")
       end
 
       it "casts and concatenates multiple columns for attributes" do
-        adapter.stub :concatenate do |clause, separator|
+        allow(adapter).to receive :concatenate do |clause, separator|
           "CONCAT_WS('#{separator}', #{clause})"
         end
-        adapter.stub :cast_to_string do |clause|
+        allow(adapter).to receive :cast_to_string do |clause|
           "CAST(#{clause} AS varchar)"
         end
 
-        attribute.stub!(:columns => [column, column])
+        allow(attribute).to receive_messages(:columns => [column, column])
 
-        presenter.to_select.should == "CONCAT_WS(',', CAST(articles.created_at AS varchar), CAST(articles.created_at AS varchar)) AS created_at"
+        expect(presenter.to_select).to eq("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|
+        allow(adapter).to receive :concatenate do |clause, separator|
           "CONCAT_WS('#{separator}', #{clause})"
         end
-        adapter.stub :cast_to_string do |clause|
+        allow(adapter).to receive :cast_to_string do |clause|
           "CAST(#{clause} AS varchar)"
         end
 
-        attribute.stub :columns => [column, column], :type => :timestamp
+        allow(attribute).to receive_messages :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"
+        expect(presenter.to_select).to eq("CONCAT_WS(',', CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar), CAST(UNIX_TIMESTAMP(articles.created_at) AS varchar)) AS created_at")
       end
 
       it "does not split attribute clause for timestamp casting if it looks like a function call" do
-        column.stub :__name => "COALESCE(articles.updated_at, articles.created_at)", :string? => true
+        allow(column).to receive_messages :__name => "COALESCE(articles.updated_at, articles.created_at)", :string? => true
 
-        attribute.stub :name => 'mod_date', :columns => [column],
+        allow(attribute).to receive_messages :name => 'mod_date', :columns => [column],
           :type => :timestamp
 
-        presenter.to_select.should == "UNIX_TIMESTAMP(COALESCE(articles.updated_at, articles.created_at)) AS mod_date"
+        expect(presenter.to_select).to eq("UNIX_TIMESTAMP(COALESCE(articles.updated_at, articles.created_at)) AS mod_date")
       end
 
       it "returns nil for query sourced attributes" do
-        attribute.stub :source_type => :query
+        allow(attribute).to receive_messages :source_type => :query
 
-        presenter.to_select.should be_nil
+        expect(presenter.to_select).to be_nil
       end
 
       it "returns nil for ranged query sourced attributes" do
-        attribute.stub :source_type => :ranged_query
+        allow(attribute).to receive_messages :source_type => :ranged_query
 
-        presenter.to_select.should be_nil
+        expect(presenter.to_select).to be_nil
       end
     end
   end