thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/real_time/interpreter_spec.rb

@@ -12,15 +12,15 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:instance) { double('interpreter', :translate! => true) }
 
     it "creates a new interpreter instance with the given block and index" do
-      ThinkingSphinx::RealTime::Interpreter.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:new).
         with(index, block).and_return(instance)
 
       ThinkingSphinx::RealTime::Interpreter.translate! index, block
     end
 
     it "calls translate! on the instance" do
-      ThinkingSphinx::RealTime::Interpreter.stub!(:new => instance)
-      instance.should_receive(:translate!)
+      allow(ThinkingSphinx::RealTime::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
 
       ThinkingSphinx::RealTime::Interpreter.translate! index, block
     end
@@ -31,18 +31,18 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:attribute) { double('attribute') }
 
     before :each do
-      ThinkingSphinx::RealTime::Attribute.stub! :new => attribute
+      allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
     end
 
     it "creates a new attribute with the provided column" do
-      ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
         with(column, {}).and_return(attribute)
 
       instance.has column
     end
 
     it "passes through options to the attribute" do
-      ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
         with(column, :as => :other_name).and_return(attribute)
 
       instance.has column, :as => :other_name
@@ -51,15 +51,15 @@ describe ThinkingSphinx::RealTime::Interpreter do
     it "adds an attribute to the index" do
       instance.has column
 
-      index.attributes.should include(attribute)
+      expect(index.attributes).to include(attribute)
     end
 
     it "adds multiple attributes when passed multiple columns" do
       instance.has column, column
 
-      index.attributes.select { |saved_attribute|
+      expect(index.attributes.select { |saved_attribute|
         saved_attribute == attribute
-      }.length.should == 2
+      }.length).to eq(2)
     end
   end
 
@@ -68,18 +68,18 @@ describe ThinkingSphinx::RealTime::Interpreter do
     let(:field)  { double('field') }
 
     before :each do
-      ThinkingSphinx::RealTime::Field.stub! :new => field
+      allow(ThinkingSphinx::RealTime::Field).to receive_messages :new => field
     end
 
     it "creates a new field with the provided column" do
-      ThinkingSphinx::RealTime::Field.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Field).to receive(:new).
         with(column, {}).and_return(field)
 
       instance.indexes column
     end
 
     it "passes through options to the field" do
-      ThinkingSphinx::RealTime::Field.should_receive(:new).
+      expect(ThinkingSphinx::RealTime::Field).to receive(:new).
         with(column, :as => :other_name).and_return(field)
 
       instance.indexes column, :as => :other_name
@@ -88,28 +88,28 @@ describe ThinkingSphinx::RealTime::Interpreter do
     it "adds a field to the index" do
       instance.indexes column
 
-      index.fields.should include(field)
+      expect(index.fields).to include(field)
     end
 
     it "adds multiple fields when passed multiple columns" do
       instance.indexes column, column
 
-      index.fields.select { |saved_field|
+      expect(index.fields.select { |saved_field|
         saved_field == field
-      }.length.should == 2
+      }.length).to eq(2)
     end
 
     context 'sortable' do
       let(:attribute) { double('attribute') }
 
       before :each do
-        ThinkingSphinx::RealTime::Attribute.stub! :new => attribute
+        allow(ThinkingSphinx::RealTime::Attribute).to receive_messages :new => attribute
 
-        column.stub :__name => :col
+        allow(column).to receive_messages :__name => :col
       end
 
       it "adds the _sort suffix to the field's name" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
           with(column, :as => :col_sort, :type => :string).
           and_return(attribute)
 
@@ -117,7 +117,7 @@ describe ThinkingSphinx::RealTime::Interpreter do
       end
 
       it "respects given aliases" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
           with(column, :as => :other_sort, :type => :string).
           and_return(attribute)
 
@@ -125,7 +125,7 @@ describe ThinkingSphinx::RealTime::Interpreter do
       end
 
       it "respects symbols instead of columns" do
-        ThinkingSphinx::RealTime::Attribute.should_receive(:new).
+        expect(ThinkingSphinx::RealTime::Attribute).to receive(:new).
           with(:title, :as => :title_sort, :type => :string).
           and_return(attribute)
 
@@ -135,7 +135,7 @@ describe ThinkingSphinx::RealTime::Interpreter do
       it "adds an attribute to the index" do
         instance.indexes column, :sortable => true
 
