asset_cloud 2.5.1 → 2.7.0

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

data/spec/find_free_key_spec.rb

@@ -1,46 +1,44 @@
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-
 class FindFreeKey
   extend AssetCloud::FreeKeyLocator
 end
 
 describe "FreeFilenameLocator", 'when asked to return a free key such as the one passed in' do
-
   it "should simply return the key if it happens to be free" do
-    FindFreeKey.should_receive(:exist?).with('free.txt').and_return(false)
+    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(false))
 
-    FindFreeKey.find_free_key_like('free.txt').should == 'free.txt'
+    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('free.txt'))
   end
 
   it "should append a UUID to the key before the extension if key is taken" do
-    SecureRandom.stub(:uuid).and_return('moo')
-    FindFreeKey.should_receive(:exist?).with('free.txt').and_return(true)
-    FindFreeKey.should_receive(:exist?).with('free_moo.txt').and_return(false)
+    allow(SecureRandom).to(receive(:uuid).and_return('moo'))
+    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(true))
+    expect(FindFreeKey).to(receive(:exist?).with('free_moo.txt').and_return(false))
 
-    FindFreeKey.find_free_key_like('free.txt').should == 'free_moo.txt'
+    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('free_moo.txt'))
   end
 
-
   it "should not strip any directory information from the key" do
-    SecureRandom.stub(:uuid).and_return('moo')
-    FindFreeKey.should_receive(:exist?).with('products/images/image.gif').and_return(true)
-    FindFreeKey.should_receive(:exist?).with('products/images/image_moo.gif').and_return(false)
+    allow(SecureRandom).to(receive(:uuid).and_return('moo'))
+    expect(FindFreeKey).to(receive(:exist?).with('products/images/image.gif').and_return(true))
+    expect(FindFreeKey).to(receive(:exist?).with('products/images/image_moo.gif').and_return(false))
 
-    FindFreeKey.find_free_key_like('products/images/image.gif').should == 'products/images/image_moo.gif'
+    expect(FindFreeKey.find_free_key_like('products/images/image.gif')).to(eq('products/images/image_moo.gif'))
   end
 
   it "should raise an exception if the randomly chosen value (after 10 attempts) is also taken" do
-    FindFreeKey.stub(:exist?).and_return(true)
-    lambda { FindFreeKey.find_free_key_like('free.txt') }.should raise_error(StandardError)
+    allow(FindFreeKey).to(receive(:exist?).and_return(true))
+    expect { FindFreeKey.find_free_key_like('free.txt') }.to(raise_error(StandardError))
   end
 
   it "should append a UUID to the key before the extensions if the force_uuid option is passed" do
-    FindFreeKey.should_receive(:exist?).with('free.txt').and_return(false)
-    FindFreeKey.should_receive(:exist?).with('free_as-in-beer.txt').and_return(false)
-    SecureRandom.stub(:uuid).and_return('as-in-beer')
+    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(false))
+    expect(FindFreeKey).to(receive(:exist?).with('free_as-in-beer.txt').and_return(false))
+    allow(SecureRandom).to(receive(:uuid).and_return('as-in-beer'))
 
-    FindFreeKey.find_free_key_like('free.txt', :force_uuid => true).should == 'free_as-in-beer.txt'
+    expect(FindFreeKey.find_free_key_like('free.txt', force_uuid: true)).to(eq('free_as-in-beer.txt'))
   end
 end

data/spec/gcs_bucket_remote_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:disable RSpec/FilePath, Lint/MissingCopEnableDirective
 
 require 'spec_helper'
 require 'google/cloud/storage'
@@ -20,9 +19,9 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     @cloud = RemoteGCSCloud.new(directory, 'assets/files')
 
     @cloud.gcs_connection = Google::Cloud::Storage.new(
-        project_id: ENV['GCS_PROJECT_ID'],
-        credentials: ENV['GCS_KEY_FILEPATH']
-      )
+      project_id: ENV['GCS_PROJECT_ID'],
+      credentials: ENV['GCS_KEY_FILEPATH']
+    )
     @bucket = @cloud.buckets[:tmp]
   end
 
@@ -31,10 +30,10 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
   end
 
   it "#ls with no arguments returns all files in the bucket" do
-    expect_any_instance_of(Google::Cloud::Storage::Bucket).to receive(:files).with(no_args)
+    expect_any_instance_of(Google::Cloud::Storage::Bucket).to(receive(:files).with(no_args))
     expect do
       @bucket.ls
-    end.not_to raise_error
+    end.not_to(raise_error)
   end
 
   it "#ls with arguments returns the file" do
