cequel 1.4.2 → 1.4.3

data/spec/examples/record/record_set_spec.rb

@@ -33,7 +33,7 @@ describe Cequel::Record::RecordSet do
 
   model :PublishedPost do
     key :blog_subdomain, :ascii
-    key :published_at, :timeuuid
+    key :published_at, :timeuuid, order: :desc
     column :permalink, :ascii, index: true
   end
 
@@ -128,23 +128,23 @@ describe Cequel::Record::RecordSet do
       its(:subdomain) { should == 'blog-0' }
       its(:name) { should == 'Blog 0' }
 
-      it { should be_persisted }
-      it { should_not be_transient }
+      it { is_expected.to be_persisted }
+      it { is_expected.not_to be_transient }
 
       it 'should cast argument to correct type' do
-        Blog.find('blog-0'.force_encoding('ASCII-8BIT')).should == blogs.first
+        expect(Blog.find('blog-0'.force_encoding('ASCII-8BIT'))).to eq(blogs.first)
       end
 
       it 'should return multiple results as an array from vararg keys' do
-        Blog.find('blog-0', 'blog-1').should == blogs.first(2)
+        expect(Blog.find('blog-0', 'blog-1')).to eq(blogs.first(2))
       end
 
       it 'should return multiple results as an array from array of keys' do
-        Blog.find(['blog-0', 'blog-1']).should == blogs.first(2)
+        expect(Blog.find(['blog-0', 'blog-1'])).to eq(blogs.first(2))
       end
 
       it 'should return result in an array from one-element array of keys' do
-        Blog.find(['blog-1']).should == [blogs[1]]
+        expect(Blog.find(['blog-1'])).to eq([blogs[1]])
       end
 
       it 'should raise RecordNotFound if bad argument passed' do
@@ -161,14 +161,14 @@ describe Cequel::Record::RecordSet do
       its(:permalink) { should == 'cequel0' }
       its(:title) { should == 'Cequel 0' }
 
-      it { should be_persisted }
-      it { should_not be_transient }
-      specify { Post.new.should_not be_persisted }
-      specify { Post.new.should be_transient }
+      it { is_expected.to be_persisted }
+      it { is_expected.not_to be_transient }
+      specify { expect(Post.new).not_to be_persisted }
+      specify { expect(Post.new).to be_transient }
 
       it 'should cast all keys to correct type' do
-        Post['cassandra'.force_encoding('ASCII-8BIT')].
-          find('cequel0'.force_encoding('ASCII-8BIT')).should be
+        expect(Post['cassandra'.force_encoding('ASCII-8BIT')].
+          find('cequel0'.force_encoding('ASCII-8BIT'))).to be
       end
 
       it 'should raise RecordNotFound if bad argument passed' do
@@ -177,16 +177,16 @@ describe Cequel::Record::RecordSet do
       end
 
       it 'should take vararg of values for single key' do
-        Post.find('cassandra', 'cequel0').should == posts.first
+        expect(Post.find('cassandra', 'cequel0')).to eq(posts.first)
       end
 
       it 'should take multiple values for key' do
-        Post.find('cassandra', ['cequel0', 'cequel1']).should == posts.first(2)
+        expect(Post.find('cassandra', ['cequel0', 'cequel1'])).to eq(posts.first(2))
       end
 
       it 'should use Enumerable#find if block given' do
-        Post['cassandra'].find { |post| post.title.include?('1') }
-          .should == posts[1]
+        expect(Post['cassandra'].find { |post| post.title.include?('1') })
+          .to eq(posts[1])
       end
 
       it 'should raise error if not enough key values specified' do
@@ -202,21 +202,21 @@ describe Cequel::Record::RecordSet do
 
       it 'should not query the database' do
         disallow_queries!
-        subject.subdomain.should == 'blog-0'
+        expect(subject.subdomain).to eq('blog-0')
       end
 
       it 'should lazily query the database when attribute accessed' do
-        subject.name.should == 'Blog 0'
+        expect(subject.name).to eq('Blog 0')
       end
 
       it 'should get all eager-loadable attributes on first lazy load' do
         subject.name
         disallow_queries!
