asset_cloud 2.7.1 → 2.7.3

data/spec/gcs_bucket_remote_spec.rb

@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'google/cloud/storage'
+require "spec_helper"
+require "google/cloud/storage"
 
 class RemoteGCSCloud < AssetCloud::Base
   attr_accessor :gcs_connection
+
   bucket :tmp, AssetCloud::GCSBucket
 
   def gcs_bucket
-    gcs_connection.bucket(ENV['GCS_BUCKET'])
+    gcs_connection.bucket(ENV["GCS_BUCKET"])
   end
 end
 
-describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPATH'] && ENV['GCS_BUCKET'] do
-  directory = File.dirname(__FILE__) + '/files'
+describe AssetCloud::GCSBucket, if: ENV["GCS_PROJECT_ID"] && ENV["GCS_KEY_FILEPATH"] && ENV["GCS_BUCKET"] do
+  directory = File.dirname(__FILE__) + "/files"
 
   before(:all) do
-    @cloud = RemoteGCSCloud.new(directory, 'assets/files')
+    @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
@@ -38,7 +39,7 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
   it "#ls with arguments returns the file" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/ls.txt'
+    key = "test/ls.txt"
 
     @bucket.write(key, local_path)
 
@@ -48,14 +49,14 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
   it "#write writes a file into the bucket" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
+    key = "test/key.txt"
 
     @bucket.write(key, local_path)
   end
 
   it "#write writes a file into the bucket with metadata" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
+    key = "test/key.txt"
     metadata = {
       "X-Robots-Tag" => "none",
     }
@@ -66,8 +67,8 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
   it "#write writes a file into the bucket with acl" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
-    acl = 'public'
+    key = "test/key.txt"
+    acl = "public"
 
     file = @bucket.write(key, local_path, acl: acl)
     expect(file.acl).to(be_truthy)
@@ -75,15 +76,15 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
 
   it "#write writes a file into the bucket with content_disposition" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
-    content_disposition = 'attachment'
+    key = "test/key.txt"
+    content_disposition = "attachment"
 
     file = @bucket.write(key, local_path, content_disposition: content_disposition)
     expect(file.content_disposition).to(eq(content_disposition))
   end
 
   it "#delete removes the file from the bucket" do
-    key = 'test/key.txt'
+    key = "test/key.txt"
 
     expect do
       @bucket.delete(key)
@@ -91,15 +92,15 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
   end
 
   it "#delete raises AssetCloud::AssetNotFoundError if the file is not found" do
-    key = 'tmp/not_found.txt'
+    key = "tmp/not_found.txt"
     expect do
       @bucket.delete(key)
     end.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#read returns the data of the file" do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    value = "hello world"
+    key = "tmp/new_file.txt"
     @bucket.write(key, StringIO.new(value))
 
     data = @bucket.read(key)
@@ -107,15 +108,15 @@ describe AssetCloud::GCSBucket, if: ENV['GCS_PROJECT_ID'] && ENV['GCS_KEY_FILEPA
   end
 
   it "#read raises AssetCloud::AssetNotFoundError if the file is not found" do
-    key = 'tmp/not_found.txt'
+    key = "tmp/not_found.txt"
     expect do
       @bucket.read(key)
     end.to(raise_error(AssetCloud::AssetNotFoundError))
   end
 
   it "#stats returns metadata of the asset" do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    value = "hello world"
+    key = "tmp/new_file.txt"
     @bucket.write(key, StringIO.new(value))
 
     stats = @bucket.stat(key)

data/spec/gcs_bucket_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'google/cloud/storage'
+
+require "spec_helper"
+require "google/cloud/storage"
 
 class GCSCloud < AssetCloud::Base
 end
@@ -13,15 +14,20 @@ class MockGCSBucket < AssetCloud::GCSBucket
   end
 
   def create_file(data, key, options = {})
+    created_files << [data, key, options]
+  end
+
+  def created_files
+    @created_files ||= []
   end
 end
 
 describe AssetCloud::GCSBucket do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before(:all) do
-    @cloud = GCSCloud.new(directory, '/assets/files')
-    @bucket = MockGCSBucket.new(@cloud, '')
+    @cloud = GCSCloud.new(directory, "/assets/files")
+    @bucket = MockGCSBucket.new(@cloud, "")
   end
 
   it "#ls with no arguments returns all files in the bucket" do
@@ -31,82 +37,62 @@ describe AssetCloud::GCSBucket do
   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))
+    key = "test/ls.txt"
+    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))
   end
 
