asset_cloud 2.5.0 → 2.6.1

data/spec/base_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class SpecialAsset < AssetCloud::Asset
@@ -8,7 +9,7 @@ end
 
 class BasicCloud < AssetCloud::Base
   bucket :special, AssetCloud::MemoryBucket, asset_class: SpecialAsset
-  bucket :conditional, AssetCloud::MemoryBucket, asset_class: Proc.new {|key|
+  bucket :conditional, AssetCloud::MemoryBucket, asset_class: proc { |key|
     LiquidAsset if key.ends_with?('.liquid')
   }
 end
@@ -17,71 +18,69 @@ describe BasicCloud do
   directory = File.dirname(__FILE__) + '/files'
 
   before do
-    @fs = BasicCloud.new(directory , 'http://assets/files' )
+    @fs = BasicCloud.new(directory, 'http://assets/files')
   end
 
   it "should raise invalid bucket if none is given" do
-    @fs['image.jpg'].exist?.should == false
+    expect(@fs['image.jpg'].exist?).to(eq(false))
   end
 
-
   it "should be backed by a file system bucket" do
-    @fs['products/key.txt'].exist?.should == true
+    expect(@fs['products/key.txt'].exist?).to(eq(true))
   end
 
   it "should raise when listing non existing buckets" do
-    @fs.ls('products').should == [AssetCloud::Asset.new(@fs, 'products/key.txt')]
+    expect(@fs.ls('products')).to(eq([AssetCloud::Asset.new(@fs, 'products/key.txt')]))
   end
 
-
   it "should allow you to create new assets" do
     obj = @fs.build('new_file.test')
-    obj.should be_an_instance_of(AssetCloud::Asset)
-    obj.cloud.should be_an_instance_of(BasicCloud)
+    expect(obj).to(be_an_instance_of(AssetCloud::Asset))
+    expect(obj.cloud).to(be_an_instance_of(BasicCloud))
   end
 
   it "should raise error when using with minus relative or absolute paths" do
-    lambda { @fs['../test']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test']    }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['.../test'] }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['./test']   }.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['../test']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test']    }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['.../test'] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['./test']   }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename has trailing period" do
-    lambda { @fs['test.']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile.']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/.']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile .']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory /.'] }.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['test.']             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test/testfile.']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory/.']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test/testfile .']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory /.'] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename ends with space" do
-    lambda { @fs['test ']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile ']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/ ']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test. ']            }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile. ']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/. '] }.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['test ']             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test/testfile ']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory/ ']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test. ']            }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test/testfile. ']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory/. '] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename ends with slash" do
-    lambda { @fs['test/']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test /']            }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile /']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory//']  }.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['test/']             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory/']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test /']            }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['/test/testfile /']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/directory//']  }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when using with minus relative even after another directory" do
-    lambda { @fs['test/../test']      }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/../../test']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/../../../test']}.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['test/../test']      }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/../../test']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test/../../../test'] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise an error when using names with combinations of '.' and ' '" do
-    lambda { @fs['test. . . .. ... .. . ']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test. .']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test.   .test2']   }.should raise_error(AssetCloud::IllegalPath)
+    expect { @fs['test. . . .. ... .. . ']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test. .'] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs['test.   .test2'] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should allow filenames with repeating dots" do
@@ -125,41 +124,41 @@ describe BasicCloud do
   end
 
   it "should compute complete urls to assets" do
-    @fs.url_for('products/key with spaces.txt').should == 'http://assets/files/products/key%20with%20spaces.txt'
+    expect(@fs.url_for('products/[key] with spaces.txt?foo=1&bar=2')).to(eq('http://assets/files/products/[key]%20with%20spaces.txt?foo=1&bar=2'))
   end
 
   describe "#find" do
     it "should return the appropriate asset when one exists" do
       asset = @fs.find('products/key.txt')
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      expect(asset.key).to(eq('products/key.txt'))
+      expect(asset.value).to(eq('value'))
     end
     it "should raise AssetNotFoundError when the asset doesn't exist" do
-      lambda { @fs.find('products/not-there.txt') }.should raise_error(AssetCloud::AssetNotFoundError)
+      expect { @fs.find('products/not-there.txt') }.to(raise_error(AssetCloud::AssetNotFoundError))
     end
   end
 
   describe "#[]" do
     it "should return the appropriate asset when one exists" do
       asset = @fs['products/key.txt']
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      expect(asset.key).to(eq('products/key.txt'))
+      expect(asset.value).to(eq('value'))
     end
     it "should not raise any errors when the asset doesn't exist" do
-      lambda { @fs['products/not-there.txt'] }.should_not raise_error
+      expect { @fs['products/not-there.txt'] }.not_to(raise_error)
     end
   end
 
   describe "#move" do
     it "should return move a resource" do
       asset = @fs['products/key.txt']
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      expect(asset.key).to(eq('products/key.txt'))
+      expect(asset.value).to(eq('value'))
       @fs.move('products/key.txt', 'products/key2.txt')
       new_asset = @fs['products/key2.txt']
-      new_asset.key.should == 'products/key2.txt'
-      new_asset.value.should == 'value'
-      expect {@fs['products/key.txt'].value }.to raise_error(AssetCloud::AssetNotFoundError)
+      expect(new_asset.key).to(eq('products/key2.txt'))
+      expect(new_asset.value).to(eq('value'))
+      expect { @fs['products/key.txt'].value }.to(raise_error(AssetCloud::AssetNotFoundError))
       @fs.move('products/key2.txt', 'products/key.txt')
     end
   end
@@ -167,46 +166,45 @@ describe BasicCloud do
   describe "#[]=" do
     it "should write through the Asset object (and thus run any callbacks on the asset)" do
       special_asset = double(:special_asset)
-      special_asset.should_receive(:value=).with('fancy fancy!')
-      special_asset.should_receive(:store)
-      SpecialAsset.should_receive(:at).and_return(special_asset)
+      expect(special_asset).to(receive(:value=).with('fancy fancy!'))
+      expect(special_asset).to(receive(:store))
+      expect(SpecialAsset).to(receive(:at).and_return(special_asset))
       @fs['special/fancy.txt'] = 'fancy fancy!'
     end
   end
 
   describe "#bucket" do
     it "should allow specifying a class to use for assets in this bucket" do
-      @fs['assets/rails_logo.gif'].should be_instance_of(AssetCloud::Asset)
-      @fs['special/fancy.txt'].should be_instance_of(SpecialAsset)
+      expect(@fs['assets/rails_logo.gif']).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs['special/fancy.txt']).to(be_instance_of(SpecialAsset))
 