-        subject.description.should == 'This is Blog number 0'
+        expect(subject.description).to eq('This is Blog number 0')
       end
 
       it 'should cast argument' do
-        subject.subdomain.encoding.name.should == 'US-ASCII'
+        expect(subject.subdomain.encoding.name).to eq('US-ASCII')
       end
     end
 
@@ -226,31 +226,31 @@ describe Cequel::Record::RecordSet do
 
       it 'should not query the database' do
         expect(cequel).not_to receive(:execute)
-        subject.blog_subdomain.should == 'cassandra'
-        subject.permalink.should == 'cequel0'
+        expect(subject.blog_subdomain).to eq('cassandra')
+        expect(subject.permalink).to eq('cequel0')
       end
 
       it 'should cast all keys to the correct type' do
-        subject.blog_subdomain.encoding.name.should == 'US-ASCII'
-        subject.permalink.encoding.name.should == 'US-ASCII'
+        expect(subject.blog_subdomain.encoding.name).to eq('US-ASCII')
+        expect(subject.permalink.encoding.name).to eq('US-ASCII')
       end
 
       it 'should lazily query the database when attribute accessed' do
-        subject.title.should == 'Cequel 0'
+        expect(subject.title).to eq('Cequel 0')
       end
 
       it 'should get all eager-loadable attributes on first lazy load' do
         subject.title
         expect(cequel).not_to receive(:execute)
-        subject.body.should == 'Post number 0'
+        expect(subject.body).to eq('Post number 0')
       end
     end
 
     context 'partially specified compound primary key' do
       let(:records) { posts }
       it 'should create partial collection if not all keys specified' do
-        Post['cassandra'].find_each(:batch_size => 2).map(&:title).
-          should == (0...5).map { |i| "Cequel #{i}" }
+        expect(Post['cassandra'].find_each(:batch_size => 2).map(&:title)).
+          to eq((0...5).map { |i| "Cequel #{i}" })
       end
     end
   end
@@ -261,7 +261,7 @@ describe Cequel::Record::RecordSet do
       subject { Blog.values_at('blog-0', 'blog-1') }
 
       it 'should return both specified records' do
-        subject.map(&:subdomain).should =~ %w(blog-0 blog-1)
+        expect(subject.map(&:subdomain)).to match_array(%w(blog-0 blog-1))
       end
 
       it 'should not query the database' do
@@ -270,13 +270,14 @@ describe Cequel::Record::RecordSet do
       end
 
       it 'should load value lazily' do
-        subject.first.name.should == 'Blog 0'
+        expect(subject.first.name).to eq('Blog 0')
       end
 
       it 'should load values for all referenced records on first access' do
-        max_statements! 1
-        subject.first.name.should == 'Blog 0'
-        subject.last.name.should == 'Blog 1'
+        expect_statement_count 1 do
+          expect(subject.first.name).to eq('Blog 0')
+          expect(subject.last.name).to eq('Blog 1')
+        end
       end
     end
 
@@ -285,8 +286,8 @@ describe Cequel::Record::RecordSet do
       subject { Post.values_at('cassandra', 'postgres') }
 
       it 'should return scope to keys' do
-        subject.map { |post| post.title }.should =~ (0...5).
-          map { |i| ["Cequel #{i}", "Sequel #{i}"] }.flatten
+        expect(subject.map { |post| post.title }).to match_array((0...5).
+          map { |i| ["Cequel #{i}", "Sequel #{i}"] }.flatten)
       end
     end
 
@@ -297,14 +298,15 @@ describe Cequel::Record::RecordSet do
 
       it 'should return collection of unloaded models' do
         disallow_queries!
-        subject.map(&:key_values).
-          should == [['cassandra', 'cequel0'], ['orms', 'cequel0']]
+        expect(subject.map(&:key_values)).
+          to eq([['cassandra', 'cequel0'], ['orms', 'cequel0']])
       end
 
       it 'should lazy-load all records when properties of one accessed' do
-        max_statements! 1
-        subject.first.title.should == 'Cequel 0'
-        subject.second.title.should == 'Cequel ORM 0'
+        expect_statement_count 1 do
+          expect(subject.first.title).to eq('Cequel 0')
+          expect(subject.second.title).to eq('Cequel ORM 0')
+        end
       end
     end
 
