asset_cloud 2.7.1 → 2.7.2

data/spec/active_record_bucket_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 MockRecords = Object.new
 
 class MockActiveRecordBucket < AssetCloud::ActiveRecordBucket
-  self.key_attribute = 'name'
-  self.value_attribute = 'body'
+  self.key_attribute = "name"
+  self.value_attribute = "body"
 
   protected
 
@@ -19,24 +20,24 @@ class RecordCloud < AssetCloud::Base
 end
 
 describe AssetCloud::ActiveRecordBucket do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @cloud = RecordCloud.new(directory, 'http://assets/files')
+    @cloud = RecordCloud.new(directory, "http://assets/files")
     @bucket = @cloud.buckets[:stuff]
   end
 
-  describe '#ls' do
+  describe "#ls" do
     before do
       expect(MockRecords).to(receive(:connection).and_return(@mock_connection = double("connection")))
-      expect(@mock_connection).to(receive(:quote_column_name).with('name').and_return("`name`"))
-      expect(@mock_record = double("record")).to(receive(:name).and_return('stuff/a1'))
+      expect(@mock_connection).to(receive(:quote_column_name).with("name").and_return("`name`"))
+      expect(@mock_record = double("record")).to(receive(:name).and_return("stuff/a1"))
     end
 
     it "should return a list of assets which start with the given prefix" do
       expect(MockRecords).to(receive(:all).with(conditions: ["`name` LIKE ?", "stuff/a%"]).and_return([@mock_record]))
 
-      expect(@bucket.ls('stuff/a').size).to(eq(1))
+      expect(@bucket.ls("stuff/a").size).to(eq(1))
     end
 
     it "should return a list of all assets when a prefix is not given" do
@@ -46,47 +47,47 @@ describe AssetCloud::ActiveRecordBucket do
     end
   end
 
-  describe '#read' do
+  describe "#read" do
     it "should return the value of a key when it exists" do
-      expect(@mock_record = double("record")).to(receive(:body).and_return('foo'))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(@mock_record = double("record")).to(receive(:body).and_return("foo"))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      @bucket.read('stuff/a1')
+      @bucket.read("stuff/a1")
     end
     it "should raise AssetNotFoundError when nothing is there" do
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(nil))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(nil))
 
-      expect { @bucket.read('stuff/a1') }.to(raise_error(AssetCloud::AssetNotFoundError))
+      expect { @bucket.read("stuff/a1") }.to(raise_error(AssetCloud::AssetNotFoundError))
     end
   end
 
-  describe '#write' do
+  describe "#write" do
     it "should write to the DB" do
-      expect(@mock_record = double("record")).to(receive(:body=).with('foo').and_return('foo'))
+      expect(@mock_record = double("record")).to(receive(:body=).with("foo").and_return("foo"))
       expect(@mock_record).to(receive(:save!).and_return(true))
-      expect(MockRecords).to(receive(:find_or_initialize_by_name).with('stuff/a1').and_return(@mock_record))
+      expect(MockRecords).to(receive(:find_or_initialize_by_name).with("stuff/a1").and_return(@mock_record))
 
-      @bucket.write('stuff/a1', 'foo')
+      @bucket.write("stuff/a1", "foo")
     end
   end
 
-  describe '#delete' do
+  describe "#delete" do
     it "should destroy records" do
       expect(@mock_record = double("record")).to(receive(:destroy).and_return(true))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      @bucket.delete('stuff/a1')
+      @bucket.delete("stuff/a1")
     end
   end
 
-  describe '#stat' do
+  describe "#stat" do
     it "should return appropriate metadata" do
       expect(@mock_record = double("record")).to(receive(:created_at).and_return(1982))
       expect(@mock_record).to(receive(:updated_at).and_return(2002))
-      expect(@mock_record).to(receive(:body).and_return('foo'))
-      expect(MockRecords).to(receive(:first).with(conditions: { 'name' => 'stuff/a1' }).and_return(@mock_record))
+      expect(@mock_record).to(receive(:body).and_return("foo"))
+      expect(MockRecords).to(receive(:first).with(conditions: { "name" => "stuff/a1" }).and_return(@mock_record))
 