-  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
+  it "#write writes a file into the bucket" do
+    local_path = "#{directory}/products/key.txt"
+    key = "test/key.txt"
+
+    @bucket.write(key, local_path)
+
+    expect(@bucket.created_files).to(include([local_path, "s#{@cloud.url}/#{key}", {}]))
   end
 
   it "#write writes a file into the bucket with metadata" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
+    key = "test/key.txt"
     metadata = {
       "X-Robots-Tag" => "none",
     }
-    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)
+
+    expect(@bucket.created_files).to(include([local_path, "s#{@cloud.url}/#{key}", { metadata: metadata }]))
   end
 
   it "#write writes a file into the bucket with acl" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
-    acl = 'public'
-    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
-      local_path,
-      "s#{@cloud.url}/#{key}",
-      acl: acl
-    ))
+    key = "test/key.txt"
+    acl = "public"
 
     @bucket.write(key, local_path, acl: acl)
+    expect(@bucket.created_files).to(include([local_path, "s#{@cloud.url}/#{key}", { acl: acl }]))
   end
 
   it "#write writes a file into the bucket with content_disposition" do
     local_path = "#{directory}/products/key.txt"
-    key = 'test/key.txt'
-    content_disposition = 'attachment'
-    expect_any_instance_of(MockGCSBucket).to(receive(:create_file).with(
-      local_path,
-      "s#{@cloud.url}/#{key}",
-      content_disposition: content_disposition
-    ))
+    key = "test/key.txt"
+    content_disposition = "attachment"
 
     @bucket.write(key, local_path, content_disposition: content_disposition)
+
+    expect(@bucket.created_files).to(include([
+      local_path,
+      "s#{@cloud.url}/#{key}",
+      { 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))
+    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 do
@@ -115,17 +101,19 @@ describe AssetCloud::GCSBucket do
   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)))
+    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)))
 
     data = @bucket.read(key)
     expect(data).to(eq(value))
   end
 
   it "#read raises AssetCloud::AssetNotFoundError if the file is not found" do
-    key = 'tmp/not_found.txt'
+    key = "tmp/not_found.txt"
     expect_any_instance_of(MockGCSBucket).to(receive(:file).with("s#{@cloud.url}/#{key}").and_return(nil))
     expect do
       @bucket.read(key)
@@ -133,12 +121,12 @@ describe AssetCloud::GCSBucket do
   end
 
   it "#stat returns information on the asset" do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    key = "tmp/new_file.txt"
     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(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))

data/spec/memory_bucket_spec.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class MemoryCloud < AssetCloud::Base
   bucket :memory, AssetCloud::MemoryBucket
 end
 
 describe AssetCloud::MemoryBucket do
-  directory = File.dirname(__FILE__) + '/files'
+  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
+  describe "modifying items in subfolder" do
     it "should return nil when file does not exist" do