@@ -314,14 +316,15 @@ describe Cequel::Record::RecordSet do
 
       it 'should combine partition key with each clustering column' do
         disallow_queries!
-        subject.map(&:key_values).
-          should == [['cassandra', 'cequel0'], ['cassandra', 'cequel1']]
+        expect(subject.map(&:key_values)).
+          to eq([['cassandra', 'cequel0'], ['cassandra', 'cequel1']])
       end
 
       it 'should lazily load all records when one record accessed' do
-        max_statements! 1
-        subject.first.title.should == 'Cequel 0'
-        subject.second.title.should == 'Cequel 1'
+        expect_statement_count 1 do
+          expect(subject.first.title).to eq('Cequel 0')
+          expect(subject.second.title).to eq('Cequel 1')
+        end
       end
 
       it 'should not allow collection columns to be selected' do
@@ -345,7 +348,7 @@ describe Cequel::Record::RecordSet do
     let(:records) { blogs }
 
     it 'should return all the records' do
-      Blog.all.map(&:subdomain).should =~ subdomains
+      expect(Blog.all.map(&:subdomain)).to match_array(subdomains)
     end
   end
 
@@ -353,14 +356,16 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, blogs, mongo_posts] }
 
     it 'should respect :batch_size argument' do
-      cequel.should_receive(:execute_with_consistency).twice.and_call_original
-      Blog.find_each(:batch_size => 2).map(&:subdomain).
-        should =~ subdomains
+      expect_statement_count 2 do
+        expect(Blog.find_each(:batch_size => 2).map(&:subdomain)).
+          to match_array(subdomains)
+      end
     end
 
     it 'should iterate over all keys' do
-      Post.find_each(:batch_size => 2).map(&:title).should =~
+      expect(Post.find_each(:batch_size => 2).map(&:title)).to match_array(
         (0...5).flat_map { |i| ["Cequel #{i}", "Sequel #{i}", "Mongoid #{i}"] }
+      )
     end
 
     describe "hydration" do
@@ -387,8 +392,9 @@ describe Cequel::Record::RecordSet do
     let!(:records) { [posts, blogs, mongo_posts] }
 
     it 'should respect :batch_size argument' do
-      cequel.should_receive(:execute_with_consistency).twice.and_call_original
-      Blog.find_in_batches(:batch_size => 2){|a_batch| next }
+      expect_statement_count 2 do
+        Blog.find_in_batches(:batch_size => 2){|a_batch| next }
+      end
     end
 
     it 'should iterate over all keys' do
@@ -400,7 +406,7 @@ describe Cequel::Record::RecordSet do
         found_posts += recs
       }
       expect(found_posts).to include(*expected_posts)
-      expect(found_posts).to have(expected_posts.size).items
+      expect(found_posts.length).to eq(expected_posts.size)
     end
 
     it 'should iterate over batches' do
@@ -436,21 +442,21 @@ describe Cequel::Record::RecordSet do
 
   describe '#[]' do
     it 'should return partial collection' do
-      Post['cassandra'].find_each(:batch_size => 2).map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].find_each(:batch_size => 2).map(&:title)).
+        to eq((0...5).map { |i| "Cequel #{i}" })
     end
 
     it 'should cast arguments correctly' do
-      Post['cassandra'.force_encoding('ASCII-8BIT')].
-        find_each(:batch_size => 2).map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'.force_encoding('ASCII-8BIT')].
+        find_each(:batch_size => 2).map(&:title)).
+        to eq((0...5).map { |i| "Cequel #{i}" })
     end
   end
 
   describe '#/' do
     it 'should behave like #[]' do
-      (Post / 'cassandra').find_each(:batch_size => 2).map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }
+      expect((Post / 'cassandra').find_each(:batch_size => 2).map(&:title)).
+        to eq((0...5).map { |i| "Cequel #{i}" })
     end
   end
 
@@ -458,18 +464,18 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, published_posts] }
 
     it 'should return collection after given key' do
-      Post['cassandra'].after('cequel1').map(&:title).
-        should == (2...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].after('cequel1').map(&:title)).
+        to eq((2...5).map { |i| "Cequel #{i}" })
     end
 
     it 'should cast argument' do
