datastax_rails 2.0.12 → 2.0.15

data/spec/datastax_rails/relation/facet_methods_spec.rb

@@ -2,51 +2,59 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
   end
 
-  describe "#field_facet" do
-    
-    it "should return facets on a field" do
-      Hobby.create(:name => 'skiing')
-      Hobby.create(:name => 'boating')
-      Hobby.create(:name => 'fishing')
-      Hobby.create(:name => 'skiing')
+  describe '#field_facet' do
+
+    it 'should return facets on a field' do
+      Hobby.create(name: 'skiing')
+      Hobby.create(name: 'boating')
+      Hobby.create(name: 'fishing')
+      Hobby.create(name: 'skiing')
       Hobby.commit_solr
-      @relation.field_facet(:name).all.facets['name'].should == ["skiing", 2, "boating", 1, "fishing", 1]
+      expect(@relation.field_facet(:name).all.facets['name']).to eq(['skiing', 2, 'boating', 1, 'fishing', 1])
     end
-    
-    it "should allow options to be specified" do
-      Hobby.create(:name => 'skiing')
-      Hobby.create(:name => 'singing')
-      Hobby.create(:name => 'reading')
+
+    it 'should allow options to be specified' do
+      Hobby.create(name: 'skiing')
+      Hobby.create(name: 'singing')
+      Hobby.create(name: 'reading')
       Hobby.commit_solr
-      @relation.field_facet(:name, :prefix => 's').all.facets['name'].should == ["singing", 1, "skiing", 1]
+      expect(@relation.field_facet(:name, prefix: 's').all.facets['name']).to eq(['singing', 1, 'skiing', 1])
     end
-    
+
   end
 
-  describe "#range_facet" do
-    
-    it "should return facets on a field" do
-      Hobby.create(:complexity => 1.0)
-      Hobby.create(:complexity => 5.0)
-      Hobby.create(:complexity => 8.0)
-      Hobby.create(:complexity => 9.0)
-      Hobby.create(:complexity => 10.0)
+  describe '#range_facet' do
+
+    it 'should return facets on a field' do
+      Hobby.create(complexity: 1.0)
+      Hobby.create(complexity: 5.0)
+      Hobby.create(complexity: 8.0)
+      Hobby.create(complexity: 9.0)
+      Hobby.create(complexity: 10.0)
       Hobby.commit_solr
-      @relation.range_facet(:complexity, 1.0, 10.0, 2.0).all.facets['complexity'].should == {"counts"=>["1.0", 1, "3.0", 0, "5.0", 1, "7.0", 1, "9.0", 2], "gap"=>2.0, "start"=>1.0, "end"=>11.0}
+      expect(@relation.range_facet(:complexity, 1.0, 10.0, 2.0).all.facets['complexity'])
+        .to eq('counts' => ['1.0', 1, '3.0', 0, '5.0', 1, '7.0', 1, '9.0', 2],
+               'gap'    => 2.0,
+               'start'  => 1.0,
+               'end'    => 11.0)
     end
 
-    it "should allow options to be specified" do
-      Hobby.create(:complexity => 1.0)
-      Hobby.create(:complexity => 5.0)
-      Hobby.create(:complexity => 8.0)
-      Hobby.create(:complexity => 9.0)
-      Hobby.create(:complexity => 10.0)
+    it 'should allow options to be specified' do
+      Hobby.create(complexity: 1.0)
+      Hobby.create(complexity: 5.0)
+      Hobby.create(complexity: 8.0)
+      Hobby.create(complexity: 9.0)
+      Hobby.create(complexity: 10.0)
       Hobby.commit_solr
-      @relation.range_facet(:complexity, 1.0, 10.0, 2.0, :include => 'upper').all.facets['complexity'].should == {"counts"=>["1.0", 0, "3.0", 1, "5.0", 0, "7.0", 2, "9.0", 1], "gap"=>2.0, "start"=>1.0, "end"=>11.0}
+      expect(@relation.range_facet(:complexity, 1.0, 10.0, 2.0, include: 'upper').all.facets['complexity'])
+        .to eq('counts' => ['1.0', 0, '3.0', 1, '5.0', 0, '7.0', 2, '9.0', 1],
+               'gap'    => 2.0,
+               'start'  => 1.0,
+               'end'    => 11.0)
     end
-         
-  end            
-end
+
+  end
+end