-        index.attributes.should include(attribute)
+        expect(index.attributes).to include(attribute)
       end
     end
   end
@@ -144,15 +144,15 @@ describe ThinkingSphinx::RealTime::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)
@@ -161,7 +161,7 @@ describe ThinkingSphinx::RealTime::Interpreter do
 
   describe '#scope' do
     it "passes the scope block through to the index" do
-      index.should_receive(:scope=).with(instance_of(Proc))
+      expect(index).to receive(:scope=).with(instance_of(Proc))
 
       instance.scope { :foo }
     end
@@ -169,18 +169,18 @@ describe ThinkingSphinx::RealTime::Interpreter do
 
   describe '#set_property' do
     before :each do
-      index.class.stub :settings => [:morphology]
+      allow(index.class).to receive_messages :settings => [:morphology]
     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
@@ -194,8 +194,8 @@ describe ThinkingSphinx::RealTime::Interpreter do
       }
 
       interpreter = ThinkingSphinx::RealTime::Interpreter.new index, block
-      interpreter.translate!.
-        should == interpreter.__id__
+      expect(interpreter.translate!).
+        to eq(interpreter.__id__)
     end
   end
 end

data/spec/thinking_sphinx/scopes_spec.rb

@@ -17,29 +17,29 @@ describe ThinkingSphinx::Scopes do
     end
 
     it "creates new search" do
-      model.foo.class.should == ThinkingSphinx::Search
+      expect(model.foo.class).to eq(ThinkingSphinx::Search)
     end
 
     it "passes block result to constructor" do
-      model.foo.options[:with].should == {:foo => :bar}
+      expect(model.foo.options[:with]).to eq({:foo => :bar})
     end
 
     it "passes non-scopes through to the standard method error call" do
-      lambda { model.bar }.should raise_error(NoMethodError)
+      expect { model.bar }.to raise_error(NoMethodError)
     end
   end
 
   describe '#sphinx_scope' do
     it "saves the given block with a name" do
       model.sphinx_scope(:foo) { 27 }
-      model.sphinx_scopes[:foo].call.should == 27
+      expect(model.sphinx_scopes[:foo].call).to eq(27)
     end
   end
 
   describe '#default_sphinx_scope' do
     it "gets and sets the default scope depending on the argument" do
       model.default_sphinx_scope :foo
-      model.default_sphinx_scope.should == :foo
+      expect(model.default_sphinx_scope).to eq(:foo)
     end
   end
 end

data/spec/thinking_sphinx/search/glaze_spec.rb

@@ -12,11 +12,11 @@ describe ThinkingSphinx::Search::Glaze do
 
   describe '#!=' do
     it "is true for objects that don't match" do
-      (glaze != double('foo')).should be_true
+      expect(glaze != double('foo')).to be_truthy
     end
 
     it "is false when the underlying object is a match" do
-      (glaze != object).should be_false
+      expect(glaze != object).to be_falsey
     end
   end
 
@@ -28,50 +28,50 @@ describe ThinkingSphinx::Search::Glaze do
     let(:pane_two) { double('pane two', :foo => 'two', :bar => 'two') }
 
     before :each do
-      klass.stub(:new).and_return(pane_one, pane_two)
+      allow(klass).to receive(:new).and_return(pane_one, pane_two)
     end
 
     it "respects objects existing methods" do
-      object.stub :foo => 'original'
+      allow(object).to receive_messages :foo => 'original'
 
-      glaze.foo.should == 'original'
+      expect(glaze.foo).to eq('original')
     end
 
     it "uses the first pane that responds to the method" do
-      glaze.foo.should == 'one'
-      glaze.bar.should == 'two'
+      expect(glaze.foo).to eq('one')
+      expect(glaze.bar).to eq('two')
     end
 
     it "raises the method missing error otherwise" do
-      object.stub :respond_to? => false
-      object.stub(:baz).and_raise(NoMethodError)
+      allow(object).to receive_messages :respond_to? => false
+      allow(object).to receive(:baz).and_raise(NoMethodError)
 
-      lambda { glaze.baz }.should raise_error(NoMethodError)
+      expect { glaze.baz }.to raise_error(NoMethodError)
     end
   end
 
   describe '#respond_to?' do
     it "responds to underlying object methods" do
-      object.stub :foo => true
+      allow(object).to receive_messages :foo => true
 