-      metadata = @bucket.stat('stuff/a1')
+      metadata = @bucket.stat("stuff/a1")
       expect(metadata.created_at).to(eq(1982))
       expect(metadata.updated_at).to(eq(2002))
       expect(metadata.size).to(eq(3))

data/spec/asset_cloud/metadata_spec.rb

@@ -1,5 +1,7 @@
-require 'spec_helper'
-require 'asset_cloud/metadata'
+# frozen_string_literal: true
+
+require "spec_helper"
+require "asset_cloud/metadata"
 
 module AssetCloud
   describe Metadata do

data/spec/asset_extension_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class NoCatsAsset < AssetCloud::Asset
   validate :no_cats
@@ -8,7 +9,7 @@ class NoCatsAsset < AssetCloud::Asset
   private
 
   def no_cats
-    add_error('no cats allowed!') if value =~ /cat/i
+    add_error("no cats allowed!") if value =~ /cat/i
   end
 end
 
@@ -53,33 +54,33 @@ describe "AssetExtension" do
   include AssetCloud
 
   before do
-    @cloud = CatsAndDogsCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @cloud = CatsAndDogsCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
   end
 
   describe "applicability" do
     it "should work" do
-      asset = @cloud['cat_pen/cats.xml']
+      asset = @cloud["cat_pen/cats.xml"]
       expect(XmlAssetExtension.applies_to_asset?(asset)).to(eq(true))
     end
   end
 
   describe "validations" do
     it "should be added to assets in the right bucket with the right extension" do
-      asset = @cloud['cat_pen/cats.css']
-      asset.value = 'foo'
+      asset = @cloud["cat_pen/cats.css"]
+      asset.value = "foo"
       expect(asset.store).to(eq(false))
       expect(asset.errors).to(eq(["not enough curly brackets!"]))
     end
 
     it "should not squash existing validations on the asset" do
-      asset = @cloud['dog_pound/cats.xml']
-      asset.value = 'cats!'
+      asset = @cloud["dog_pound/cats.xml"]
+      asset.value = "cats!"
       expect(asset.store).to(eq(false))
-      expect(asset.errors).to(eq(['no cats allowed!', "not enough angle brackets!"]))
+      expect(asset.errors).to(eq(["no cats allowed!", "not enough angle brackets!"]))
     end
 
     it "should not apply to non-matching assets or those in exempted buckets" do
-      asset = @cloud['cat_pen/cats.xml']
+      asset = @cloud["cat_pen/cats.xml"]
       asset.value = "xml"
       expect(asset.store).to(eq(true))
     end
@@ -87,20 +88,20 @@ describe "AssetExtension" do
 
   describe "callbacks" do
     it "should run alongside the asset's callbacks" do
-      asset = @cloud['dog_pound/dogs.xml']
+      asset = @cloud["dog_pound/dogs.xml"]
       expect(asset).to(receive(:asset_callback))
       expect(asset.extensions.first).to(receive(:xml_callback))
-      asset.value = '<dogs/>'
+      asset.value = "<dogs/>"
       expect(asset.store).to(eq(true))
     end
   end
 
   describe "#method_missing" do
     it "should try to run method on extensions" do
-      asset = @cloud['dog_pound/dogs.xml']
-      asset.value = 'dogs'
+      asset = @cloud["dog_pound/dogs.xml"]
+      asset.value = "dogs"
       asset.turn_into_xml
-      expect(asset.value).to(eq('<xml>dogs</xml>'))
+      expect(asset.value).to(eq("<xml>dogs</xml>"))
     end
 
     it "does not swallow NotImplementedError" do
@@ -108,7 +109,7 @@ describe "AssetExtension" do
         raise NotImplementedError
       end
 
-      asset = @cloud['dog_pound/dogs.xml']
+      asset = @cloud["dog_pound/dogs.xml"]
 
       expect(asset).to(respond_to(:my_unimplemented_extension))
       expect { asset.my_unimplemented_extension }.to(raise_error(NotImplementedError))

data/spec/asset_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe "Asset" do
   include AssetCloud
 
   before do
-    @cloud = double('Cloud', asset_extension_classes_for_bucket: [])
+    @cloud = double("Cloud", asset_extension_classes_for_bucket: [])
   end
 
   describe "when first created (without a value)" do