data/spec/datastax_rails/relation/finder_methods_spec.rb

@@ -2,120 +2,119 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
     Hobby.commit_solr
   end
-  
-  describe "#find" do
-    let(:h) {Hobby.create}
-    let(:i) {Hobby.create}
-    
-    context "with a single id" do
-      context "as a scalar" do
-        it "finds the object and returns it as an object" do
-          
+
+  describe '#find' do
+    let(:h) { Hobby.create }
+    let(:i) { Hobby.create }
+
+    context 'with a single id' do
+      context 'as a scalar' do
+        it 'finds the object and returns it as an object' do
           expect(Hobby.find(h.id)).to eq(h)
         end
-        
-        it "raises RecordNotFound for an invalid ID" do
-          expect{Hobby.find("asdf")}.to raise_exception(DatastaxRails::RecordNotFound)
+
+        it 'raises RecordNotFound for an invalid ID' do
+          expect { Hobby.find('asdf') }.to raise_exception(DatastaxRails::RecordNotFound)
         end
-        
-        it "raises RecordNotFound for a nil ID" do
-          expect{Hobby.find(nil)}.to raise_exception(DatastaxRails::RecordNotFound)
+
+        it 'raises RecordNotFound for a nil ID' do
+          expect { Hobby.find(nil) }.to raise_exception(DatastaxRails::RecordNotFound)
         end
       end
-      
-      context "as an array" do
-        it "finds the object and returns it as a single-element array" do
+
+      context 'as an array' do
+        it 'finds the object and returns it as a single-element array' do
           expect(Hobby.find([h.id])).to eq([h])
         end
       end
     end
-    
-    context "with multiple ids" do
-      it "raises RecordNotFound if any portion of the records could not be found" do
-        expect{Hobby.find(h.id, ::Cql::TimeUuid::Generator.new.next)}.to raise_exception(DatastaxRails::RecordNotFound)
+
+    context 'with multiple ids' do
+      it 'raises RecordNotFound if any portion of the records could not be found' do
+        expect { Hobby.find(h.id, ::Cql::TimeUuid::Generator.new.next) }.to raise_exception(DatastaxRails::RecordNotFound)
       end
-      
-      context "as an array" do
-        it "finds the objects and returns them as an array" do
-          expect(Hobby.find([h.id, i.id])).to eq([h,i])
+
+      context 'as an array' do
+        it 'finds the objects and returns them as an array' do
+          expect(Hobby.find([h.id, i.id])).to eq([h, i])
         end
       end
-      
-      context "as discrete parameters" do
-        it "finds the objects and returns them as an array" do
-          expect(Hobby.find(h.id, i.id)).to eq([h,i])
+
+      context 'as discrete parameters' do
+        it 'finds the objects and returns them as an array' do
+          expect(Hobby.find(h.id, i.id)).to eq([h, i])
         end
       end
     end
   end
-  
-  describe "#first" do
-    it "should return the first result if records are already loaded" do
-      a_record = mock_model(Hobby)
-      @relation.stub(:loaded? => true)
-      @relation.instance_variable_set(:@results, [a_record, mock_model(Hobby)])
-      @relation.first.should == a_record
+
+  describe '#first' do
+    it 'should return the first result if records are already loaded' do
+      a_record = build_stubbed(:hobby)
+      allow(@relation).to receive(:loaded?).and_return(true)
+      @relation.instance_variable_set(:@results, [a_record, build_stubbed(:hobby)])
+      expect(@relation.first).to eq(a_record)
     end
-    
-    it "should look up the first result if records are not already loaded" do
-      a_record = mock_model(Hobby)
-      @relation.stub(:loaded? => false)
-      mock_relation = double(DatastaxRails::Relation, :to_a => [a_record])
-      @relation.should_receive(:limit).with(1).and_return(mock_relation)
-      @relation.first.should == a_record
+
+    it 'should look up the first result if records are not already loaded' do
+      a_record = build_stubbed(:hobby)
+      allow(@relation).to receive(:loaded?).and_return(false)
+      mock_relation = double(DatastaxRails::Relation, to_a: [a_record])
+      expect(@relation).to receive(:limit).with(1).and_return(mock_relation)
+      expect(@relation.first).to eq(a_record)
     end
   end
