asset_cloud 2.5.3 → 2.6.0

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,27 +25,27 @@ 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(
+    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
       local_path,
       "s#{@cloud.url}/#{key}",
       {}
-    )
+    ))
 
     @bucket.write(key, local_path)
   end
@@ -53,13 +54,13 @@ describe AssetCloud::GCSBucket 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 +69,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 +82,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 +125,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

data/spec/memory_bucket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class MemoryCloud < AssetCloud::Base
@@ -8,41 +9,39 @@ describe AssetCloud::MemoryBucket do
   directory = File.dirname(__FILE__) + '/files'
 
   before do
-    @fs = MemoryCloud.new(directory , 'http://assets/files' )
+    @fs = MemoryCloud.new(directory, 'http://assets/files')
   end
 
   describe 'modifying items in subfolder' do
-
     it "should return nil when file does not exist" do
-      @fs['memory/essay.txt'].exist?.should == false
+      expect(@fs['memory/essay.txt'].exist?).to(eq(false))
     end
 
     it "should return set content when asked for the same file" do
       @fs['memory/essay.txt'] = 'text'
-      @fs['memory/essay.txt'].value.should == 'text'
+      expect(@fs['memory/essay.txt'].value).to(eq('text'))
     end
-
   end
 
   describe "#versioned?" do
     it "should return false" do
-      @fs.buckets[:memory].versioned?.should == false
+      expect(@fs.buckets[:memory].versioned?).to(eq(false))
     end
   end
 
   describe '#ls' do
     before do
       %w{a b}.each do |letter|
-        2.times {|number| @fs.write("memory/#{letter}#{number}",'.')}
+        2.times { |number| @fs.write("memory/#{letter}#{number}", '.') }
       end
     end
 
     it "should return a list of assets which start with the given prefix" do
-      @fs.buckets[:memory].ls('memory/a').size.should == 2
+      expect(@fs.buckets[:memory].ls('memory/a').size).to(eq(2))
     end
 
     it "should return a list of all assets when a prefix is not given" do
-      @fs.buckets[:memory].ls.size.should == 4
+      expect(@fs.buckets[:memory].ls.size).to(eq(4))
     end
   end
 end

data/spec/mock_s3_interface.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'ostruct'
 
 class MockS3Interface
@@ -7,7 +8,7 @@ class MockS3Interface
 
   attr_reader :bucket_storage
 
-  def initialize(aws_access_key_id = nil, aws_secret_access_key = nil, params = {})
+  def initialize(_aws_access_key_id = nil, _aws_secret_access_key = nil, _params = {})
     @buckets = {}
   end
 
@@ -32,7 +33,7 @@ class MockS3Interface
 
     {
       content_length: options.body.size,
-      last_modified: Time.parse("Mon Aug 27 17:37:51 UTC 2007")
+      last_modified: Time.parse("Mon Aug 27 17:37:51 UTC 2007"),
     }
   end
 
@@ -60,7 +61,7 @@ class MockS3Interface
       if options[:acl] && !VALID_ACLS.include?(options[:acl])
         raise "Invalid ACL `#{options[:acl].inspect}`, must be one of: #{VALID_ACLS.inspect}"
       end
-      
+
       options[:body] = options[:body].force_encoding(Encoding::BINARY)
 
       key = options.delete(:key)

data/spec/remote_s3_bucket_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class RemoteS3Cloud < AssetCloud::Base
   attr_accessor :s3_connection
   bucket :tmp, AssetCloud::S3Bucket
 
-  def s3_bucket(key)
+  def s3_bucket(_key)
     s3_connection.bucket(ENV['S3_BUCKET_NAME'])
   end
 end
@@ -21,14 +22,14 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
       ),
     }
 
-    @cloud = RemoteS3Cloud.new(directory , 'testing/assets/files' )
+    @cloud = RemoteS3Cloud.new(directory, 'testing/assets/files')
     @cloud.s3_connection = Aws::S3::Resource.new
     @bucket = @cloud.buckets[:tmp]
   end
 
   after(:all) do
     listing = @bucket.ls('tmp')
-    listing.each { |object| object.delete }
+    listing.each(&:delete)
   end
 
   it "#ls should return assets with proper keys" do
@@ -37,8 +38,8 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
 
     ls = @bucket.ls('tmp')
 
-    expect(ls).to all(be_an(AssetCloud::Asset))
-    expect(ls.map(&:key) - ['tmp/test1.txt', 'tmp/test2.txt']).to be_empty
+    expect(ls).to(all(be_an(AssetCloud::Asset)))
+    expect(ls.map(&:key) - ['tmp/test1.txt', 'tmp/test2.txt']).to(be_empty)
   end
 
   it "#ls returns all assets" do
@@ -47,8 +48,8 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
 
     ls = @bucket.ls
 
-    expect(ls).to all(be_an(AssetCloud::Asset))
-    expect(ls.map(&:key) - ['tmp/test1.txt', 'tmp/test2.txt']).to be_empty
+    expect(ls).to(all(be_an(AssetCloud::Asset)))
+    expect(ls.map(&:key) - ['tmp/test1.txt', 'tmp/test2.txt']).to(be_empty)
   end
 
   it "#delete should ignore errors when deleting" do
@@ -58,7 +59,7 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
   it "#delete should always return true" do
     @cloud['tmp/test1.txt'] = 'test1'
 
-    @bucket.delete('tmp/test1.txt').should == true
+    expect(@bucket.delete('tmp/test1.txt')).to(eq(true))
   end
 
   it "#stat should get metadata from S3" do
@@ -66,14 +67,14 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
     value = 'hello world'
     @cloud.build('tmp/new_file.test', value).store
     metadata = @bucket.stat('tmp/new_file.test')
-    metadata.size.should == value.size
-    metadata.updated_at.should >= start_time
+    expect(metadata.size).to(eq(value.size))
+    expect(metadata.updated_at).to(be >= start_time)
   end
 
   it "#stat a missing asset" do
     metadata = @bucket.stat('i_do_not_exist_and_never_will.test')
-    expect(metadata).to be_an(AssetCloud::Metadata)
-    expect(metadata.exist).to be false
+    expect(metadata).to(be_an(AssetCloud::Metadata))
+    expect(metadata.exist).to(be(false))
   end
 
   it "#read " do
@@ -81,19 +82,19 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
     key = 'tmp/new_file.txt'
     @bucket.write(key, value)
     data = @bucket.read(key)
-    data.should == value
+    expect(data).to(eq(value))
   end
 
   it "#read a missing asset" do
-    expect { @bucket.read("i_do_not_exist_and_never_will.test") }.to raise_error(AssetCloud::AssetNotFoundError)
+    expect { @bucket.read("i_do_not_exist_and_never_will.test") }.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#reads first bytes when passed options" do
     value = 'hello world'
     key = 'tmp/new_file.txt'
-    options = {range: 0...5}
+    options = { range: 0...5 }
     @bucket.write(key, value)
     data = @bucket.read(key, options)
-    data.should == 'hello'
+    expect(data).to(eq('hello'))
   end
 end