-      @fs.build('assets/foo').should be_instance_of(AssetCloud::Asset)
-      @fs.build('special/foo').should be_instance_of(SpecialAsset)
+      expect(@fs.build('assets/foo')).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs.build('special/foo')).to(be_instance_of(SpecialAsset))
     end
 
     it "should allow specifying a proc that determines the class to use, using the default bucket when returning nil" do
-      @fs.build('conditional/default.js').should be_instance_of(AssetCloud::Asset)
-      @fs.build('conditional/better.liquid').should be_instance_of(LiquidAsset)
+      expect(@fs.build('conditional/default.js')).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs.build('conditional/better.liquid')).to(be_instance_of(LiquidAsset))
     end
 
     it "should raise " do
-      expect { BasicCloud.bucket(AssetCloud::MemoryBucket, asset_class: Proc.new {}) }.to(raise_error(ArgumentError))
+      expect { BasicCloud.bucket(AssetCloud::MemoryBucket, asset_class: proc {}) }.to(raise_error(ArgumentError))
     end
   end
 
   describe "MATCH_BUCKET" do
     it "should match following stuff " do
-
       'products/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
 
       'products/subpath/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
 
       'key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == nil
+      expect(Regexp.last_match(1)).to(eq(nil))
 
       'products' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
     end
   end
 end