-      glaze.respond_to?(:foo).should be_true
+      expect(glaze.respond_to?(:foo)).to be_truthy
     end
 
     it "responds to underlying pane methods" do
       pane  = double('Pane Class', :new => double('pane', :bar => true))
       glaze = ThinkingSphinx::Search::Glaze.new context, object, raw, [pane]
 
-      glaze.respond_to?(:bar).should be_true
+      expect(glaze.respond_to?(:bar)).to be_truthy
     end
 
     it "does not to respond to methods that don't exist" do
-      glaze.respond_to?(:something).should be_false
+      expect(glaze.respond_to?(:something)).to be_falsey
     end
   end
 
   describe '#unglazed' do
     it "returns the original object" do
-      glaze.unglazed.should == object
+      expect(glaze.unglazed).to eq(object)
     end
   end
 end

data/spec/thinking_sphinx/search/query_spec.rb

@@ -14,30 +14,30 @@ describe ThinkingSphinx::Search::Query do
     it "passes through the keyword as provided" do
       query = ThinkingSphinx::Search::Query.new 'pancakes'
 
-      query.to_s.should == 'pancakes'
+      expect(query.to_s).to eq('pancakes')
     end
 
     it "pairs fields and keywords for given conditions" do
       query = ThinkingSphinx::Search::Query.new '', :title => 'pancakes'
 
-      query.to_s.should == '@title pancakes'
+      expect(query.to_s).to eq('@title pancakes')
     end
 
     it "combines both keywords and conditions" do
       query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes'
 
-      query.to_s.should == 'tasty @title pancakes'
+      expect(query.to_s).to eq('tasty @title pancakes')
     end
 
     it "automatically stars keywords if requested" do
-      ThinkingSphinx::Query.should_receive(:wildcard).with('cake', true).
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('cake', true).
         and_return('*cake*')
 
       ThinkingSphinx::Search::Query.new('cake', {}, true).to_s
     end
 
     it "automatically stars condition keywords if requested" do
-      ThinkingSphinx::Query.should_receive(:wildcard).with('pan', true).
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('pan', true).
         and_return('*pan*')
 
       ThinkingSphinx::Search::Query.new('', {:title => 'pan'}, true).to_s
@@ -47,32 +47,32 @@ describe ThinkingSphinx::Search::Query do
       query = ThinkingSphinx::Search::Query.new '',
         {:sphinx_internal_class_name => 'article'}, true
 
-      query.to_s.should == '@sphinx_internal_class_name article'
+      expect(query.to_s).to eq('@sphinx_internal_class_name article')
     end
 
     it "handles null values by removing them from the conditions hash" do
       query = ThinkingSphinx::Search::Query.new '', :title => nil
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "handles empty string values by removing them from the conditions hash" do
       query = ThinkingSphinx::Search::Query.new '', :title => ''
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "handles nil queries" do
       query = ThinkingSphinx::Search::Query.new nil, {}
 
-      query.to_s.should == ''
+      expect(query.to_s).to eq('')
     end
 
     it "allows mixing of blank and non-blank conditions" do
       query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes',
         :ingredients => nil
 
-      query.to_s.should == 'tasty @title pancakes'
+      expect(query.to_s).to eq('tasty @title pancakes')
     end
   end
 end

data/spec/thinking_sphinx/search_spec.rb

@@ -34,26 +34,26 @@ describe ThinkingSphinx::Search do
   end
 
   before :each do
-    ThinkingSphinx::Search::Context.stub :new => context
+    allow(ThinkingSphinx::Search::Context).to receive_messages :new => context
 
     stub_const 'ThinkingSphinx::Middlewares::DEFAULT', stack
   end
 
   describe '#current_page' do
     it "should return 1 by default" do
-      search.current_page.should == 1
+      expect(search.current_page).to eq(1)
     end
 
     it "should handle string page values" do
-      ThinkingSphinx::Search.new(:page => '2').current_page.should == 2
+      expect(ThinkingSphinx::Search.new(:page => '2').current_page).to eq(2)
     end
 
     it "should handle empty string page values" do
-      ThinkingSphinx::Search.new(:page => '').current_page.should == 1
+      expect(ThinkingSphinx::Search.new(:page => '').current_page).to eq(1)
     end
 
     it "should return the requested page" do
-      ThinkingSphinx::Search.new(:page => 10).current_page.should == 10
+      expect(ThinkingSphinx::Search.new(:page => 10).current_page).to eq(10)
     end
   end
 
