cequel 1.4.2 → 1.4.3

data/spec/examples/metal/keyspace_spec.rb

@@ -21,13 +21,13 @@ describe Cequel::Metal::Keyspace do
 
   describe '::batch' do
     it 'should send enclosed write statements in bulk' do
-      expect(cequel).to receive(:execute).once.and_call_original
-      cequel.batch do
-        cequel[:posts].insert(id: 1, title: 'Hey')
-        cequel[:posts].where(id: 1).update(body: 'Body')
-        cequel[:posts].where(id: 1).delete(:title)
+      expect_statement_count 1 do
+        cequel.batch do
+          cequel[:posts].insert(id: 1, title: 'Hey')
+          cequel[:posts].where(id: 1).update(body: 'Body')
+          cequel[:posts].where(id: 1).delete(:title)
+        end
       end
-      RSpec::Mocks.proxy_for(cequel).reset
       expect(cequel[:posts].first).to eq({id: 1, title: nil, body: 'Body'}
         .with_indifferent_access)
     end
@@ -96,20 +96,12 @@ describe Cequel::Metal::Keyspace do
     end
 
     context "with a connection error" do
-      after(:each) do
-        RSpec::Mocks.proxy_for(cequel).reset
-      end
-
       it "reconnects to cassandra with a new client after first failed connection" do
-        allow(cequel).to receive(:execute_with_consistency)
+        allow(cequel.client).to receive(:execute_with_consistency)
           .with(statement, [], nil)
           .and_raise(Ione::Io::ConnectionError)
           .once
 
-        expect(cequel).to receive(:execute_with_consistency)
-          .with(statement, [], :quorum)
-          .once
-
         expect { cequel.execute(statement) }.not_to raise_error
       end
     end

data/spec/examples/record/associations_spec.rb

@@ -55,29 +55,29 @@ describe Cequel::Record::Associations do
     let(:post) { Post.new }
 
     it 'should add parent key as first key' do
-      Post.key_column_names.first.should == :blog_subdomain
+      expect(Post.key_column_names.first).to eq(:blog_subdomain)
     end
 
     it 'should add parent key as the partition key' do
-      Post.partition_key_column_names.should == [:blog_subdomain]
+      expect(Post.partition_key_column_names).to eq([:blog_subdomain])
     end
 
     it "should add parent's keys as first keys" do
-      Comment.key_column_names.first(2).should == [:post_blog_subdomain, :post_id]
+      expect(Comment.key_column_names.first(2)).to eq([:post_blog_subdomain, :post_id])
     end
 
     it "should add parent's first key as partition key" do
-      Comment.partition_key_column_names.should == [:post_blog_subdomain]
+      expect(Comment.partition_key_column_names).to eq([:post_blog_subdomain])
     end
 
     it 'should provide accessors for association object' do
       post.blog = blog
-      post.blog.should == blog
+      expect(post.blog).to eq(blog)
     end
 
     it 'should set parent key(s) when setting association object' do
       post.blog = blog
-      post.blog_subdomain.should == 'big-data'
+      expect(post.blog_subdomain).to eq('big-data')
     end
 
     it 'should raise ArgumentError when parent is set without keys' do
@@ -91,13 +91,13 @@ describe Cequel::Record::Associations do
 
     it 'should return Blog instance when parent key set directly' do
       post.blog_subdomain = 'big-data'
-      post.blog.subdomain.should == 'big-data'
+      expect(post.blog.subdomain).to eq('big-data')
     end
 
     it 'should not hydrate parent instance when creating from key' do
       post.blog_subdomain = 'big-data'
       disallow_queries!
-      post.blog.should_not be_loaded
+      expect(post.blog).not_to be_loaded
     end
 
     it 'should not allow declaring belongs_to after key' do
@@ -125,22 +125,22 @@ describe Cequel::Record::Associations do
       let(:photo) { Photo.new }
 
       it "should add parent's keys as first keys" do
-        Photo.key_column_names.first(2).should == [:post_blog_subdomain, :post_id]
+        expect(Photo.key_column_names.first(2)).to eq([:post_blog_subdomain, :post_id])
       end
 
       it "should add parent's keys as partition keys" do
-        Photo.partition_key_column_names.should == [:post_blog_subdomain, :post_id]
+        expect(Photo.partition_key_column_names).to eq([:post_blog_subdomain, :post_id])
       end
 
       it 'should provide accessors for association object' do
         photo.post = post