data/spec/blackhole_bucket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class BlackholeCloud < AssetCloud::Base
@@ -8,7 +9,7 @@ describe BlackholeCloud do
   directory = File.dirname(__FILE__) + '/files'
 
   before do
-    @fs = BlackholeCloud.new(directory , 'http://assets/files' )
+    @fs = BlackholeCloud.new(directory, 'http://assets/files')
   end
 
   it "should allow access to files using the [] operator" do
@@ -16,12 +17,12 @@ describe BlackholeCloud do
   end
 
   it "should return nil for non existent files" do
-    @fs['tmp/image.jpg'].exist?.should == false
+    expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
   end
 
   it "should still return nil, even if you wrote something there" do
     @fs['tmp/image.jpg'] = 'test'
-    @fs['tmp/image.jpg'].exist?.should == false
+    expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
   end
 
   describe "when using a sub path" do
@@ -30,12 +31,12 @@ describe BlackholeCloud do
     end
 
     it "should return nil for non existent files" do
-      @fs['tmp/image.jpg'].exist?.should == false
+      expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
     end
 
     it "should still return nil, even if you wrote something there" do
       @fs['tmp/image.jpg'] = 'test'
-      @fs['tmp/image.jpg'].exist?.should == false
+      expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
     end
   end
 end

data/spec/bucket_chain_spec.rb

@@ -1,58 +1,59 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class ChainedCloud < AssetCloud::Base
-  bucket :stuff, AssetCloud::BucketChain.chain( AssetCloud::MemoryBucket,
+  bucket :stuff, AssetCloud::BucketChain.chain(AssetCloud::MemoryBucket,
                                                 AssetCloud::MemoryBucket,
-                                                AssetCloud::FileSystemBucket )
+                                                AssetCloud::FileSystemBucket)
 
-  bucket :versioned_stuff, AssetCloud::BucketChain.chain( AssetCloud::FileSystemBucket,
+  bucket :versioned_stuff, AssetCloud::BucketChain.chain(AssetCloud::FileSystemBucket,
                                                           AssetCloud::VersionedMemoryBucket,
-                                                          AssetCloud::MemoryBucket )
+                                                          AssetCloud::MemoryBucket)
 end
 
 describe AssetCloud::BucketChain do
   directory = File.dirname(__FILE__) + '/files'
 
   before(:each) do
-    @cloud = ChainedCloud.new(directory , 'http://assets/files' )
+    @cloud = ChainedCloud.new(directory, 'http://assets/files')
     @bucket_chain = @cloud.buckets[:stuff]
     @chained_buckets = @bucket_chain.chained_buckets
-    @chained_buckets.each {|b| b.ls('stuff').each {|asset| asset.delete}}
+    @chained_buckets.each { |b| b.ls('stuff').each(&:delete) }
 
     @versioned_stuff = @cloud.buckets[:versioned_stuff]
   end
 
   describe ".chain" do
     it 'should take multiple Bucket classes and return a new Bucket class' do
-      @bucket_chain.should be_a_kind_of(AssetCloud::BucketChain)
+      expect(@bucket_chain).to(be_a_kind_of(AssetCloud::BucketChain))
     end
   end
 
   describe "#write" do
     it 'should write to each sub-bucket when everything is kosher and return the result of the first write' do
       @chained_buckets.each do |bucket|
-        bucket.should_receive(:write).with('stuff/foo', 'successful creation').and_return('successful creation')
+        expect(bucket).to(receive(:write).with('stuff/foo', 'successful creation').and_return('successful creation'))
       end
 
-      @bucket_chain.write('stuff/foo', 'successful creation').should == 'successful creation'
+      expect(@bucket_chain.write('stuff/foo', 'successful creation')).to(eq('successful creation'))
     end
     it 'should roll back creation-writes and re-raise an error when a bucket raises one' do