-      Post['cassandra'].after('cequel1'.force_encoding('ASCII-8BIT')).
-        map(&:title).should == (2...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].after('cequel1'.force_encoding('ASCII-8BIT')).
+        map(&:title)).to eq((2...5).map { |i| "Cequel #{i}" })
     end
 
     it 'should query Time range for Timeuuid key' do
-      PublishedPost['cassandra'].after(now - 3.minutes).map(&:permalink).
-        should == %w(cequel2 cequel3 cequel4)
+      expect(PublishedPost['cassandra'].after(now - 3.minutes).map(&:permalink)).
+        to eq(%w(cequel4 cequel3 cequel2))
     end
   end
 
@@ -477,18 +483,18 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, published_posts] }
 
     it 'should return collection starting with given key' do
-      Post['cassandra'].from('cequel1').map(&:title).
-        should == (1...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].from('cequel1').map(&:title)).
+        to eq((1...5).map { |i| "Cequel #{i}" })
     end
 
     it 'should cast argument' do
-      Post['cassandra'].from('cequel1'.force_encoding('ASCII-8BIT')).
-        map(&:title).should == (1...5).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].from('cequel1'.force_encoding('ASCII-8BIT')).
+        map(&:title)).to eq((1...5).map { |i| "Cequel #{i}" })
     end
 
     it 'should query Time range for Timeuuid key' do
-      PublishedPost['cassandra'].from(now - 3.minutes).map(&:permalink).
-        should == %w(cequel1 cequel2 cequel3 cequel4)
+      expect(PublishedPost['cassandra'].from(now - 3.minutes).map(&:permalink)).
+        to eq(%w(cequel4 cequel3 cequel2 cequel1))
     end
 
     it 'should raise ArgumentError when called on partition key' do
@@ -501,18 +507,18 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, published_posts] }
 
     it 'should return collection before given key' do
-      Post['cassandra'].before('cequel3').map(&:title).
-        should == (0...3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].before('cequel3').map(&:title)).
+        to eq((0...3).map { |i| "Cequel #{i}" })
     end
 
     it 'should query Time range for Timeuuid key' do
-      PublishedPost['cassandra'].before(now - 1.minute).map(&:permalink).
-        should == %w(cequel0 cequel1 cequel2)
+      expect(PublishedPost['cassandra'].before(now - 1.minute).map(&:permalink)).
+        to eq(%w(cequel2 cequel1 cequel0))
     end
 
     it 'should cast argument' do
-      Post['cassandra'].before('cequel3'.force_encoding('ASCII-8BIT')).
-        map(&:title).should == (0...3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].before('cequel3'.force_encoding('ASCII-8BIT')).
+        map(&:title)).to eq((0...3).map { |i| "Cequel #{i}" })
     end
   end
 
@@ -520,18 +526,18 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, published_posts] }
 
     it 'should return collection up to given key' do
-      Post['cassandra'].upto('cequel3').map(&:title).
-        should == (0..3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].upto('cequel3').map(&:title)).
+        to eq((0..3).map { |i| "Cequel #{i}" })
     end
 
     it 'should cast argument' do
-      Post['cassandra'].upto('cequel3'.force_encoding('ASCII-8BIT')).
-        map(&:title).should == (0..3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].upto('cequel3'.force_encoding('ASCII-8BIT')).
+        map(&:title)).to eq((0..3).map { |i| "Cequel #{i}" })
     end
 
     it 'should query Time range for Timeuuid key' do
-      PublishedPost['cassandra'].upto(now - 1.minute).map(&:permalink).
-        should == %w(cequel0 cequel1 cequel2 cequel3)
+      expect(PublishedPost['cassandra'].upto(now - 1.minute).map(&:permalink)).
+        to eq(%w(cequel3 cequel2 cequel1 cequel0))
     end
   end
 
@@ -539,68 +545,68 @@ describe Cequel::Record::RecordSet do
     let(:records) { [posts, published_posts] }
 
     it 'should return collection with inclusive upper bound' do