@@ -61,25 +61,25 @@ describe ThinkingSphinx::Search do
     it "returns false if there is anything in the data set" do
       context[:results] << double
 
-      search.should_not be_empty
+      expect(search).not_to be_empty
     end
 
     it "returns true if the data set is empty" do
       context[:results].clear
 
-      search.should be_empty
+      expect(search).to be_empty
     end
   end
 
   describe '#initialize' do
     it "lazily loads by default" do
-      stack.should_not_receive(:call)
+      expect(stack).not_to receive(:call)
 
       ThinkingSphinx::Search.new
     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)
 
       ThinkingSphinx::Search.new(:populate => true)
     end
@@ -87,74 +87,74 @@ describe ThinkingSphinx::Search do
 
   describe '#offset' do
     it "should default to 0" do
-      search.offset.should == 0
+      expect(search.offset).to eq(0)
     end
 
     it "should increase by the per_page value for each page in" do
-      ThinkingSphinx::Search.new(:per_page => 25, :page => 2).offset.
-        should == 25
+      expect(ThinkingSphinx::Search.new(:per_page => 25, :page => 2).offset).
+        to eq(25)
     end
 
     it "should prioritise explicit :offset over calculated if given" do
-      ThinkingSphinx::Search.new(:offset => 5).offset.should == 5
+      expect(ThinkingSphinx::Search.new(:offset => 5).offset).to eq(5)
     end
   end
 
   describe '#page' do
     it "sets the current page" do
       search.page(3)
-      search.current_page.should == 3
+      expect(search.current_page).to eq(3)
     end
 
     it "returns the search object" do
-      search.page(2).should == search
+      expect(search.page(2)).to eq(search)
     end
   end
 
   describe '#per' do
     it "sets the current per_page value" do
       search.per(29)
-      search.per_page.should == 29
+      expect(search.per_page).to eq(29)
     end
 
     it "returns the search object" do
-      search.per(29).should == search
+      expect(search.per(29)).to eq(search)
     end
   end
 
   describe '#per_page' do
     it "defaults to 20" do
-      search.per_page.should == 20
+      expect(search.per_page).to eq(20)
     end
 
     it "is set as part of the search options" do
-      ThinkingSphinx::Search.new(:per_page => 10).per_page.should == 10
+      expect(ThinkingSphinx::Search.new(:per_page => 10).per_page).to eq(10)
     end
 
     it "should prioritise :limit over :per_page if given" do
-      ThinkingSphinx::Search.new(:per_page => 30, :limit => 40).per_page.
-        should == 40
+      expect(ThinkingSphinx::Search.new(:per_page => 30, :limit => 40).per_page).
+        to eq(40)
     end
 
     it "should allow for string arguments" do
-      ThinkingSphinx::Search.new(:per_page => '10').per_page.should == 10
+      expect(ThinkingSphinx::Search.new(:per_page => '10').per_page).to eq(10)
     end
 
     it "allows setting of the per_page value" do
       search.per_page(24)
-      search.per_page.should == 24
+      expect(search.per_page).to eq(24)
     end
   end
 
   describe '#populate' do
     it "runs the middleware" do
-      stack.should_receive(:call).with([context]).and_return(true)
+      expect(stack).to receive(:call).with([context]).and_return(true)
 
       search.populate
     end
 
     it "does not retrieve results twice" do
-      stack.should_receive(:call).with([context]).once.and_return(true)
+      expect(stack).to receive(:call).with([context]).once.and_return(true)
 
       search.populate
       search.populate
@@ -163,11 +163,11 @@ describe ThinkingSphinx::Search do
 
   describe '#respond_to?' do
     it "should respond to Array methods" do
-      search.respond_to?(:each).should be_true
+      expect(search.respond_to?(:each)).to be_truthy
     end
 
     it "should respond to Search methods" do
-      search.respond_to?(:per_page).should be_true
+      expect(search.respond_to?(:per_page)).to be_truthy
     end
 
     it "should return true for methods delegated to pagination mask by method_missing" do
@@ -196,7 +196,7 @@ describe ThinkingSphinx::Search do
 
       context[:results] << glazed
 
-      search.to_a.first.__id__.should == unglazed.__id__
+      expect(search.to_a.first.__id__).to eq(unglazed.__id__)
     end
   end