-      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_raise('hell')
+      expect(@chained_buckets.last).to(receive(:write).with('stuff/foo', 'unsuccessful creation').and_raise('hell'))
       @chained_buckets[0..-2].each do |bucket|
-        bucket.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_return(true)
-        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+        expect(bucket).to(receive(:write).with('stuff/foo', 'unsuccessful creation').and_return(true))
+        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
       end
 
-      lambda { @bucket_chain.write('stuff/foo', 'unsuccessful creation') }.should raise_error(RuntimeError)
+      expect { @bucket_chain.write('stuff/foo', 'unsuccessful creation') }.to(raise_error(RuntimeError))
     end
     it 'should roll back update-writes and re-raise an error when a bucket raises one' do
       @bucket_chain.write('stuff/foo', "original value")
 
-      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'new value').and_raise('hell')
+      expect(@chained_buckets.last).to(receive(:write).with('stuff/foo', 'new value').and_raise('hell'))
 
-      lambda { @bucket_chain.write('stuff/foo', 'new value') }.should raise_error(RuntimeError)
+      expect { @bucket_chain.write('stuff/foo', 'new value') }.to(raise_error(RuntimeError))
       @chained_buckets.each do |bucket|
-        bucket.read('stuff/foo').should == 'original value'
+        expect(bucket.read('stuff/foo')).to(eq('original value'))
       end
     end
   end
@@ -62,7 +63,7 @@ describe AssetCloud::BucketChain do
       @bucket_chain.write('stuff/foo', "successful deletion comin' up")
 
       @chained_buckets.each do |bucket|
-        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
       end
 
       @bucket_chain.delete('stuff/foo')
@@ -70,47 +71,46 @@ describe AssetCloud::BucketChain do
     it 'should roll back deletions and re-raise an error when a bucket raises one' do
       @bucket_chain.write('stuff/foo', "this deletion will fail")
 
-      @chained_buckets.last.should_receive(:delete).with('stuff/foo').and_raise('hell')
+      expect(@chained_buckets.last).to(receive(:delete).with('stuff/foo').and_raise('hell'))
       @chained_buckets[0..-2].each do |bucket|
-        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
-        bucket.should_receive(:write).with('stuff/foo', 'this deletion will fail').and_return(true)
+        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
+        expect(bucket).to(receive(:write).with('stuff/foo', 'this deletion will fail').and_return(true))
       end
 
-      lambda { @bucket_chain.delete('stuff/foo') }.should raise_error(RuntimeError)
+      expect { @bucket_chain.delete('stuff/foo') }.to(raise_error(RuntimeError))
     end
   end
 
   describe "#read" do
     it 'should read from only the first available sub-bucket' do
-      @chained_buckets[0].should_receive(:read).with('stuff/foo').and_raise(NotImplementedError)
-      @chained_buckets[0].should_receive(:ls).with(nil).and_raise(NoMethodError)
-      @chained_buckets[0].should_receive(:stat).and_return(:metadata)
+      expect(@chained_buckets[0]).to(receive(:read).with('stuff/foo').and_raise(NotImplementedError))
+      expect(@chained_buckets[0]).to(receive(:ls).with(nil).and_raise(NoMethodError))
+      expect(@chained_buckets[0]).to(receive(:stat).and_return(:metadata))
 
-      @chained_buckets[1].should_receive(:read).with('stuff/foo').and_return('bar')
-      @chained_buckets[1].should_receive(:ls).with(nil).and_return(:some_assets)
-      @chained_buckets[1].should_not_receive(:stat)
+      expect(@chained_buckets[1]).to(receive(:read).with('stuff/foo').and_return('bar'))
+      expect(@chained_buckets[1]).to(receive(:ls).with(nil).and_return(:some_assets))
+      expect(@chained_buckets[1]).not_to(receive(:stat))
 
       @chained_buckets[2..-1].each do |bucket|
