asset_cloud 2.5.3 → 2.6.0

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

data/spec/bucket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe AssetCloud::Bucket do
@@ -7,19 +8,19 @@ describe AssetCloud::Bucket do
 
   describe "operations not supported" do
     it "#ls not supported" do
-      expect { @bucket.ls('foo')}.to raise_error NotImplementedError
+      expect { @bucket.ls('foo') }.to(raise_error(NotImplementedError))
     end
 
     it "#read(key) not supported" do
-      expect { @bucket.read('foo')}.to raise_error NotImplementedError
+      expect { @bucket.read('foo') }.to(raise_error(NotImplementedError))
     end
 
     it "#write(key, data) not supported" do
-      expect { @bucket.write('foo', 'bar')}.to raise_error NotImplementedError
+      expect { @bucket.write('foo', 'bar') }.to(raise_error(NotImplementedError))
     end
 
     it "#delete(key) not supported" do
-      expect { @bucket.delete('foo')}.to raise_error NotImplementedError
+      expect { @bucket.delete('foo') }.to(raise_error(NotImplementedError))
     end
   end
 end

data/spec/callbacks_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class CallbackAsset < AssetCloud::Asset
@@ -21,12 +22,12 @@ class CallbackAsset < AssetCloud::Asset
   end
 
   def valid_value
-    add_error 'value is not "valid"' unless value == 'valid'
+    add_error('value is not "valid"') unless value == 'valid'
   end
 end
 
 class BasicCloud < AssetCloud::Base
-  bucket :callback_assets, AssetCloud::MemoryBucket, :asset_class => CallbackAsset
+  bucket :callback_assets, AssetCloud::MemoryBucket, asset_class: CallbackAsset
 end
 
 class CallbackCloud < AssetCloud::Base
@@ -39,6 +40,7 @@ class CallbackCloud < AssetCloud::Base
   before_write :callback_before_write
 
   def callback_before_write(*args); end
+
   def callback_after_write(*args); end
 end
 
@@ -50,7 +52,7 @@ class MethodRecordingCloud < AssetCloud::Base
   before_write :callback_before_write
   after_write :callback_before_write
 
-  def method_missing(method, *args)
+  def method_missing(method, *_args)
     @run_callbacks << method.to_sym
   end
 end
@@ -62,38 +64,36 @@ describe CallbackCloud do
   end
 
   it "should invoke callbacks after store" do
-    @fs.should_receive(:callback_before_write).with('tmp/file.txt', 'text').and_return(true)
-    @fs.should_receive(:callback_after_write).with('tmp/file.txt', 'text').and_return(true)
-
+    expect(@fs).to(receive(:callback_before_write).with('tmp/file.txt', 'text').and_return(true))
+    expect(@fs).to(receive(:callback_after_write).with('tmp/file.txt', 'text').and_return(true))
 
-    @fs.write('tmp/file.txt', 'text').should == true
-    @fs.read('tmp/file.txt').should == 'text'
+    expect(@fs.write('tmp/file.txt', 'text')).to(eq(true))
+    expect(@fs.read('tmp/file.txt')).to(eq('text'))
   end
 
   it "should invoke callbacks after delete" do
-    @fs.should_receive(:callback_before_delete).with('tmp/file.txt').and_return(true)
-    @fs.should_receive(:callback_after_delete).with('tmp/file.txt').and_return(true)
+    expect(@fs).to(receive(:callback_before_delete).with('tmp/file.txt').and_return(true))
+    expect(@fs).to(receive(:callback_after_delete).with('tmp/file.txt').and_return(true))
 
-    @fs.delete('tmp/file.txt').should == 'foo'
+    expect(@fs.delete('tmp/file.txt')).to(eq('foo'))
   end
 
   it "should not invoke other callbacks when a before_ filter returns false" do
-    @fs.should_receive(:callback_before_delete)
+    expect(@fs).to(receive(:callback_before_delete)
       .with('tmp/file.txt')
-      .and_return(false)
-    @fs.should_not_receive(:callback_after_delete)
+      .and_return(false))
+    expect(@fs).not_to(receive(:callback_after_delete))
 
-    @fs.delete('tmp/file.txt').should == nil
+    expect(@fs.delete('tmp/file.txt')).to(eq(nil))
   end
 
   it "should invoke callbacks even when constructing a new asset" do
-    @fs.should_receive(:callback_before_write).with('tmp/file.txt', 'hello').and_return(true)
-    @fs.should_receive(:callback_after_write).with('tmp/file.txt', 'hello').and_return(true)
-
+    expect(@fs).to(receive(:callback_before_write).with('tmp/file.txt', 'hello').and_return(true))
+    expect(@fs).to(receive(:callback_after_write).with('tmp/file.txt', 'hello').and_return(true))
 
     asset = @fs.build('tmp/file.txt')
     asset.value = 'hello'
-    asset.store.should == true
+    expect(asset.store).to(eq(true))
   end
 end
 
@@ -105,12 +105,12 @@ describe MethodRecordingCloud do
 
   it 'should record event when invoked' do
     @fs.write('tmp/file.txt', 'random data')
-    @fs.run_callbacks.should == [:callback_before_write, :callback_before_write]
+    expect(@fs.run_callbacks).to(eq([:callback_before_write, :callback_before_write]))
   end
 
   it 'should record event when assignment operator is used' do
     @fs['tmp/file.txt'] = 'random data'