-  
-  describe "#first!" do
-    it "should raise RecordNotFound if no record is returned" do
-      lambda { @relation.first! }.should raise_exception(DatastaxRails::RecordNotFound)
+
+  describe '#first!' do
+    it 'should raise RecordNotFound if no record is returned' do
+      expect { @relation.first! }.to raise_exception(DatastaxRails::RecordNotFound)
     end
   end
-  
-  describe "#last" do
-    it "should return the last result if records are already loaded" do
-      a_record = mock_model(Hobby)
-      @relation.stub(:loaded? => true)
-      @relation.instance_variable_set(:@results, [mock_model(Hobby), a_record])
-      @relation.last.should == a_record
+
+  describe '#last' do
+    it 'should return the last result if records are already loaded' do
+      a_record = build_stubbed(:hobby)
+      allow(@relation).to receive(:loaded?).and_return(true)
+      @relation.instance_variable_set(:@results, [build_stubbed(:hobby), a_record])
+      expect(@relation.last).to eq(a_record)
     end
-    
-    it "should look up the last result if records are not already loaded" do
-      a_record = mock_model(Hobby)
-      @relation.stub(:loaded? => false)
-      mock_relation = double(DatastaxRails::Relation, :to_a => [a_record])
-      @relation.should_receive(:reverse_order).and_return(mock_relation)
-      mock_relation.should_receive(:limit).with(1).and_return(mock_relation)
-      @relation.last.should == a_record
+
+    it 'should look up the last result if records are not already loaded' do
+      a_record = build_stubbed(:hobby)
+      allow(@relation).to receive(:loaded?).and_return(false)
+      mock_relation = double(DatastaxRails::Relation, to_a: [a_record])
+      expect(@relation).to receive(:reverse_order).and_return(mock_relation)
+      expect(mock_relation).to receive(:limit).with(1).and_return(mock_relation)
+      expect(@relation.last).to eq(a_record)
     end
   end
-  
-  describe "#last!" do
-    it "should raise RecordNotFound if no record is returned" do
-      lambda { @relation.last! }.should raise_exception(DatastaxRails::RecordNotFound)
+
+  describe '#last!' do
+    it 'should raise RecordNotFound if no record is returned' do
+      expect { @relation.last! }.to raise_exception(DatastaxRails::RecordNotFound)
     end
   end
 
-  describe "#find_by" do
-    it "finds a record by an attribute" do
-      Boat.create(:name => 'Spooner')
+  describe '#find_by' do
+    it 'finds a record by an attribute' do
+      Boat.create(name: 'Spooner')
       Boat.commit_solr
-      Boat.find_by(name: 'Spooner').should_not be_nil
+      expect(Boat.find_by(name: 'Spooner')).not_to be_nil
     end
 
-    it "finds a record by an attribute with a space in it" do
-      Boat.create(:name => 'Water Lily')
+    it 'finds a record by an attribute with a space in it' do
+      Boat.create(name: 'Water Lily')
       Boat.commit_solr
-      Boat.find_by(name: 'Water Lily').should_not be_nil
+      expect(Boat.find_by(name: 'Water Lily')).not_to be_nil
     end
 
-    it "finds a record by an attribute with a colon in it" do
-      Boat.create(:name => 'Dumb: Name')
+    it 'finds a record by an attribute with a colon in it' do
+      Boat.create(name: 'Dumb: Name')
       Boat.commit_solr
-      Boat.find_by(name: 'Dumb: Name').should_not be_nil
+      expect(Boat.find_by(name: 'Dumb: Name')).not_to be_nil
     end
   end
 end

data/spec/datastax_rails/relation/modification_methods_spec.rb

@@ -2,39 +2,39 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
   end
-  
-  describe "Modification Methods" do
-    describe "#destroy_all" do
-      it "should destroy all matching records" do
-        Hobby.create(:name => "biking", :complexity => 1.0)
-        Hobby.create(:name => "skydiving", :complexity => 4.0)
+
+  describe 'Modification Methods' do
+    describe '#destroy_all' do
+      it 'should destroy all matching records' do
+        Hobby.create(name: 'biking', complexity: 1.0)
+        Hobby.create(name: 'skydiving', complexity: 4.0)
         @relation.commit_solr
         @relation.where(:complexity).greater_than(2.0).destroy_all
         @relation.commit_solr
-        @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
-        @relation.count.should == 1
+        @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
+        expect(@relation.count).to eq(1)
       end
     end