-      expect(@fs['memory/essay.txt'].exist?).to(eq(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'
-      expect(@fs['memory/essay.txt'].value).to(eq('text'))
+      @fs["memory/essay.txt"] = "text"
+      expect(@fs["memory/essay.txt"].value).to(eq("text"))
     end
   end
 
@@ -29,15 +30,15 @@ describe AssetCloud::MemoryBucket do
     end
   end
 
-  describe '#ls' do
+  describe "#ls" do
     before do
-      %w{a b}.each do |letter|
-        2.times { |number| @fs.write("memory/#{letter}#{number}", '.') }
+      ["a", "b"].each do |letter|
+        2.times { |number| @fs.write("memory/#{letter}#{number}", ".") }
       end
     end
 
     it "should return a list of assets which start with the given prefix" do
-      expect(@fs.buckets[:memory].ls('memory/a').size).to(eq(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

data/spec/mock_s3_interface.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
-require 'ostruct'
+
+require "ostruct"
 
 class MockS3Interface
-  VALID_ACLS = %w(
-    private public-read public-read-write authenticated-read aws-exec-read bucket-owner-read bucket-owner-full-control
-  )
+  VALID_ACLS = [
+    "private",
+    "public-read",
+    "public-read-write",
+    "authenticated-read",
+    "aws-exec-read",
+    "bucket-owner-read",
+    "bucket-owner-full-control",
+  ]
 
   attr_reader :bucket_storage
 
@@ -39,6 +46,7 @@ class MockS3Interface
 
   class Bucket
     attr_reader :name, :client
+
     def initialize(client, name)
       @client = client
       @name = name
@@ -62,7 +70,7 @@ class MockS3Interface
         raise "Invalid ACL `#{options[:acl].inspect}`, must be one of: #{VALID_ACLS.inspect}"
       end
 
-      options[:body] = options[:body].force_encoding(Encoding::BINARY)
+      options[:body] = options[:body].dup.force_encoding(Encoding::BINARY)
 
       key = options.delete(:key)
 
@@ -81,6 +89,7 @@ class MockS3Interface
 
   class NullS3Object
     attr_reader :key
+
     def initialize(bucket, key)
       @bucket = bucket
       @key = key
@@ -101,6 +110,8 @@ class MockS3Interface
   class S3Object
     attr_reader :key, :options
 
+    GottenObject = Struct.new(:body, keyword_init: true)
+
     def initialize(bucket, key, options = {})
       @bucket = bucket
       @key = key
@@ -113,7 +124,7 @@ class MockS3Interface
     end
 
     def get(*)
-      OpenStruct.new(options)
+      GottenObject.new(**options)
     end
 
     def put(options = {})

data/spec/remote_s3_bucket_spec.rb

@@ -1,85 +1,88 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class RemoteS3Cloud < AssetCloud::Base
   attr_accessor :s3_connection
+
   bucket :tmp, AssetCloud::S3Bucket
 
   def s3_bucket(_key)
-    s3_connection.bucket(ENV['S3_BUCKET_NAME'])
+    s3_connection.bucket(ENV["S3_BUCKET_NAME"])
   end
 end
 
-describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] && ENV['AWS_SECRET_ACCESS_KEY'] && ENV['S3_BUCKET_NAME'] do
-  directory = File.dirname(__FILE__) + '/files'
+describe "Remote test for AssetCloud::S3Bucket",
+  if: ENV["AWS_ACCESS_KEY_ID"] && ENV["AWS_SECRET_ACCESS_KEY"] && ENV["S3_BUCKET_NAME"] do
+  directory = File.dirname(__FILE__) + "/files"
 
   before(:all) do
     Aws.config = {
-      region: ENV.fetch('AWS_REGION', 'us-east-1'),
+      region: ENV.fetch("AWS_REGION", "us-east-1"),
       credentials: Aws::Credentials.new(
-        ENV['AWS_ACCESS_KEY_ID'],
-        ENV['AWS_SECRET_ACCESS_KEY'],
+        ENV["AWS_ACCESS_KEY_ID"],
+        ENV["AWS_SECRET_ACCESS_KEY"],
       ),
     }
 
-    @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 = @bucket.ls("tmp")
     listing.each(&:delete)
   end
 
   it "#ls should return assets with proper keys" do
-    @cloud['tmp/test1.txt'] = 'test1'
-    @cloud['tmp/test2.txt'] = 'test2'
+    @cloud["tmp/test1.txt"] = "test1"
+    @cloud["tmp/test2.txt"] = "test2"
 
-    ls = @bucket.ls('tmp')
+    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.map(&:key) - ["tmp/test1.txt", "tmp/test2.txt"]).to(be_empty)
   end
 
   it "#ls returns all assets" do
-    @cloud['tmp/test1.txt'] = 'test1'
-    @cloud['tmp/test2.txt'] = 'test2'
+    @cloud["tmp/test1.txt"] = "test1"
+    @cloud["tmp/test2.txt"] = "test2"
 
     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.map(&:key) - ["tmp/test1.txt", "tmp/test2.txt"]).to(be_empty)
   end
 
   it "#delete should ignore errors when deleting" do
-    @bucket.delete('tmp/a_file_that_should_not_exist.txt')
+    @bucket.delete("tmp/a_file_that_should_not_exist.txt")
   end
 
   it "#delete should always return true" do
-    @cloud['tmp/test1.txt'] = 'test1'
+    @cloud["tmp/test1.txt"] = "test1"
 
-    expect(@bucket.delete('tmp/test1.txt')).to(eq(true))
+    expect(@bucket.delete("tmp/test1.txt")).to(eq(true))
   end
 
   it "#stat should get metadata from S3" do
     start_time = Time.now
-    value = 'hello world'
-    @cloud.build('tmp/new_file.test', value).store
-    metadata = @bucket.stat('tmp/new_file.test')
+    value = "hello world"
+    @cloud.build("tmp/new_file.test", value).store
+    metadata = @bucket.stat("tmp/new_file.test")
     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')
+    metadata = @bucket.stat("i_do_not_exist_and_never_will.test")
     expect(metadata).to(be_an(AssetCloud::Metadata))
     expect(metadata.exist).to(be(false))
   end
 
   it "#read " do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    value = "hello world"
+    key = "tmp/new_file.txt"
     @bucket.write(key, value)
     data = @bucket.read(key)
     expect(data).to(eq(value))
@@ -90,11 +93,11 @@ describe 'Remote test for AssetCloud::S3Bucket', if: ENV['AWS_ACCESS_KEY_ID'] &&
   end
 
   it "#reads first bytes when passed options" do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    value = "hello world"
+    key = "tmp/new_file.txt"
     options = { range: 0...5 }
     @bucket.write(key, value)
     data = @bucket.read(key, options)
-    expect(data).to(eq('hello'))
+    expect(data).to(eq("hello"))
   end
 end

data/spec/s3_bucket_spec.rb

@@ -1,5 +1,7 @@
-require 'spec_helper'
-require 'mock_s3_interface'
+# frozen_string_literal: true
+
+require "spec_helper"
+require "mock_s3_interface"
 
 class S3Cloud < AssetCloud::Base
   bucket :tmp, AssetCloud::S3Bucket
@@ -11,19 +13,19 @@ class S3Cloud < AssetCloud::Base
 end
 
 describe AssetCloud::S3Bucket do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before(:all) do
-    @cloud = S3Cloud.new(directory, 'http://assets/files')
-    @cloud.s3_connection = MockS3Interface.new('a', 'b')
-    @cloud.s3_bucket_name = 'asset-cloud-test'
+    @cloud = S3Cloud.new(directory, "http://assets/files")
+    @cloud.s3_connection = MockS3Interface.new("a", "b")
+    @cloud.s3_bucket_name = "asset-cloud-test"
 
     @bucket = @cloud.buckets[:tmp]
-    FileUtils.mkdir_p(directory + '/tmp')
+    FileUtils.mkdir_p(directory + "/tmp")
   end
 
   after(:each) do
-    FileUtils.rm_rf(directory + '/tmp')
+    FileUtils.rm_rf(directory + "/tmp")
   end
 
   it "#ls should return assets with proper keys" do
@@ -32,35 +34,35 @@ describe AssetCloud::S3Bucket do
     end
     expect_any_instance_of(MockS3Interface::Bucket).to(receive(:objects).and_return(collection))
 
-    ls = @bucket.ls('tmp')
+    ls = @bucket.ls("tmp")
 
     expect(ls).to(all(be_an(AssetCloud::Asset)))
-    expect(ls.map(&:key) - ['tmp/blah.gif', 'tmp/add_to_cart.gif']).to(be_empty)
+    expect(ls.map(&:key) - ["tmp/blah.gif", "tmp/add_to_cart.gif"]).to(be_empty)
   end
 
   it "#delete should not ignore errors when deleting" do
     expect_any_instance_of(MockS3Interface::NullS3Object).to(receive(:delete).and_raise(StandardError))
 
-    expect { @bucket.delete('assets/fail.gif') }.to(raise_error(StandardError))
+    expect { @bucket.delete("assets/fail.gif") }.to(raise_error(StandardError))
   end
 
   it "#delete should always return true" do
     expect_any_instance_of(MockS3Interface::NullS3Object).to(receive(:delete).and_return(nil))
 
-    expect(@bucket.delete('assets/fail.gif')).to(eq(true))
+    expect(@bucket.delete("assets/fail.gif")).to(eq(true))
   end
 
   it "#stat should get metadata from S3" do
-    value = 'hello world'
-    @cloud.build('tmp/new_file.test', value).store
-    metadata = @bucket.stat('tmp/new_file.test')
+    value = "hello world"
+    @cloud.build("tmp/new_file.test", value).store
+    metadata = @bucket.stat("tmp/new_file.test")
     expect(metadata.size).to(eq(value.size))
     expect(metadata.updated_at).to(eq(Time.parse("Mon Aug 27 17:37:51 UTC 2007")))
   end
 
   it "#read " do
-    value = 'hello world'
-    key = 'tmp/new_file.txt'
+    value = "hello world"
+    key = "tmp/new_file.txt"
     @bucket.write(key, value)
     data = @bucket.read(key)
     expect(data).to(eq(value))

data/spec/spec_helper.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-require 'rubygems'
-require 'rspec'
-require 'pry-byebug' if RUBY_VERSION >= '2.0.0'
-require 'active_support/all'
+
+require "rubygems"
+require "rspec"
+require "pry-byebug" if RUBY_VERSION >= "2.0.0"
+require "active_support/all"
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
-require 'asset_cloud'
-require 'asset_cloud/buckets/s3_bucket'
-require 'asset_cloud/buckets/gcs_bucket'
+require "asset_cloud"
+require "asset_cloud/buckets/s3_bucket"
+require "asset_cloud/buckets/gcs_bucket"