-    @fs.run_callbacks.should == [:callback_before_write, :callback_before_write]
+    expect(@fs.run_callbacks).to(eq([:callback_before_write, :callback_before_write]))
   end
 end
 
@@ -122,25 +122,25 @@ describe CallbackAsset do
   end
 
   it "should run before_validate, then validate, then after validate, then before_store, then store" do
-    @asset.should_receive(:callback_before_store).and_return(true)
-    @asset.should_not_receive(:callback_after_delete)
+    expect(@asset).to(receive(:callback_before_store).and_return(true))
+    expect(@asset).not_to(receive(:callback_after_delete))
 
     @asset.value = 'foo'
-    @asset.store.should == true
-    @asset.value.should == 'valid spice'
+    expect(@asset.store).to(eq(true))
+    expect(@asset.value).to(eq('valid spice'))
   end
 
   it "should run its after_delete callback after delete is called" do
-    @asset.should_not_receive(:callback_before_store)
-    @asset.should_receive(:callback_after_delete).and_return(true)
+    expect(@asset).not_to(receive(:callback_before_store))
+    expect(@asset).to(receive(:callback_after_delete).and_return(true))
 
-    @asset.delete.should == 'bar'
+    expect(@asset.delete).to(eq('bar'))
   end
 
   it "not invoke other callbacks when a before_ filter returns false" do
-    @asset.should_receive(:callback_before_delete).and_return(false)
-    @asset.should_not_receive(:callback_after_delete)
+    expect(@asset).to(receive(:callback_before_delete).and_return(false))
+    expect(@asset).not_to(receive(:callback_after_delete))
 
-    @asset.delete.should == nil
+    expect(@asset.delete).to(eq(nil))
   end
 end

data/spec/file_system_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'fileutils'
 
@@ -7,12 +8,11 @@ class FileSystemCloud < AssetCloud::Base
   bucket :tmp,      AssetCloud::FileSystemBucket
 end
 
-
 describe FileSystemCloud do
   directory = File.dirname(__FILE__) + '/files'
 
   before do
-    @fs = FileSystemCloud.new(directory , 'http://assets/files' )
+    @fs = FileSystemCloud.new(directory, 'http://assets/files')
     FileUtils.mkdir_p(directory + '/tmp')
   end
 
@@ -21,31 +21,31 @@ describe FileSystemCloud do
   end
 
   it "should use invalid bucket for random directories" do
-    @fs.bucket_for('does-not-exist/file.txt').should be_an_instance_of(AssetCloud::InvalidBucket)
+    expect(@fs.bucket_for('does-not-exist/file.txt')).to(be_an_instance_of(AssetCloud::InvalidBucket))
   end
 
   it "should use filesystem bucket for products/ and tmp/  directories" do
-    @fs.bucket_for('products/file.txt').should be_an_instance_of(AssetCloud::FileSystemBucket)
-    @fs.bucket_for('tmp/file.txt').should be_an_instance_of(AssetCloud::FileSystemBucket)
+    expect(@fs.bucket_for('products/file.txt')).to(be_an_instance_of(AssetCloud::FileSystemBucket))
+    expect(@fs.bucket_for('tmp/file.txt')).to(be_an_instance_of(AssetCloud::FileSystemBucket))
   end
 
   it "should return Asset for existing files" do
-    @fs['products/key.txt'].exist?.should == true
-    @fs['products/key.txt'].should be_an_instance_of(AssetCloud::Asset)
+    expect(@fs['products/key.txt'].exist?).to(eq(true))
+    expect(@fs['products/key.txt']).to(be_an_instance_of(AssetCloud::Asset))
   end
 
   it "should be able to test if a file exists or not" do
-    @fs.stat('products/key.txt').exist?.should == true
-    @fs.stat('products/key2.txt').exist?.should == false
+    expect(@fs.stat('products/key.txt').exist?).to(eq(true))
+    expect(@fs.stat('products/key2.txt').exist?).to(eq(false))
   end
 
   it "should be able to list files" do
-    @fs.ls('products').collect(&:key).should == ['products/key.txt']
+    expect(@fs.ls('products').collect(&:key)).to(eq(['products/key.txt']))
   end
 
   describe 'when modifying file system' do
     it "should call write after storing an asset" do
-      @fs.buckets[:tmp].should_receive(:write).with('tmp/new_file.test', 'hello world').and_return(true)
+      expect(@fs.buckets[:tmp]).to(receive(:write).with('tmp/new_file.test', 'hello world').and_return(true))
 
       @fs.build('tmp/new_file.test', 'hello world').store
     end
@@ -53,21 +53,20 @@ describe FileSystemCloud do
     it "should be able to create new files" do
       @fs.build('tmp/new_file.test', 'hello world').store
 
-      @fs.stat('tmp/new_file.test').exist.should == true
+      expect(@fs.stat('tmp/new_file.test').exist).to(eq(true))
     end
 
     it "should be able to create new files with simple assignment" do
       @fs['tmp/new_file.test'] = 'hello world'
 
-      @fs.stat('tmp/new_file.test').exist.should == true
+      expect(@fs.stat('tmp/new_file.test').exist).to(eq(true))
     end
 
     it "should create directories as needed" do
       @fs.build('tmp/new_file.test', 'hello world').store
 
-      @fs['tmp/new_file.test'].exist?.should == true
-      @fs['tmp/new_file.test'].value.should == 'hello world'
+      expect(@fs['tmp/new_file.test'].exist?).to(eq(true))
+      expect(@fs['tmp/new_file.test'].value).to(eq('hello world'))
     end
-
   end
 end