-        bucket.should_not_receive(:read)
-        bucket.should_not_receive(:ls)
-        bucket.should_not_receive(:stat)
+        expect(bucket).not_to(receive(:read))
+        expect(bucket).not_to(receive(:ls))
+        expect(bucket).not_to(receive(:stat))
       end
 
-      @bucket_chain.read('stuff/foo').should == 'bar'
-      @bucket_chain.ls.should == :some_assets
-      @bucket_chain.stat.should == :metadata
+      expect(@bucket_chain.read('stuff/foo')).to(eq('bar'))
+      expect(@bucket_chain.ls).to(eq(:some_assets))
+      expect(@bucket_chain.stat).to(eq(:metadata))
     end
   end
 
-
   describe "#read_version" do
     it 'should read from only the first available sub-bucket' do
       buckets = @versioned_stuff.chained_buckets
 
-      buckets[1].should_receive(:read_version).with('stuff/foo',3).and_return('bar')
-      buckets.last.should_not_receive(:read_version)
+      expect(buckets[1]).to(receive(:read_version).with('stuff/foo', 3).and_return('bar'))
+      expect(buckets.last).not_to(receive(:read_version))
 
-      @versioned_stuff.read_version('stuff/foo', 3).should == 'bar'
+      expect(@versioned_stuff.read_version('stuff/foo', 3)).to(eq('bar'))
     end
   end
 
@@ -118,10 +118,10 @@ describe AssetCloud::BucketChain do
     it 'should read from only the first available sub-bucket' do
       buckets = @versioned_stuff.chained_buckets
 
-      buckets[1].should_receive(:versions).with('versioned_stuff/foo').and_return([1,2,3])
-      buckets.last.should_not_receive(:versions)
+      expect(buckets[1]).to(receive(:versions).with('versioned_stuff/foo').and_return([1, 2, 3]))
+      expect(buckets.last).not_to(receive(:versions))
 
-      @versioned_stuff.versions('versioned_stuff/foo').should == [1,2,3]
+      expect(@versioned_stuff.versions('versioned_stuff/foo')).to(eq([1, 2, 3]))
     end
   end
 
@@ -131,28 +131,28 @@ describe AssetCloud::BucketChain do
         @cloud['versioned_stuff/foo'] = content
       end
       asset = @cloud['versioned_stuff/foo']
-      asset.value.should == 'three'
-      asset.rollback(1).value.should == 'one'
-      asset.versions.should == [1,2,3]
+      expect(asset.value).to(eq('three'))
+      expect(asset.rollback(1).value).to(eq('one'))
+      expect(asset.versions).to(eq([1, 2, 3]))
       asset.value = 'four'
       asset.store
-      asset.versions.should == [1,2,3,4]
+      expect(asset.versions).to(eq([1, 2, 3, 4]))
     end
   end
 
   describe '#respond_to?' do
     it 'should return true if any chained buckets respond to the given method' do
-      @bucket_chain.respond_to?(:foo).should == false
-      @chained_buckets[1].should_receive(:respond_to?).with(:bar).and_return(true)
-      @bucket_chain.respond_to?(:bar).should == true
+      expect(@bucket_chain.respond_to?(:foo)).to(eq(false))
+      expect(@chained_buckets[1]).to(receive(:respond_to?).with(:bar).and_return(true))
+      expect(@bucket_chain.respond_to?(:bar)).to(eq(true))
     end
   end
 
   describe '#method_missing' do
     it 'should try each bucket' do
-      @chained_buckets[1].should_receive(:buzz).and_return(true)
-      @chained_buckets[2].should_not_receive(:buzz)
-      @bucket_chain.buzz.should == true
+      expect(@chained_buckets[1]).to(receive(:buzz).and_return(true))
+      expect(@chained_buckets[2]).not_to(receive(:buzz))
+      expect(@bucket_chain.buzz).to(eq(true))
     end
   end
 end