-        photo.post.should == post
+        expect(photo.post).to eq(post)
       end
 
       it 'should set parent key(s) when setting association object' do
         photo.post = post
-        photo.post_blog_subdomain.should == 'big-data'
-        photo.post_id.should == post.id
+        expect(photo.post_blog_subdomain).to eq('big-data')
+        expect(photo.post_id).to eq(post.id)
       end
 
       it 'should raise ArgumentError when parent is set without a key' do
@@ -155,14 +155,14 @@ describe Cequel::Record::Associations do
       it 'should return Photo instance when parent keys are set directly' do
         photo.post_blog_subdomain = 'big-data'
         photo.post_id = post.id
-        photo.post.should == post
+        expect(photo.post).to eq(post)
       end
 
       it 'should not hydrate parent instance when creating from keys' do
         photo.post_blog_subdomain = 'big-data'
         photo.post_id = post.id
         disallow_queries!
-        photo.post.should_not be_loaded
+        expect(photo.post).not_to be_loaded
       end
 
       it 'should not allow declaring belongs_to after key' do
@@ -208,32 +208,32 @@ describe Cequel::Record::Associations do
     end
 
     it 'should return scope of posts' do
-      blog.posts.map(&:title).should == ["Post 0", "Post 1", "Post 2"]
+      expect(blog.posts.map(&:title)).to eq(["Post 0", "Post 1", "Post 2"])
     end
 
     it 'should retain scope when hydrated multiple times' do
       blog.posts.map(&:id)
       disallow_queries!
-      blog.posts.map(&:title).should == ["Post 0", "Post 1", "Post 2"]
+      expect(blog.posts.map(&:title)).to eq(["Post 0", "Post 1", "Post 2"])
     end
 
     it 'should reload when reload argument passed' do
       blog.posts.map(&:id)
       posts.first.destroy
-      blog.posts(true).map(&:title).should == ['Post 1', 'Post 2']
+      expect(blog.posts(true).map(&:title)).to eq(['Post 1', 'Post 2'])
     end
 
     it 'should support #find with key' do
-      blog.posts.find(posts.first.id).should == posts.first
+      expect(blog.posts.find(posts.first.id)).to eq(posts.first)
     end
 
     it 'should support #find with block' do
-      blog.posts.find { |post| post.title.include?('1') }.should == posts[1]
+      expect(blog.posts.find { |post| post.title.include?('1') }).to eq(posts[1])
     end
 
     it 'should support #select with block' do
-      blog.posts.select { |post| !post.title.include?('2') }
-        .should == posts.first(2)
+      expect(blog.posts.select { |post| !post.title.include?('2') })
+        .to eq(posts.first(2))
     end
 
     it 'should support #select with arguments' do
@@ -243,35 +243,35 @@ describe Cequel::Record::Associations do
 
     it 'should load #first directly from the database if unloaded' do
       blog.posts.first.title
-      blog.posts.should_not be_loaded
+      expect(blog.posts).not_to be_loaded
     end
 
     it 'should read #first from loaded collection' do
       blog.posts.entries
       disallow_queries!
-      blog.posts.first.title.should == 'Post 0'
+      expect(blog.posts.first.title).to eq('Post 0')
     end
 
     it 'should always query the database for #count' do
       blog.posts.entries
       posts.first.destroy
-      blog.posts.count.should == 2
+      expect(blog.posts.count).to eq(2)
     end
 
     it 'should always load the records for #length' do
-      blog.posts.length.should == 3
-      blog.posts.should be_loaded
+      expect(blog.posts.length).to eq(3)
+      expect(blog.posts).to be_loaded
     end
 
     it 'should count from database for #size if unloaded' do
-      blog.posts.size.should == 3
-      blog.posts.should_not be_loaded
+      expect(blog.posts.size).to eq(3)
+      expect(blog.posts).not_to be_loaded
     end
 
     it 'should count records in memory for #size if loaded' do
       blog.posts.entries
       disallow_queries!
-      blog.posts.size.should == 3
+      expect(blog.posts.size).to eq(3)
     end
 
     it "does not allow invalid :dependent options" do

data/spec/examples/record/callbacks_spec.rb

@@ -68,28 +68,28 @@ describe Cequel::Record::Callbacks do
     before { new_post.save! }
     subject { new_post.executed_callbacks }
 