-    
-    describe "#destroy" do
+
+    describe '#destroy' do
       before(:each) do
-        @h1 = Hobby.create(:name => "biking", :complexity => 1.0)
-        @h2 = Hobby.create(:name => "skydiving", :complexity => 4.0)
+        @h1 = Hobby.create(name: 'biking', complexity: 1.0)
+        @h2 = Hobby.create(name: 'skydiving', complexity: 4.0)
         @relation.commit_solr
       end
-      
-      it "should destroy 1 record by id" do
+
+      it 'should destroy 1 record by id' do
         @relation.destroy(@h1.id)
         @relation.commit_solr
-        @relation.count.should == 1
+        expect(@relation.count).to eq(1)
       end
-      
-      it "should destroy multiple records by id" do
+
+      it 'should destroy multiple records by id' do
         @relation.destroy([@h1.id, @h2.id])
         @relation.commit_solr
-        @relation.count.should == 0
+        expect(@relation.count).to eq(0)
       end
     end
   end

data/spec/datastax_rails/relation/search_methods_spec.rb

@@ -2,249 +2,249 @@ require 'spec_helper'
 
 describe DatastaxRails::Relation do
   before(:each) do
-    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+    @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
   end
-  
-  describe "#consistency" do
-    it "should throw an ArgumentError for invalid consistency levels" do
-      lambda { @relation.consistency(:foo) }.should raise_exception(ArgumentError)
-    end
-    
-    it "should not raise an exception for a valid consistency level" do
-      lambda { @relation.consistency(:local_quorum) }.should_not raise_exception
-    end
-    
-    it "should call cassandra to enforce consistency" do
-      h=Hobby.create(:name => 'swimming')
+
+  describe '#consistency' do
+    it 'should throw an ArgumentError for invalid consistency levels' do
+      expect { @relation.consistency(:foo) }.to raise_exception(ArgumentError)
+    end
+
+    it 'should not raise an exception for a valid consistency level' do
+      expect { @relation.consistency(:local_quorum) }.not_to raise_exception
+    end
+
+    it 'should call cassandra to enforce consistency' do
+      h = Hobby.create(name: 'swimming')
       Hobby.commit_solr
-      Hobby.stub_chain(:with_cassandra,:consistency).and_return(@relation)
-      @relation.should_receive(:find_by_id).with(h.id)
-      @relation.consistency(:all).where(:name => 'swimming').all
+      allow(Hobby).to receive_message_chain(:with_cassandra, :consistency).and_return(@relation)
+      expect(@relation).to receive(:find_by_id).with(h.id)
+      @relation.consistency(:all).where(name: 'swimming').all
     end
   end
-  
-  describe "#limit" do
-    it "should limit the page size" do
-      "a".upto("l") do |letter|
-        Hobby.create(:name => letter)
+
+  describe '#limit' do
+    it 'should limit the page size' do
+      'a'.upto('l') do |letter|
+        Hobby.create(name: letter)
       end
       Hobby.commit_solr
-      @relation.limit(7).all.size.should == 7
+      expect(@relation.limit(7).all.size).to eq(7)
     end
   end
-  
-  describe "#page" do
-    it "should get a particular page" do
-      "a".upto("l") do |letter|
-        Hobby.create(:name => letter)
+
+  describe '#page' do
+    it 'should get a particular page' do
+      'a'.upto('l') do |letter|
+        Hobby.create(name: letter)
       end
       Hobby.commit_solr
-      @relation.per_page(3).page(2).order(:name).all.first.name.should == "d"
+      expect(@relation.per_page(3).page(2).order(:name).all.first.name).to eq('d')
     end
   end
-  
-  describe "#group" do
-    
+
+  describe '#group' do
+
   end
-  
-  describe "#order" do
-    it "should return items in ascending order" do
-      %w[fishing hiking boating jogging swimming chess].each do |word|
-        Hobby.create(:name => word)
+
+  describe '#order' do
+    it 'should return items in ascending order' do
+      %w(fishing hiking boating jogging swimming chess).each do |word|
+        Hobby.create(name: word)
       end
       @relation.commit_solr
-      @relation.order(:name).collect {|h| h.name}.should == %w[boating chess fishing hiking jogging swimming]
+      expect(@relation.order(:name).map { |h| h.name }).to eq(%w(boating chess fishing hiking jogging swimming))
     end
