asset_cloud 2.7.1 → 2.7.2

data/spec/callbacks_spec.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
+require "spec_helper"
 
 class AfterStoreCallback
-  def self.after_store(*args); end
+  class << self
+    def after_store(*args); end
+  end
 end
 
 class CallbackAsset < AssetCloud::Asset
@@ -21,15 +23,15 @@ class CallbackAsset < AssetCloud::Asset
   def callback_before_delete(*args); end
 
   def make_value_valid
-    self.value = 'valid'
+    self.value = "valid"
   end
 
   def add_spice
-    self.value += ' spice'
+    self.value += " spice"
   end
 
   def valid_value
-    add_error('value is not "valid"') unless value == 'valid'
+    add_error('value is not "valid"') unless value == "valid"
   end
 end
 
@@ -59,89 +61,89 @@ class MethodRecordingCloud < AssetCloud::Base
   before_write :callback_before_write
   after_write :callback_before_write
 
-  def method_missing(method, *_args)
-    @run_callbacks << method.to_sym
+  def callback_before_write(*)
+    @run_callbacks << __method__
   end
 end
 
 describe CallbackCloud do
   before do
-    @fs = CallbackCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    @fs.write('tmp/file.txt', 'foo')
+    @fs = CallbackCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    @fs.write("tmp/file.txt", "foo")
   end
 
   it "should invoke callbacks after store" do
-    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))
+    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))
 
-    expect(@fs.write('tmp/file.txt', 'text')).to(eq(true))
-    expect(@fs.read('tmp/file.txt')).to(eq('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
-    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))
+    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))
 
-    expect(@fs.delete('tmp/file.txt')).to(eq('foo'))
+    expect(@fs.delete("tmp/file.txt")).to(eq("foo"))
   end
 
   it "should not invoke other callbacks when a before_ filter returns false" do
     expect(@fs).to(receive(:callback_before_delete)
-      .with('tmp/file.txt')
+      .with("tmp/file.txt")
       .and_return(false))
     expect(@fs).not_to(receive(:callback_after_delete))
 
-    expect(@fs.delete('tmp/file.txt')).to(eq(nil))
+    expect(@fs.delete("tmp/file.txt")).to(eq(nil))
   end
 
   it "should invoke callbacks even when constructing a new asset" do
-    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))
+    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 = @fs.build("tmp/file.txt")
+    asset.value = "hello"
     expect(asset.store).to(eq(true))
   end
 end
 
 describe MethodRecordingCloud do
   before do
-    @fs = MethodRecordingCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @fs = MethodRecordingCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
     @fs.run_callbacks = []
   end
 
-  it 'should record event when invoked' do
-    @fs.write('tmp/file.txt', 'random data')
+  it "should record event when invoked" do
+    @fs.write("tmp/file.txt", "random data")
     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'
+  it "should record event when assignment operator is used" do
+    @fs["tmp/file.txt"] = "random data"
     expect(@fs.run_callbacks).to(eq([:callback_before_write, :callback_before_write]))
   end
 end
 
 describe CallbackAsset do
   before(:each) do
-    @fs = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    @fs.write('callback_assets/foo', 'bar')
-    @asset = @fs.asset_at('callback_assets/foo')
+    @fs = BasicCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    @fs.write("callback_assets/foo", "bar")
+    @asset = @fs.asset_at("callback_assets/foo")
   end
 
   it "should run before_validate, then validate, then after validate, then before_store, then store" do
     expect(@asset).to(receive(:callback_before_store).and_return(true))
     expect(@asset).not_to(receive(:callback_after_delete))
 
-    @asset.value = 'foo'
+    @asset.value = "foo"
     expect(@asset.store).to(eq(true))
-    expect(@asset.value).to(eq('valid spice'))
+    expect(@asset.value).to(eq("valid spice"))
   end
 
   it "should run its after_delete callback after delete is called" do
     expect(@asset).not_to(receive(:callback_before_store))
     expect(@asset).to(receive(:callback_after_delete).and_return(true))
 