@@ -44,7 +43,7 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     @bucket.write(key, local_path)
 
     file = @bucket.ls(key)
-    expect(file.name).to eq("s#{@cloud.url}/#{key}")
+    expect(file.name).to(eq("s#{@cloud.url}/#{key}"))
   end
 
   it "#write writes a file into the bucket" do
@@ -58,11 +57,11 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     local_path = "#{directory}/products/key.txt"
     key = 'test/key.txt'
     metadata = {
-      "X-Robots-Tag" => "none"
+      "X-Robots-Tag" => "none",
     }
 
     file = @bucket.write(key, local_path, metadata: metadata)
-    expect(file.metadata).to eq(metadata)
+    expect(file.metadata).to(eq(metadata))
   end
 
   it "#write writes a file into the bucket with acl" do
@@ -71,7 +70,7 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     acl = 'public'
 
     file = @bucket.write(key, local_path, acl: acl)
-    expect(file.acl).to be_truthy
+    expect(file.acl).to(be_truthy)
   end
 
   it "#write writes a file into the bucket with content_disposition" do
@@ -80,7 +79,7 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     content_disposition = 'attachment'
 
     file = @bucket.write(key, local_path, content_disposition: content_disposition)
-    expect(file.content_disposition).to eq(content_disposition)
+    expect(file.content_disposition).to(eq(content_disposition))
   end
 
   it "#delete removes the file from the bucket" do
@@ -88,14 +87,14 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
     expect do
       @bucket.delete(key)
-    end.not_to raise_error
+    end.not_to(raise_error)
   end
 
   it "#delete raises AssetCloud::AssetNotFoundError if the file is not found" do
     key = 'tmp/not_found.txt'
     expect do
       @bucket.delete(key)
-    end.to raise_error(AssetCloud::AssetNotFoundError)
+    end.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#read returns the data of the file" do
@@ -104,14 +103,14 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
     @bucket.write(key, StringIO.new(value))
 
     data = @bucket.read(key)
-    data.should == value
+    expect(data).to(eq(value))
   end
 
   it "#read raises AssetCloud::AssetNotFoundError if the file is not found" do
     key = 'tmp/not_found.txt'
     expect do
       @bucket.read(key)
-    end.to raise_error(AssetCloud::AssetNotFoundError)
+    end.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#stats returns metadata of the asset" do
@@ -121,8 +120,8 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
     stats = @bucket.stat(key)
 
-    expect(stats.size).not_to be_nil
-    expect(stats.created_at).not_to be_nil
-    expect(stats.updated_at).not_to be_nil
+    expect(stats.size).not_to(be_nil)
+    expect(stats.created_at).not_to(be_nil)
+    expect(stats.updated_at).not_to(be_nil)
   end
-end
+end

data/spec/gcs_bucket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'google/cloud/storage'
 
@@ -24,42 +25,55 @@ describe AssetCloud::GCSBucket do
   end
 
   it "#ls with no arguments returns all files in the bucket" do
-    expect_any_instance_of(GCSCloud).to receive(:gcs_bucket).and_return(@bucket)
-    expect_any_instance_of(MockGCSBucket).to receive(:files).with(no_args).and_return(nil)
+    expect_any_instance_of(GCSCloud).to(receive(:gcs_bucket).and_return(@bucket))
+    expect_any_instance_of(MockGCSBucket).to(receive(:files).with(no_args).and_return(nil))
     @bucket.ls
   end
 
   it "#ls with arguments returns the file" do
     key = 'test/ls.txt'
-    expect_any_instance_of(MockGCSBucket).to receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new)
+    expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new))
 
     file = @bucket.ls(key)
-    expect(file.class).to eq(Google::Cloud::Storage::File)
+    expect(file.class).to(eq(Google::Cloud::Storage::File))
   end
 
-  it "#write writes a file into the bucket" do
-    local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
-    expect_any_instance_of(MockGCSBucket).to receive(:create_file).with(
-      local_path,
-      "s#{@cloud.url}/#{key}",
-      {}
-    )
-
-    @bucket.write(key, local_path)
+  if RUBY_VERSION >= '2.7'
+    it "#write writes a file into the bucket" do
+      local_path = "#{directory}/products/key.txt"
+      key = 'test/key.txt'
+      expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
+        local_path,
+        "s#{@cloud.url}/#{key}",
+      ))
+
+      @bucket.write(key, local_path)
+    end
+  else
+    it "#write writes a file into the bucket" do
+      local_path = "#{directory}/products/key.txt"
+      key = 'test/key.txt'
+      expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
+        local_path,
+        "s#{@cloud.url}/#{key}",
+        {}
+      ))
+
+      @bucket.write(key, local_path)
+    end
   end
 
   it "#write writes a file into the bucket with metadata" do
     local_path = "#{directory}/products/key.txt"
     key = 'test/key.txt'
     metadata = {
-      "X-Robots-Tag" => "none"
+      "X-Robots-Tag" => "none",
     }