-    
-    it "should return items in descending order" do
-      %w[fishing hiking boating jogging swimming chess].each do |word|
-        Hobby.create!(:name => word)
+
+    it 'should return items in descending order' do
+      %w(fishing hiking boating jogging swimming chess).each do |word|
+        Hobby.create!(name: word)
       end
       @relation.commit_solr
-      @relation.order(:name => :desc).collect {|h| h.name}.should == %w[swimming jogging hiking fishing chess boating]
+      expect(@relation.order(name: :desc).map { |h| h.name }).to eq(%w(swimming jogging hiking fishing chess boating))
     end
   end
-  
-  describe "#select" do
-    it "returns maps from solr automatically" do
-      Hobby.create!(:name => "legos", :components => {'squares' => 4, 'rectangles' => 6})
+
+  describe '#select' do
+    it 'returns maps from solr automatically' do
+      Hobby.create!(name: 'legos', components: { 'squares' => 4, 'rectangles' => 6 })
       @relation.commit_solr
-      res = @relation.select(:components).with_solr.first.components.should have_key('squares')
+      expect(@relation.select(:components).with_solr.first.components).to have_key('squares')
     end
   end
-  
-  describe "#slow_order" do
-    it "should manually order items coming from Cassandra" do
-      %w[john jason michael tony billy jim phil].each_with_index do |name,i|
-        AuditLog.create!(:uuid => "c1401540-f092-11e2-9001-6a5ab73a986#{i}", :user => name, :message => 'changed')
+
+  describe '#slow_order' do
+    it 'should manually order items coming from Cassandra' do
+      %w(john jason michael tony billy jim phil).each_with_index do |name, i|
+        AuditLog.create!(uuid: "c1401540-f092-11e2-9001-6a5ab73a986#{i}", user: name, message: 'changed')
       end
-      AuditLog.unscoped.slow_order(:user => :asc).collect {|log| log.user}.should == %w[billy jason jim john michael phil tony]
+      expect(AuditLog.unscoped.slow_order(user: :asc).map { |log| log.user }).to eq(%w(billy jason jim john michael phil tony))
     end
-    
-    it "should manually order items coming from Cassandra in descending order" do
-      %w[john jason michael tony billy jim phil].each_with_index do |name,i|
-        AuditLog.create!(:uuid => "c1401540-f092-11e2-9001-6a5ab73a986#{i}", :user => name, :message => 'changed')
+
+    it 'should manually order items coming from Cassandra in descending order' do
+      %w(john jason michael tony billy jim phil).each_with_index do |name, i|
+        AuditLog.create!(uuid: "c1401540-f092-11e2-9001-6a5ab73a986#{i}", user: name, message: 'changed')
       end
-      AuditLog.unscoped.slow_order(:user => :desc).collect {|log| log.user}.should == %w[tony phil michael john jim jason billy]
+      expect(AuditLog.unscoped.slow_order(user: :desc).map { |log| log.user }).to eq(%w(tony phil michael john jim jason billy))
     end
   end
-  
-  describe "#where" do
-    it "should return documents where a field is nil (does not exist)" do
-      Hobby.create(:name => 'Swimming')
-      Hobby.create(:name => nil)
+
+  describe '#where' do
+    it 'should return documents where a field is nil (does not exist)' do
+      Hobby.create(name: 'Swimming')
+      Hobby.create(name: nil)
       @relation.commit_solr
-      @relation.where(:name => nil).should_not be_empty
+      expect(@relation.where(name: nil)).not_to be_empty
     end
-    
-    it "should return documents where a value is greater than the given value" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should return documents where a value is greater than the given value' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where(:complexity).greater_than(1.0).should_not be_empty
+      expect(@relation.where(:complexity).greater_than(1.0)).not_to be_empty
     end
-    
-    it "should allow :greater_than to be specified in a single call" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should allow :greater_than to be specified in a single call' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where(:complexity => {:greater_than => 1.0}).should_not be_empty
+      expect(@relation.where(complexity: { greater_than: 1.0 })).not_to be_empty
     end
-    
-    it "should return documents where a value is less than the given value" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should return documents where a value is less than the given value' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where(:complexity).less_than(2.0).should_not be_empty
+      expect(@relation.where(:complexity).less_than(2.0)).not_to be_empty
     end