-    expect(@asset.delete).to(eq('bar'))
+    expect(@asset.delete).to(eq("bar"))
   end
 
   it "not invoke other callbacks when a before_ filter returns false" do
@@ -152,13 +154,13 @@ describe CallbackAsset do
   end
 
   it "should invoke after_store callback defined in separate class" do
-    local_fs = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    local_fs.write('callback_assets/foo', 'bar')
-    local_asset = local_fs.asset_at('callback_assets/foo')
-    
+    local_fs = BasicCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    local_fs.write("callback_assets/foo", "bar")
+    local_asset = local_fs.asset_at("callback_assets/foo")
+
     expect(local_asset).to(receive(:callback_before_store).and_return(true))
-    expect(::AfterStoreCallback).to(receive(:after_store))
-    
+    expect(AfterStoreCallback).to(receive(:after_store))
+
     expect(local_asset.store).to(eq(true))
   end
 end

data/spec/file_system_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'fileutils'
+
+require "spec_helper"
+require "fileutils"
 
 class FileSystemCloud < AssetCloud::Base
   bucket AssetCloud::InvalidBucket
@@ -9,64 +10,64 @@ class FileSystemCloud < AssetCloud::Base
 end
 
 describe FileSystemCloud do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @fs = FileSystemCloud.new(directory, 'http://assets/files')
-    FileUtils.mkdir_p(directory + '/tmp')
+    @fs = FileSystemCloud.new(directory, "http://assets/files")
+    FileUtils.mkdir_p(directory + "/tmp")
   end
 
   after do
-    FileUtils.rm_rf(directory + '/tmp')
+    FileUtils.rm_rf(directory + "/tmp")
   end
 
   it "should use invalid bucket for random directories" do
-    expect(@fs.bucket_for('does-not-exist/file.txt')).to(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
-    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))
+    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
-    expect(@fs['products/key.txt'].exist?).to(eq(true))
-    expect(@fs['products/key.txt']).to(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
-    expect(@fs.stat('products/key.txt').exist?).to(eq(true))
-    expect(@fs.stat('products/key2.txt').exist?).to(eq(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
-    expect(@fs.ls('products').collect(&:key)).to(eq(['products/key.txt']))
+    expect(@fs.ls("products").collect(&:key)).to(eq(["products/key.txt"]))
   end
 
-  describe 'when modifying file system' do
+  describe "when modifying file system" do
     it "should call write after storing an asset" do
-      expect(@fs.buckets[:tmp]).to(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
+      @fs.build("tmp/new_file.test", "hello world").store
     end
 
     it "should be able to create new files" do
-      @fs.build('tmp/new_file.test', 'hello world').store
+      @fs.build("tmp/new_file.test", "hello world").store
 
-      expect(@fs.stat('tmp/new_file.test').exist).to(eq(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["tmp/new_file.test"] = "hello world"
 
-      expect(@fs.stat('tmp/new_file.test').exist).to(eq(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.build("tmp/new_file.test", "hello world").store
 
-      expect(@fs['tmp/new_file.test'].exist?).to(eq(true))
-      expect(@fs['tmp/new_file.test'].value).to(eq('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,44 +1,43 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+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
+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
-    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(false))
+    expect(FindFreeKey).to(receive(:exist?).with("free.txt").and_return(false))
 
-    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('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
-    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))
+    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))
 
-    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('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
-    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))
+    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))
 
-    expect(FindFreeKey.find_free_key_like('products/images/image.gif')).to(eq('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
     allow(FindFreeKey).to(receive(:exist?).and_return(true))
-    expect { FindFreeKey.find_free_key_like('free.txt') }.to(raise_error(StandardError))
+    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
-    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'))
+    expect(FindFreeKey).to(receive(:exist?).with("free_as-in-beer.txt").and_return(false))
+    allow(SecureRandom).to(receive(:uuid).and_return("as-in-beer"))
 
-    expect(FindFreeKey.find_free_key_like('free.txt', force_uuid: true)).to(eq('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,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))