-    it { should include(:before_save) }
-    it { should include(:after_save) }
-    it { should include(:before_create) }
-    it { should include(:after_create) }
-    it { should_not include(:before_update) }
-    it { should_not include(:after_update) }
-    it { should_not include(:before_destroy) }
-    it { should_not include(:after_destroy) }
+    it { is_expected.to include(:before_save) }
+    it { is_expected.to include(:after_save) }
+    it { is_expected.to include(:before_create) }
+    it { is_expected.to include(:after_create) }
+    it { is_expected.not_to include(:before_update) }
+    it { is_expected.not_to include(:after_update) }
+    it { is_expected.not_to include(:before_destroy) }
+    it { is_expected.not_to include(:after_destroy) }
   end
 
   context 'on update' do
     before { existing_post.save! }
     subject { existing_post.executed_callbacks }
 
-    it { should include(:before_save) }
-    it { should include(:after_save) }
-    it { should_not include(:before_create) }
-    it { should_not include(:after_create) }
-    it { should include(:before_update) }
-    it { should include(:after_update) }
-    it { should_not include(:before_destroy) }
-    it { should_not include(:after_destroy) }
+    it { is_expected.to include(:before_save) }
+    it { is_expected.to include(:after_save) }
+    it { is_expected.not_to include(:before_create) }
+    it { is_expected.not_to include(:after_create) }
+    it { is_expected.to include(:before_update) }
+    it { is_expected.to include(:after_update) }
+    it { is_expected.not_to include(:before_destroy) }
+    it { is_expected.not_to include(:after_destroy) }
   end
 
   context 'on destroy' do
@@ -97,14 +97,14 @@ describe Cequel::Record::Callbacks do
 
     subject { existing_post.executed_callbacks }
 
-    it { should_not include(:before_save) }
-    it { should_not include(:after_save) }
-    it { should_not include(:before_create) }
-    it { should_not include(:after_create) }
-    it { should_not include(:before_update) }
-    it { should_not include(:after_update) }
-    it { should include(:before_destroy) }
-    it { should include(:after_destroy) }
+    it { is_expected.not_to include(:before_save) }
+    it { is_expected.not_to include(:after_save) }
+    it { is_expected.not_to include(:before_create) }
+    it { is_expected.not_to include(:after_create) }
+    it { is_expected.not_to include(:before_update) }
+    it { is_expected.not_to include(:after_update) }
+    it { is_expected.to include(:before_destroy) }
+    it { is_expected.to include(:after_destroy) }
   end
 
   describe 'atomic writes' do
@@ -114,7 +114,7 @@ describe Cequel::Record::Callbacks do
         -> { expect { Post.find('autopost') }.
           to raise_error(Cequel::Record::RecordNotFound) }
       comment.save!
-      Post.find('autopost').title.should == 'Auto Post'
+      expect(Post.find('autopost').title).to eq('Auto Post')
     end
   end
 end

data/spec/examples/record/dirty_spec.rb

@@ -18,43 +18,44 @@ describe Cequel::Record::Dirty do
     end
 
     it 'should not have changed attributes by default' do
-      post.changed_attributes.should be_empty
+      expect(post.changed_attributes).to be_empty
     end
 
     it 'should have changed attributes if attributes change' do
       post.title = 'Cequel ORM'
-      post.changed_attributes.
-        should == {:title => 'Cequel'}.with_indifferent_access
+      expect(post.changed_attributes).
+        to eq({:title => 'Cequel'}.with_indifferent_access)
     end
 
     it 'should not have changed attributes if attribute set to the same thing' do
       post.title = 'Cequel'
-      post.changed_attributes.should be_empty
+      expect(post.changed_attributes).to be_empty
     end
 
     it 'should support *_changed? method' do
       post.title = 'Cequel ORM'
-      post.title_changed?.should be_true
+      expect(post.title_changed?).to eq(true)
     end
 
     it 'should not have changed attributes after save' do
       post.title = 'Cequel ORM'
       post.save
-      post.changed_attributes.should be_empty
+      expect(post.changed_attributes).to be_empty
     end
 
     it 'should have previous changes after save' do
       post.title = 'Cequel ORM'
       post.save
-      post.previous_changes.
-        should == { :title => ['Cequel', 'Cequel ORM'] }.with_indifferent_access
+      expect(post.previous_changes).
+        to eq({ :title => ['Cequel', 'Cequel ORM'] }.with_indifferent_access)
     end
 
     it 'should detect changes to collections' do
       post.categories << 'Gems'
-      post.changes.should ==
+      expect(post.changes).to eq(
         {categories: [Set['Libraries'], Set['Libraries', 'Gems']]}.
         with_indifferent_access
+      )
     end
   end
 