-    
-    it "should allow :less_than to be specified in a single call" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should allow :less_than to be specified in a single call' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where(:complexity => {:less_than => 2.0}).should_not be_empty
+      expect(@relation.where(complexity: { less_than: 2.0 })).not_to be_empty
     end
-    
-    it "should allow arrays to be passed as OR queries" do
-      %w[fishing hiking boating jogging swimming chess].each do |word|
-        Hobby.create(:name => word)
+
+    it 'should allow arrays to be passed as OR queries' do
+      %w(fishing hiking boating jogging swimming chess).each do |word|
+        Hobby.create(name: word)
       end
       @relation.commit_solr
-      @relation.where(:name => ['boating', 'jogging', 'chess', 'skydiving']).size.should == 3
+      expect(@relation.where(name: %w(boating jogging chess skydiving)).size).to eq(3)
     end
-    
-    it "should handle negative numbers without breaking" do
-      Hobby.create(:name => 'jogging', :complexity => -1.2)
+
+    it 'should handle negative numbers without breaking' do
+      Hobby.create(name: 'jogging', complexity: -1.2)
       @relation.commit_solr
-      @relation.where(:complexity).less_than(-1).should_not be_empty
+      expect(@relation.where(:complexity).less_than(-1)).not_to be_empty
     end
-    
-    it "should not tokenize where queries on spaces" do
-      Hobby.create(:name => 'horseback riding')
+
+    it 'should not tokenize where queries on spaces' do
+      Hobby.create(name: 'horseback riding')
       @relation.commit_solr
-      @relation.where(:name => 'horseback').should be_empty
-      @relation.where(:name => 'horseback riding').should_not be_empty
-      @relation.where(:name => 'horseback ri*').should_not be_empty
+      expect(@relation.where(name: 'horseback')).to be_empty
+      expect(@relation.where(name: 'horseback riding')).not_to be_empty
+      expect(@relation.where(name: 'horseback ri*')).not_to be_empty
     end
-    
-    it "should not tokenize where queries on spaces inside arrays" do
-      Hobby.create(:name => 'horseback riding')
+
+    it 'should not tokenize where queries on spaces inside arrays' do
+      Hobby.create(name: 'horseback riding')
       @relation.commit_solr
-      @relation.where(:name => ['horseback riding', 'some other hobby']).should_not be_empty
+      expect(@relation.where(name: ['horseback riding', 'some other hobby'])).not_to be_empty
     end
-    
-    it "should search for values within a range" do
-      Hobby.create(:name => 'jogging', :complexity => 1.2)
+
+    it 'should search for values within a range' do
+      Hobby.create(name: 'jogging', complexity: 1.2)
       @relation.commit_solr
-      @relation.where(:complexity => 1..2).should_not be_empty
-      @relation.where(:complexity => 2..3).should be_empty
+      expect(@relation.where(complexity: 1..2)).not_to be_empty
+      expect(@relation.where(complexity: 2..3)).to be_empty
     end
   end
-  
-  describe "#where_not" do
-    it "should return documents where a field has any value" do
-      Hobby.create(:name => 'Swimming')
+
+  describe '#where_not' do
+    it 'should return documents where a field has any value' do
+      Hobby.create(name: 'Swimming')
       @relation.commit_solr
-      @relation.where_not(:name => nil).should_not be_empty
+      expect(@relation.where_not(name: nil)).not_to be_empty
     end
-    
-    it "should return documents where none of the options are present" do
-      Hobby.create(:name => 'Swimming')
-      Hobby.create(:name => 'Biking')
+
+    it 'should return documents where none of the options are present' do
+      Hobby.create(name: 'Swimming')
+      Hobby.create(name: 'Biking')
       @relation.commit_solr
-      @relation.where_not(:name => ['Swimming','Biking']).should be_empty
+      expect(@relation.where_not(name: %w(Swimming Biking))).to be_empty
     end
-    
-    it "should return documents where a value is not greater than the given value" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should return documents where a value is not greater than the given value' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where_not(:complexity).greater_than(2.0).should_not be_empty
+      expect(@relation.where_not(:complexity).greater_than(2.0)).not_to be_empty
     end
-    
-    it "should allow :greater_than to be specified in a single call" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should allow :greater_than to be specified in a single call' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where_not(:complexity => {:greater_than => 2.0}).should_not be_empty
+      expect(@relation.where_not(complexity: { greater_than: 2.0 })).not_to be_empty
     end