-    expect_any_instance_of(MockGCSBucket).to receive(:create_file).with(
+    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
       local_path,
       "s#{@cloud.url}/#{key}",
       metadata: metadata
-    )
+    ))
 
     @bucket.write(key, local_path, metadata: metadata)
   end
@@ -68,11 +82,11 @@ describe AssetCloud::GCSBucket do
     local_path = "#{directory}/products/key.txt"
     key = 'test/key.txt'
     acl = 'public'
-    expect_any_instance_of(MockGCSBucket).to receive(:create_file).with(
+    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
       local_path,
       "s#{@cloud.url}/#{key}",
       acl: acl
-    )
+    ))
 
     @bucket.write(key, local_path, acl: acl)
   end
@@ -81,41 +95,41 @@ describe AssetCloud::GCSBucket do
     local_path = "#{directory}/products/key.txt"
     key = 'test/key.txt'
     content_disposition = 'attachment'
-    expect_any_instance_of(MockGCSBucket).to receive(:create_file).with(
+    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
       local_path,
       "s#{@cloud.url}/#{key}",
       content_disposition: content_disposition
-    )
+    ))
 
     @bucket.write(key, local_path, content_disposition: content_disposition)
   end
 
   it "#delete removes the file from the bucket" do
     key = 'test/key.txt'
-    expect_any_instance_of(MockGCSBucket).to receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new)
-    expect_any_instance_of(Google::Cloud::Storage::File).to receive(:delete).with(no_args)
+    expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new))
+    expect_any_instance_of(Google::Cloud::Storage::File).to(receive(:delete).with(no_args))
 
     expect do
       @bucket.delete(key)
-    end.not_to raise_error
+    end.not_to(raise_error)
   end
 
   it "#read returns the data of the file" do
     value = 'hello world'
     key = 'tmp/new_file.txt'
-    expect_any_instance_of(MockGCSBucket).to receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new)
-    expect_any_instance_of(Google::Cloud::Storage::File).to receive(:download).and_return(StringIO.new(value))
+    expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new))
+    expect_any_instance_of(Google::Cloud::Storage::File).to(receive(:download).and_return(StringIO.new(value)))
 
     data = @bucket.read(key)
-    data.should == value
+    expect(data).to(eq(value))
   end
 
   it "#read raises AssetCloud::AssetNotFoundError if the file is not found" do
     key = 'tmp/not_found.txt'
-    expect_any_instance_of(MockGCSBucket).to receive(:file).with("s#{@cloud.url}/#{key}").and_return(nil)
+    expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(nil))
     expect do
       @bucket.read(key)
-    end.to raise_error(AssetCloud::AssetNotFoundError)
+    end.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#stat returns information on the asset" do
@@ -124,14 +138,14 @@ describe AssetCloud::GCSBucket do
     expected_time = Time.now
     expected_size = 1
 
-    expect_any_instance_of(MockGCSBucket).to receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new)
-    expect_any_instance_of(Google::Cloud::Storage::File).to receive(:size).and_return(expected_size)
-    expect_any_instance_of(Google::Cloud::Storage::File).to receive(:created_at).and_return(expected_time)
-    expect_any_instance_of(Google::Cloud::Storage::File).to receive(:updated_at).and_return(expected_time)
+    expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(Google::Cloud::Storage::File.new))
+    expect_any_instance_of(Google::Cloud::Storage::File).to(receive(:size).and_return(expected_size))
+    expect_any_instance_of(Google::Cloud::Storage::File).to(receive(:created_at).and_return(expected_time))
+    expect_any_instance_of(Google::Cloud::Storage::File).to(receive(:updated_at).and_return(expected_time))
 
     stats = @bucket.stat(key)
-    expect(stats.size).to eq(expected_size)
-    expect(stats.created_at).to eq(expected_time)
-    expect(stats.updated_at).to eq(expected_time)
+    expect(stats.size).to(eq(expected_size))
+    expect(stats.created_at).to(eq(expected_time))
+    expect(stats.updated_at).to(eq(expected_time))
   end
 end