-      Post['cassandra'].in('cequel1'..'cequel3').map(&:title).
-        should == (1..3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].in('cequel1'..'cequel3').map(&:title)).
+        to eq((1..3).map { |i| "Cequel #{i}" })
     end
 
     it 'should cast arguments' do
-      Post['cassandra'].in('cequel1'.force_encoding('ASCII-8BIT')..
+      expect(Post['cassandra'].in('cequel1'.force_encoding('ASCII-8BIT')..
                               'cequel3'.force_encoding('ASCII-8BIT')).
-        map(&:title).should == (1..3).map { |i| "Cequel #{i}" }
+        map(&:title)).to eq((1..3).map { |i| "Cequel #{i}" })
     end
 
     it 'should return collection with exclusive upper bound' do
-      Post['cassandra'].in('cequel1'...'cequel3').map(&:title).
-        should == (1...3).map { |i| "Cequel #{i}" }
+      expect(Post['cassandra'].in('cequel1'...'cequel3').map(&:title)).
+        to eq((1...3).map { |i| "Cequel #{i}" })
     end
 
     it 'should query Time range for Timeuuid key' do
-      PublishedPost['cassandra'].in((now - 3.minutes)..(now - 1.minute)).
-        map(&:permalink).should == %w(cequel1 cequel2 cequel3)
+      expect(PublishedPost['cassandra'].in((now - 3.minutes)..(now - 1.minute)).
+        map(&:permalink)).to eq(%w(cequel3 cequel2 cequel1))
     end
 
     it 'should query Time range for Timeuuid key with exclusive upper bound' do
-      PublishedPost['cassandra'].in((now - 3.minutes)...(now - 1.minute)).
-        map(&:permalink).should == %w(cequel1 cequel2)
+      expect(PublishedPost['cassandra'].in((now - 3.minutes)...(now - 1.minute)).
+        map(&:permalink)).to eq(%w(cequel2 cequel1))
     end
   end
 
   describe '#reverse' do
-    let(:records) { [posts, comments] }
+    let(:records) { [published_posts, comments] }
 
     it 'should not call the database' do
       disallow_queries!
-      Post['cassandra'].reverse
+      PublishedPost['cassandra'].reverse
     end
 
     it 'should return collection in reverse' do
-      Post['cassandra'].reverse.map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }.reverse
+      expect(PublishedPost['cassandra'].reverse.map(&:permalink)).
+        to eq((0...5).map { |i| "cequel#{i}" })
     end
 
     it 'should batch iterate over collection in reverse' do
-      Post['cassandra'].reverse.find_each(:batch_size => 2).map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }.reverse
+      expect(PublishedPost['cassandra'].reverse.find_each(:batch_size => 2).map(&:permalink)).
+        to eq((0...5).map { |i| "cequel#{i}" })
     end
 
     it 'should raise an error if range key is a partition key' do
-      expect { Post.all.reverse }.to raise_error(Cequel::Record::IllegalQuery)
+      expect { PublishedPost.all.reverse }.to raise_error(Cequel::Record::IllegalQuery)
     end
 
     it 'should use the correct ordering column in deeply nested models' do
-      Comment['cassandra']['cequel0'].reverse.map(&:body).
-        should == (0...5).map { |i| "Comment #{i}" }.reverse
+      expect(Comment['cassandra']['cequel0'].reverse.map(&:body)).
+        to eq((0...5).map { |i| "Comment #{i}" }.reverse)
     end
   end
 
   describe 'last' do
     it 'should return the last instance' do
-      Post['cassandra'].last.title.should == "Cequel 4"
+      expect(Post['cassandra'].last.title).to eq("Cequel 4")
     end
 
     it 'should return the last N instances if specified' do
-      Post['cassandra'].last(3).map(&:title).
-        should == ["Cequel 2", "Cequel 3", "Cequel 4"]
+      expect(Post['cassandra'].last(3).map(&:title)).
+        to eq(["Cequel 2", "Cequel 3", "Cequel 4"])
     end
   end
 
@@ -609,16 +615,16 @@ describe Cequel::Record::RecordSet do
 
     context 'with no arguments' do
       it 'should return an arbitrary record' do
-        subdomains.should include(Blog.first.subdomain)
+        expect(subdomains).to include(Blog.first.subdomain)
       end
     end
 
     context 'with a given size' do
       subject { Blog.first(2) }
 