-    
-    it "should return documents where a value is not less than the given value" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should return documents where a value is not less than the given value' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where_not(:complexity).less_than(1.0).should_not be_empty
+      expect(@relation.where_not(:complexity).less_than(1.0)).not_to be_empty
     end
-    
-    it "should allow :less_than to be specified in a single call" do
-      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+
+    it 'should allow :less_than to be specified in a single call' do
+      Hobby.create(name: 'Swimming', complexity: 1.1)
       @relation.commit_solr
-      @relation.where_not(:complexity => {:less_than => 1.0}).should_not be_empty
+      expect(@relation.where_not(complexity: { less_than: 1.0 })).not_to be_empty
     end
-    
-    it "should search for values outside a range" do
-      Hobby.create(:name => 'jogging', :complexity => 1.2)
+
+    it 'should search for values outside a range' do
+      Hobby.create(name: 'jogging', complexity: 1.2)
       @relation.commit_solr
-      @relation.where_not(:complexity => 1..2).should be_empty
-      @relation.where_not(:complexity => 2..3).should_not be_empty
+      expect(@relation.where_not(complexity: 1..2)).to be_empty
+      expect(@relation.where_not(complexity: 2..3)).not_to be_empty
     end
   end
-  
-  describe "#fulltext" do
-    it "should allow case-insensitive wildcard searches" do
-      Hobby.create(:name => "Swimming")
+
+  describe '#fulltext' do
+    it 'should allow case-insensitive wildcard searches' do
+      Hobby.create(name: 'Swimming')
       @relation.commit_solr
-      @relation.fulltext("swimming").should_not be_empty
+      expect(@relation.fulltext('swimming')).not_to be_empty
     end
   end
-  
+
   describe '#highlight' do
-    let(:hl) { @relation.highlight(:name, :description, :snippet => 3, :fragsize => 200) }
-    
+    let(:hl) { @relation.highlight(:name, :description, snippet: 3, fragsize: 200) }
+
     it { expect(hl.highlight_options[:fields]).to eq [:name, :description] }
     it { expect(hl.highlight_options[:snippet]).to eq 3 }
     it { expect(hl.highlight_options[:fragsize]).to eq 200 }
-    
+
     context 'with duplicate fields' do
       let(:hl) { @relation.highlight(:name, :description, :name) }
-      
+
       it { expect(hl.highlight_options[:fields]).to eq [:name, :description] }
     end
   end
-  
+
   describe '#solr_format' do
     context 'when formatting Time' do
-      let(:time) { Time.new 2011, 10, 9, 8, 7, 6, "-05:00" }
-      let(:c) {DatastaxRails::Column.new("field", nil, "time")}
-      
-      it { expect(@relation.solr_format(c,time)).to eq '2011-10-09T13:07:06Z' }
+      let(:time) { Time.new 2011, 10, 9, 8, 7, 6, '-05:00' }
+      let(:c) { DatastaxRails::Column.new('field', nil, 'time') }
+
+      it { expect(@relation.solr_format(c, time)).to eq '2011-10-09T13:07:06Z' }
     end
-    
+
     context 'when formatting Date' do
       let(:date) { Date.new 2001, 2, 3 }
-      let(:c) {DatastaxRails::Column.new("field", nil, "date")}
-      
-      it { expect(@relation.solr_format(c,date)).to eq '2001-02-03T00:00:00Z' }
+      let(:c) { DatastaxRails::Column.new('field', nil, 'date') }
+
+      it { expect(@relation.solr_format(c, date)).to eq '2001-02-03T00:00:00Z' }
     end
-    
+
     context 'when formatting DateTime' do
-      let(:datetime) { DateTime.new 2001, 2, 3, 4, 5, 6, "-07:00" }
-      let(:c) {DatastaxRails::Column.new("field", nil, "timestamp")}
-      
-      it { expect(@relation.solr_format(c,datetime)).to eq '2001-02-03T11:05:06Z' }
+      let(:datetime) { DateTime.new 2001, 2, 3, 4, 5, 6, '-07:00' }
+      let(:c) { DatastaxRails::Column.new('field', nil, 'timestamp') }
+
+      it { expect(@relation.solr_format(c, datetime)).to eq '2001-02-03T11:05:06Z' }
     end
   end
-end
+end