@@ -63,7 +64,7 @@ describe Cequel::Record::Dirty do
 
     it 'should not track changes' do
       post.title = 'Cequel'
-      post.changes.should be_empty
+      expect(post.changes).to be_empty
     end
   end
 end

data/spec/examples/record/list_spec.rb

@@ -26,7 +26,7 @@ describe Cequel::Record::List do
 
   context 'new record' do
     it 'should save list as-is' do
-      subject[:tags].should == %w(one two)
+      expect(subject[:tags]).to eq(%w(one two))
     end
   end
 
@@ -34,13 +34,13 @@ describe Cequel::Record::List do
     it 'should overwrite value' do
       post.tags = %w(three four)
       post.save!
-      subject[:tags].should == %w(three four)
+      expect(subject[:tags]).to eq(%w(three four))
     end
 
     it 'should cast collection before overwriting' do
       post.tags = Set['three', 'four']
       post.save!
-      subject[:tags].should == %w(three four)
+      expect(subject[:tags]).to eq(%w(three four))
     end
   end
 
@@ -48,21 +48,21 @@ describe Cequel::Record::List do
     it 'should add new items' do
       post.tags << 'three' << 'four'
       post.save
-      subject[:tags].should == %w(one two three four)
+      expect(subject[:tags]).to eq(%w(one two three four))
     end
 
     it 'should add new items atomically' do
       scope.list_append(:tags, 'three')
       post.tags << 'four' << 'five'
       post.save
-      subject[:tags].should == %w(one two three four five)
+      expect(subject[:tags]).to eq(%w(one two three four five))
     end
 
     it 'should add new items without reading' do
       unloaded_post.tags << 'four' << 'five'
       unloaded_post.save
-      unloaded_post.should_not be_loaded
-      subject[:tags].should == %w(one two four five)
+      expect(unloaded_post).not_to be_loaded
+      expect(subject[:tags]).to eq(%w(one two four five))
     end
 
     it 'should load itself and then add new items in memory when unloaded' do
@@ -82,7 +82,7 @@ describe Cequel::Record::List do
     it 'should atomically replace a single element' do
       post.tags[1] = 'TWO'
       post.save
-      subject[:tags].should == %w(one TWO three)
+      expect(subject[:tags]).to eq(%w(one TWO three))
       expect(post.tags).to eq(%w(one TWO))
     end
 
@@ -92,14 +92,14 @@ describe Cequel::Record::List do
     end
 
     it 'should replace an element without reading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags[1] = 'TWO'
     end
 
     it 'should persist the replaced element' do
       unloaded_post.tags[1] = 'TWO'
       unloaded_post.save
-      subject[:tags].should == %w(one TWO three)
+      expect(subject[:tags]).to eq(%w(one TWO three))
     end
 
     it 'should apply local modifications when loaded later' do
@@ -110,7 +110,7 @@ describe Cequel::Record::List do
     it 'should atomically replace a given number of arguments' do
       post.tags[0, 2] = 'One', 'Two'
       post.save
-      subject[:tags].should == %w(One Two three)
+      expect(subject[:tags]).to eq(%w(One Two three))
       expect(post.tags).to eq(%w(One Two))
     end
 
@@ -123,14 +123,14 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'four')
       post.tags[0, 3] = 'ONE'
       post.save
-      subject[:tags].should == %w(ONE four)
+      expect(subject[:tags]).to eq(%w(ONE four))
       expect(post.tags).to eq(%w(ONE))
     end
 
     it 'should atomically replace a given range of elements' do
       post.tags[0..1] = ['One', 'Two']
       post.save
-      subject[:tags].should == %w(One Two three)
+      expect(subject[:tags]).to eq(%w(One Two three))
       expect(post.tags).to eq(%w(One Two))
     end
 
@@ -138,7 +138,7 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'four')
       post.tags[0..2] = 'ONE'
       post.save
-      subject[:tags].should == %w(ONE four)
+      expect(subject[:tags]).to eq(%w(ONE four))
       expect(post.tags).to eq(%w(ONE))
     end
   end
@@ -147,19 +147,19 @@ describe Cequel::Record::List do
     it 'should clear all elements from the array' do
       post.tags.clear
       post.save
-      subject[:tags].should be_blank
+      expect(subject[:tags]).to be_blank
       expect(post.tags).to eq([])
     end
 
     it 'should clear elements without loading' do
-      cequel.should_not receive(:execute)
+      expect(cequel).not_to receive(:execute)
       unloaded_post.tags.clear
     end
 
     it 'should persist clear without loading' do
       unloaded_post.tags.clear
       unloaded_post.save