@@ -18,7 +19,7 @@ describe "Asset" do
     end
 
     it "should have a key" do
-      expect(@asset.key).to(eq('products/key.txt'))
+      expect(@asset.key).to(eq("products/key.txt"))
     end
 
     it "should have a value of nil" do
@@ -26,23 +27,23 @@ describe "Asset" do
     end
 
     it "should have a basename" do
-      expect(@asset.basename).to(eq('key.txt'))
+      expect(@asset.basename).to(eq("key.txt"))
     end
 
     it "should have a basename without ext (if required)" do
-      expect(@asset.basename_without_ext).to(eq('key'))
+      expect(@asset.basename_without_ext).to(eq("key"))
     end
 
     it "should have an ext" do
-      expect(@asset.extname).to(eq('.txt'))
+      expect(@asset.extname).to(eq(".txt"))
     end
 
     it "should have a relative_key_without_ext" do
-      expect(@asset.relative_key_without_ext).to(eq('key'))
+      expect(@asset.relative_key_without_ext).to(eq("key"))
     end
 
     it "should have a bucket_name" do
-      expect(@asset.bucket_name).to(eq('products'))
+      expect(@asset.bucket_name).to(eq("products"))
     end
 
     it "should have a bucket" do
@@ -51,9 +52,9 @@ describe "Asset" do
     end
 
     it "should store data to the bucket" do
-      expect(@cloud).to(receive(:write).with("products/key.txt", 'value'))
+      expect(@cloud).to(receive(:write).with("products/key.txt", "value"))
 
-      @asset.value = 'value'
+      @asset.value = "value"
       @asset.store
     end
 
@@ -82,17 +83,17 @@ describe "Asset" do
     end
 
     it "should have a relative_key_without_ext" do
-      expect(@asset.relative_key_without_ext).to(eq('retail/key'))
+      expect(@asset.relative_key_without_ext).to(eq("retail/key"))
     end
 
     it "should have a relative_key" do
-      expect(@asset.relative_key).to(eq('retail/key.txt'))
+      expect(@asset.relative_key).to(eq("retail/key.txt"))
     end
   end
 
   describe "when first created with value" do
     before do
-      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt", 'value')
+      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt", "value")
     end
 
     it "should be return new_asset? => true" do
@@ -100,7 +101,7 @@ describe "Asset" do
     end
 
     it "should have a value of 'value'" do
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should return false when asked if it exists because its still a new_asset" do
@@ -110,18 +111,23 @@ describe "Asset" do
     it "should not try to read data from bucket if its a new_asset" do
       expect(@cloud).to(receive(:read).never)
 
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should write data to the bucket" do
-      expect(@cloud).to(receive(:write).with("products/key.txt", 'value'))
+      expect(@cloud).to(receive(:write).with("products/key.txt", "value"))
       @asset.store
     end
   end
 
   describe "when fetched from the bucket" do
     before do
-      @asset = AssetCloud::Asset.at(@cloud, "products/key.txt", 'value', AssetCloud::Metadata.new(true, 'value'.size, Time.now, Time.now))
+      @asset = AssetCloud::Asset.at(
+        @cloud,
+        "products/key.txt",
+        "value",
+        AssetCloud::Metadata.new(true, "value".size, Time.now, Time.now),
+      )
     end
 
     it "should be return new_asset? => false" do
@@ -133,7 +139,7 @@ describe "Asset" do
     end
 
     it "should read the value from the bucket" do
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should simply ignore calls to delete" do
@@ -143,13 +149,13 @@ describe "Asset" do
     end
 
     it "should ask the bucket to create a full url" do
-      expect(@cloud).to(receive(:url_for).with('products/key.txt', {}).and_return('http://assets/products/key.txt'))
+      expect(@cloud).to(receive(:url_for).with("products/key.txt", {}).and_return("http://assets/products/key.txt"))
 
-      expect(@asset.url).to(eq('http://assets/products/key.txt'))
+      expect(@asset.url).to(eq("http://assets/products/key.txt"))
     end
 
     it "should ask the bucket whether or not it is versioned" do
-      bucket = double('Bucket')
+      bucket = double("Bucket")
       expect(@cloud).to(receive(:buckets).and_return(products: bucket))
       expect(bucket).to(receive(:versioned?).and_return(true))