-      it { should be_a(Array) }
-      it { should have(2).items }
-      specify { (subject.map(&:subdomain) & subdomains).should have(2).items }
+      it { is_expected.to be_a(Array) }
+      its(:size) { should be(2) }
+      specify { expect((subject.map(&:subdomain) & subdomains).size).to be(2) }
     end
   end
 
@@ -626,7 +632,7 @@ describe Cequel::Record::RecordSet do
     let(:records) { blogs }
 
     it 'should return the number of records requested' do
-      Blog.limit(2).should have(2).entries
+      expect(Blog.limit(2).length).to be(2)
     end
   end
 
@@ -636,8 +642,8 @@ describe Cequel::Record::RecordSet do
     context 'with no block' do
       subject { Blog.select(:subdomain, :name).first }
 
-      it { should be_loaded(:name) }
-      it { should_not be_loaded(:description) }
+      it { is_expected.to be_loaded(:name) }
+      it { is_expected.not_to be_loaded(:description) }
       specify { expect { subject.name }.to_not raise_error }
       specify { expect { subject.description }.
         to raise_error(Cequel::Record::MissingAttributeError) }
@@ -645,8 +651,8 @@ describe Cequel::Record::RecordSet do
 
     context 'with block' do
       it 'should delegate to the Enumerable method' do
-        Blog.all.select { |p| p.subdomain[/\d+/].to_i.even? }.
-          map(&:subdomain).should =~ %w(blog-0 blog-2)
+        expect(Blog.all.select { |p| p.subdomain[/\d+/].to_i.even? }.
+          map(&:subdomain)).to match_array(%w(blog-0 blog-2))
       end
     end
   end
@@ -702,13 +708,13 @@ describe Cequel::Record::RecordSet do
 
     context 'secondary indexed column' do
       it 'should query for secondary indexed columns with two arguments' do
-        Post.where(:author_id, uuids.first).map(&:permalink).
-          should == %w(cequel0 cequel2 cequel4)
+        expect(Post.where(:author_id, uuids.first).map(&:permalink)).
+          to eq(%w(cequel0 cequel2 cequel4))
       end
 
       it 'should query for secondary indexed columns with hash argument' do
-        Post.where(author_id: uuids.first).map(&:permalink).
-          should == %w(cequel0 cequel2 cequel4)
+        expect(Post.where(author_id: uuids.first).map(&:permalink)).
+          to eq(%w(cequel0 cequel2 cequel4))
       end
 
       it 'should not allow multiple columns in the arguments' do
@@ -723,27 +729,25 @@ describe Cequel::Record::RecordSet do
       end
 
       it 'should cast argument for column' do
-        Post.where(:author_id, uuids.first.to_s).map(&:permalink).
-          should == %w(cequel0 cequel2 cequel4)
+        expect(Post.where(:author_id, uuids.first.to_s).map(&:permalink)).
+          to eq(%w(cequel0 cequel2 cequel4))
       end
     end
 
     context 'mixing keys and secondary-indexed columns' do
       it 'should allow mixture in hash argument' do
-        Post.where(blog_subdomain: 'cassandra', author_id: uuids.first).
-          should have(3).entries
+        expect(Post.where(blog_subdomain: 'cassandra', author_id: uuids.first).
+          entries.length).to be(3)
       end
 
       it 'should allow mixture in chain with primary first' do
-        Post.where(blog_subdomain: 'cassandra')
-          .where(author_id: uuids.first)
-          .should have(3).entries
+        expect(Post.where(blog_subdomain: 'cassandra')
+          .where(author_id: uuids.first).entries.length).to be(3)
       end
 
       it 'should allow mixture in chain with secondary first' do
-        Post.where(author_id: uuids.first)
-          .where(blog_subdomain: 'cassandra')
-        .should have(3).entries
+        expect(Post.where(author_id: uuids.first)
+          .where(blog_subdomain: 'cassandra').entries.length).to be(3)
       end
     end
 
@@ -774,14 +778,14 @@ describe Cequel::Record::RecordSet do
     let(:records) { blogs }
 
     it 'should count records' do