-      subject[:tags].should be_blank
+      expect(subject[:tags]).to be_blank
     end
 
     it 'should apply local modifications post-hoc' do
@@ -179,7 +179,7 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'three')
       post.tags.concat(['four', 'five'])
       post.save
-      subject[:tags].should == %w(one two three four five)
+      expect(subject[:tags]).to eq(%w(one two three four five))
       expect(post.tags).to eq(%w(one two four five))
     end
 
@@ -189,14 +189,14 @@ describe Cequel::Record::List do
     end
 
     it 'should concat elements without loading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags.concat(['four', 'five'])
     end
 
     it 'should persist concatenated elements' do
       unloaded_post.tags.concat(['four', 'five'])
       unloaded_post.save
-      subject[:tags].should == %w(one two four five)
+      expect(subject[:tags]).to eq(%w(one two four five))
     end
 
     it 'should apply local modifications when loaded later' do
@@ -211,7 +211,7 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'two')
       post.tags.delete('two')
       post.save
-      subject[:tags].should == %w(one three)
+      expect(subject[:tags]).to eq(%w(one three))
       expect(post.tags).to eq(%w(one))
     end
 
@@ -221,14 +221,14 @@ describe Cequel::Record::List do
     end
 
     it 'should delete without loading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags.delete('two')
     end
 
     it 'should persist deletions without loading' do
       unloaded_post.tags.delete('two')
       unloaded_post.save
-      subject[:tags].should == %w(one)
+      expect(subject[:tags]).to eq(%w(one))
     end
 
     it 'should modify local copy after the fact' do
@@ -242,19 +242,19 @@ describe Cequel::Record::List do
       scope.list_append(:tags, ['three', 'four'])
       post.tags.delete_at(1)
       post.save
-      subject[:tags].should == %w(one three four)
+      expect(subject[:tags]).to eq(%w(one three four))
       expect(post.tags).to eq(%w(one))
     end
 
     it 'should delete from a given index without reading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags.delete_at(1)
     end
 
     it 'should persist deletion from unloaded list' do
       unloaded_post.tags.delete_at(1)
       unloaded_post.save
-      subject[:tags].should == %w(one)
+      expect(subject[:tags]).to eq(%w(one))
     end
 
     it 'should apply deletion after the fact' do
@@ -313,7 +313,7 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'three')
       post.tags.push('four').push('five')
       post.save
-      subject[:tags].should == %w(one two three four five)
+      expect(subject[:tags]).to eq(%w(one two three four five))
       expect(post.tags).to eq(%w(one two four five))
     end
   end
@@ -330,7 +330,7 @@ describe Cequel::Record::List do
       scope.list_append(:tags, 'three')
       post.tags.replace(%w(four five))
       post.save
-      subject[:tags].should == %w(four five)
+      expect(subject[:tags]).to eq(%w(four five))
       expect(post.tags).to eq(%w(four five))
     end
 
@@ -340,14 +340,14 @@ describe Cequel::Record::List do
     end
 
     it 'should overwrite without reading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags.replace(%w(four five))
     end
 
     it 'should persist unloaded overwrite' do
       unloaded_post.tags.replace(%w(four five))
       unloaded_post.save
-      subject[:tags].should == %w(four five)
+      expect(subject[:tags]).to eq(%w(four five))
     end
 
     it 'should apply replace post-hoc' do
@@ -417,7 +417,7 @@ describe Cequel::Record::List do
       scope.list_prepend(:tags, 'zero')
       post.tags.unshift('minustwo', 'minusone')
       post.save
-      subject[:tags].should == %w(minustwo minusone zero one two)
+      expect(subject[:tags]).to eq(%w(minustwo minusone zero one two))
       expect(post.tags).to eq(%w(minustwo minusone one two))
     end
 
@@ -427,14 +427,14 @@ describe Cequel::Record::List do
     end
 
     it 'should unshift without reading' do
-      cequel.should_not_receive :execute
+      disallow_queries!
       unloaded_post.tags.unshift('minustwo', 'minusone')
     end
 
     it 'should persist unloaded unshift' do
       unloaded_post.tags.unshift('minustwo', 'minusone')
       unloaded_post.save
-      subject[:tags].should == %w(minustwo minusone one two)
+      expect(subject[:tags]).to eq(%w(minustwo minusone one two))
     end
 
     it 'should apply unshift after the fact' do