-      Blog.count.should == 3
+      expect(Blog.count).to eq(3)
     end
   end
 
   describe 'scope methods' do
     it 'should delegate unknown methods to class singleton with current scope' do
-      Post['cassandra'].latest(3).map(&:permalink).
-        should == %w(cequel4 cequel3 cequel2)
+      expect(Post['cassandra'].latest(3).map(&:permalink)).
+        to eq(%w(cequel4 cequel3 cequel2))
     end
 
     it 'should raise NoMethodError if undefined method called' do
@@ -794,23 +798,23 @@ describe Cequel::Record::RecordSet do
 
     it 'should be able to update with no scoping' do
       Post.update_all(title: 'Same Title')
-      Post.all.map(&:title).should == Array.new(posts.length) { 'Same Title' }
+      expect(Post.all.map(&:title)).to eq(Array.new(posts.length) { 'Same Title' })
     end
 
     it 'should update posts with scoping' do
       Post['cassandra'].update_all(title: 'Same Title')
-      Post['cassandra'].map(&:title).
-        should == Array.new(cassandra_posts.length) { 'Same Title' }
-      Post['postgres'].map(&:title).should == postgres_posts.map(&:title)
+      expect(Post['cassandra'].map(&:title)).
+        to eq(Array.new(cassandra_posts.length) { 'Same Title' })
+      expect(Post['postgres'].map(&:title)).to eq(postgres_posts.map(&:title))
     end
 
     it 'should update fully specified collection' do
       Post['cassandra'].values_at('cequel0', 'cequel1', 'cequel2').
         update_all(title: 'Same Title')
-      Post['cassandra'].values_at('cequel0', 'cequel1', 'cequel2').map(&:title).
-        should == Array.new(3) { 'Same Title' }
-      Post['cassandra'].values_at('cequel3', 'cequel4').map(&:title).
-        should == cassandra_posts.drop(3).map(&:title)
+      expect(Post['cassandra'].values_at('cequel0', 'cequel1', 'cequel2').map(&:title)).
+        to eq(Array.new(3) { 'Same Title' })
+      expect(Post['cassandra'].values_at('cequel3', 'cequel4').map(&:title)).
+        to eq(cassandra_posts.drop(3).map(&:title))
     end
   end
 
@@ -819,19 +823,19 @@ describe Cequel::Record::RecordSet do
 
     it 'should be able to delete with no scoping' do
       Post.delete_all
-      Post.count.should be_zero
+      expect(Post.count).to be_zero
     end
 
     it 'should be able to delete with scoping' do
       Post['postgres'].delete_all
-      Post['postgres'].count.should be_zero
-      Post['cassandra'].count.should == cassandra_posts.length
+      expect(Post['postgres'].count).to be_zero
+      expect(Post['cassandra'].count).to eq(cassandra_posts.length)
     end
 
     it 'should be able to delete fully specified collection' do
       Post['postgres'].values_at('sequel0', 'sequel1').delete_all
-      Post['postgres'].map(&:permalink).
-        should == postgres_posts.drop(2).map(&:permalink)
+      expect(Post['postgres'].map(&:permalink)).
+        to eq(postgres_posts.drop(2).map(&:permalink))
     end
   end
 
@@ -840,19 +844,19 @@ describe Cequel::Record::RecordSet do
 
     it 'should be able to delete with no scoping' do
       Post.destroy_all
-      Post.count.should be_zero
+      expect(Post.count).to be_zero
     end
 
     it 'should be able to delete with scoping' do
       Post['postgres'].destroy_all
-      Post['postgres'].count.should be_zero
-      Post['cassandra'].count.should == cassandra_posts.length
+      expect(Post['postgres'].count).to be_zero
+      expect(Post['cassandra'].count).to eq(cassandra_posts.length)
     end
 
     it 'should be able to delete fully specified collection' do
       Post['postgres'].values_at('sequel0', 'sequel1').destroy_all
-      Post['postgres'].map(&:permalink).
-        should == postgres_posts.drop(2).map(&:permalink)
+      expect(Post['postgres'].map(&:permalink)).
+        to eq(postgres_posts.drop(2).map(&:permalink))
     end
   end