asset_cloud 1.0.2

data/spec/base_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+class SpecialAsset < AssetCloud::Asset
+end
+
+class BasicCloud < AssetCloud::Base
+  bucket :special, AssetCloud::MemoryBucket, :asset_class => SpecialAsset
+end
+
+
+describe BasicCloud do
+  directory = File.dirname(__FILE__) + '/files'
+
+  before do
+    @fs = BasicCloud.new(directory , 'http://assets/files' )
+  end
+
+  it "should raise invalid bucket if none is given" do
+    @fs['image.jpg'].exist?.should == false
+  end
+
+
+  it "should be backed by a file system bucket" do
+    @fs['products/key.txt'].exist?.should == true
+  end
+
+  it "should raise when listing non existing buckets" do
+    @fs.ls('products').should == [AssetCloud::Asset.new(@fs, 'products/key.txt')]
+  end
+
+
+  it "should allow you to create new assets" do
+    obj = @fs.build('new_file.test')
+    obj.should be_an_instance_of(AssetCloud::Asset)
+    obj.cloud.should be_an_instance_of(BasicCloud)
+  end
+
+  it "should raise error when using with minus relative or absolute paths" do
+    lambda { @fs['../test']  }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['/test']    }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['.../test'] }.should raise_error(AssetCloud::IllegalPath)
+    lambda { @fs['./test']   }.should raise_error(AssetCloud::IllegalPath)
+  end
+
+  it "should allow sensible relative filenames" do
+    @fs['assets/rails_logo.gif']
+    @fs['assets/rails-2.gif']
+    @fs['assets/223434.gif']
+    @fs['files/1.JPG']
+  end
+
+  it "should compute complete urls to assets" do
+    @fs.url_for('products/key with spaces.txt').should == 'http://assets/files/products/key%20with%20spaces.txt'
+  end
+
+  describe "#find" do
+    it "should return the appropriate asset when one exists" do
+      asset = @fs.find('products/key.txt')
+      asset.key.should == 'products/key.txt'
+      asset.value.should == 'value'
+    end
+    it "should raise AssetNotFoundError when the asset doesn't exist" do
+      lambda { @fs.find('products/not-there.txt') }.should raise_error(AssetCloud::AssetNotFoundError)
+    end
+  end
+
+  describe "#[]" do
+    it "should return the appropriate asset when one exists" do
+      asset = @fs['products/key.txt']
+      asset.key.should == 'products/key.txt'
+      asset.value.should == 'value'
+    end
+    it "should not raise any errors when the asset doesn't exist" do
+      lambda { @fs['products/not-there.txt'] }.should_not raise_error
+    end
+  end
+
+  describe "#[]=" do
+    it "should write through the Asset object (and thus run any callbacks on the asset)" do
+      special_asset = double(:special_asset)
+      special_asset.should_receive(:value=).with('fancy fancy!')
+      special_asset.should_receive(:store)
+      SpecialAsset.should_receive(:at).and_return(special_asset)
+      @fs['special/fancy.txt'] = 'fancy fancy!'
+    end
+  end
+
+  describe "#bucket" do
+    it "should allow specifying a class to use for assets in this bucket" do
+      @fs['assets/rails_logo.gif'].should be_instance_of(AssetCloud::Asset)
+      @fs['special/fancy.txt'].should be_instance_of(SpecialAsset)
+
+      @fs.build('assets/foo').should be_instance_of(AssetCloud::Asset)
+      @fs.build('special/foo').should be_instance_of(SpecialAsset)
+    end
+  end
+
+  describe "MATCH_BUCKET" do
+    it "should match following stuff " do
+
+      'products/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
+      $1.should == 'products'
+
+      'products/subpath/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
+      $1.should == 'products'
+
+      'key.txt' =~ AssetCloud::Base::MATCH_BUCKET
+      $1.should == nil
+
+      'products' =~ AssetCloud::Base::MATCH_BUCKET
+      $1.should == 'products'
+    end
+  end
+end

data/spec/blackhole_bucket_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+class BlackholeCloud < AssetCloud::Base
+  bucket AssetCloud::BlackholeBucket
+end
+
+describe BlackholeCloud do
+  directory = File.dirname(__FILE__) + '/files'
+
+  before do
+    @fs = BlackholeCloud.new(directory , 'http://assets/files' )
+  end
+
+  it "should allow access to files using the [] operator" do
+    @fs['tmp/image.jpg']
+  end
+
+  it "should return nil for non existent files" do
+    @fs['tmp/image.jpg'].exist?.should == false
+  end
+
+  it "should still return nil, even if you wrote something there" do
+    @fs['tmp/image.jpg'] = 'test'
+    @fs['tmp/image.jpg'].exist?.should == false
+  end
+
+  describe "when using a sub path" do
+    it "should allow access to files using the [] operator" do
+      @fs['tmp/image.jpg']
+    end
+
+    it "should return nil for non existent files" do
+      @fs['tmp/image.jpg'].exist?.should == false
+    end
+
+    it "should still return nil, even if you wrote something there" do
+      @fs['tmp/image.jpg'] = 'test'
+      @fs['tmp/image.jpg'].exist?.should == false
+    end
+  end
+end

data/spec/bucket_chain_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+class ChainedCloud < AssetCloud::Base
+  bucket :stuff, AssetCloud::BucketChain.chain( AssetCloud::MemoryBucket,
+                                                AssetCloud::MemoryBucket,
+                                                AssetCloud::FileSystemBucket )
+
+  bucket :versioned_stuff, AssetCloud::BucketChain.chain( AssetCloud::FileSystemBucket,
+                                                          AssetCloud::VersionedMemoryBucket,
+                                                          AssetCloud::MemoryBucket )
+end
+
+describe AssetCloud::BucketChain do
+  directory = File.dirname(__FILE__) + '/files'
+
+  before(:each) do
+    @cloud = ChainedCloud.new(directory , 'http://assets/files' )
+    @bucket_chain = @cloud.buckets[:stuff]
+    @chained_buckets = @bucket_chain.chained_buckets
+    @chained_buckets.each {|b| b.ls('stuff').each {|asset| asset.delete}}
+
+    @versioned_stuff = @cloud.buckets[:versioned_stuff]
+  end
+
+  describe ".chain" do
+    it 'should take multiple Bucket classes and return a new Bucket class' do
+      @bucket_chain.should be_a_kind_of(AssetCloud::BucketChain)
+    end
+  end
+
+  describe "#write" do
+    it 'should write to each sub-bucket when everything is kosher and return the result of the first write' do
+      @chained_buckets.each do |bucket|
+        bucket.should_receive(:write).with('stuff/foo', 'successful creation').and_return('successful creation')
+      end
+
+      @bucket_chain.write('stuff/foo', 'successful creation').should == 'successful creation'
+    end
+    it 'should roll back creation-writes and re-raise an error when a bucket raises one' do
+      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_raise('hell')
+      @chained_buckets[0..-2].each do |bucket|
+        bucket.should_receive(:write).with('stuff/foo', 'unsuccessful creation').and_return(true)
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+      end
+
+      lambda { @bucket_chain.write('stuff/foo', 'unsuccessful creation') }.should raise_error(RuntimeError)
+    end
+    it 'should roll back update-writes and re-raise an error when a bucket raises one' do
+      @bucket_chain.write('stuff/foo', "original value")
+
+      @chained_buckets.last.should_receive(:write).with('stuff/foo', 'new value').and_raise('hell')
+
+      lambda { @bucket_chain.write('stuff/foo', 'new value') }.should raise_error(RuntimeError)
+      @chained_buckets.each do |bucket|
+        bucket.read('stuff/foo').should == 'original value'
+      end
+    end
+  end
+
+  describe "#delete" do
+    it 'should delete from each sub-bucket when everything is kosher' do
+      @bucket_chain.write('stuff/foo', "successful deletion comin' up")
+
+      @chained_buckets.each do |bucket|
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+      end
+
+      @bucket_chain.delete('stuff/foo')
+    end
+    it 'should roll back deletions and re-raise an error when a bucket raises one' do
+      @bucket_chain.write('stuff/foo', "this deletion will fail")
+
+      @chained_buckets.last.should_receive(:delete).with('stuff/foo').and_raise('hell')
+      @chained_buckets[0..-2].each do |bucket|
+        bucket.should_receive(:delete).with('stuff/foo').and_return(true)
+        bucket.should_receive(:write).with('stuff/foo', 'this deletion will fail').and_return(true)
+      end
+
+      lambda { @bucket_chain.delete('stuff/foo') }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe "#read" do
+    it 'should read from only the first available sub-bucket' do
+      @chained_buckets[0].should_receive(:read).with('stuff/foo').and_raise(NotImplementedError)
+      @chained_buckets[0].should_receive(:ls).with(nil).and_raise(NoMethodError)
+      @chained_buckets[0].should_receive(:stat).and_return(:metadata)
+
+      @chained_buckets[1].should_receive(:read).with('stuff/foo').and_return('bar')
+      @chained_buckets[1].should_receive(:ls).with(nil).and_return(:some_assets)
+      @chained_buckets[1].should_not_receive(:stat)
+
+      @chained_buckets[2..-1].each do |bucket|
+        bucket.should_not_receive(:read)
+        bucket.should_not_receive(:ls)
+        bucket.should_not_receive(:stat)
+      end
+
+      @bucket_chain.read('stuff/foo').should == 'bar'
+      @bucket_chain.ls.should == :some_assets
+      @bucket_chain.stat.should == :metadata
+    end
+  end
+
+
+  describe "#read_version" do
+    it 'should read from only the first available sub-bucket' do
+      buckets = @versioned_stuff.chained_buckets
+
+      buckets[1].should_receive(:read_version).with('stuff/foo',3).and_return('bar')
+      buckets.last.should_not_receive(:read_version)
+
+      @versioned_stuff.read_version('stuff/foo', 3).should == 'bar'
+    end
+  end
+
+  describe "#versions" do
+    it 'should read from only the first available sub-bucket' do
+      buckets = @versioned_stuff.chained_buckets
+
+      buckets[1].should_receive(:versions).with('versioned_stuff/foo').and_return([1,2,3])
+      buckets.last.should_not_receive(:versions)
+
+      @versioned_stuff.versions('versioned_stuff/foo').should == [1,2,3]
+    end
+  end
+
+  describe "with versioned buckets" do
+    it 'should store and retrieve versions seamlessly' do
+      %w{one two three}.each do |content|
+        @cloud['versioned_stuff/foo'] = content
+      end
+      asset = @cloud['versioned_stuff/foo']
+      asset.value.should == 'three'
+      asset.rollback(1).value.should == 'one'
+      asset.versions.should == [1,2,3]
+      asset.value = 'four'
+      asset.store
+      asset.versions.should == [1,2,3,4]
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'should return true if any chained buckets respond to the given method' do
+      @bucket_chain.respond_to?(:foo).should == false
+      @chained_buckets[1].should_receive(:respond_to?).with(:bar).and_return(true)
+      @bucket_chain.respond_to?(:bar).should == true
+    end
+  end
+
+  describe '#method_missing' do
+    it 'should try each bucket' do
+      @chained_buckets[1].should_receive(:buzz).and_return(true)
+      @chained_buckets[2].should_not_receive(:buzz)
+      @bucket_chain.buzz.should == true
+    end
+  end
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+class CallbackAsset < AssetCloud::Asset
+  before_store :callback_before_store
+  after_delete :callback_after_delete
+  before_validate :make_value_valid
+  after_validate :add_spice
+  validate :valid_value
+
+  private
+  def make_value_valid
+    self.value = 'valid'
+  end
+  def add_spice
+    self.value += ' spice'
+  end
+
+  def valid_value
+    add_error 'value is not "valid"' unless value == 'valid'
+  end
+end
+
+class BasicCloud < AssetCloud::Base
+  bucket :callback_assets, AssetCloud::MemoryBucket, :asset_class => CallbackAsset
+end
+
+class CallbackCloud < AssetCloud::Base
+  bucket :tmp, AssetCloud::MemoryBucket
+
+  after_delete :callback_after_delete
+  before_delete :callback_before_delete
+
+  after_write :callback_after_write
+  before_write :callback_before_write
+end
+
+class MethodRecordingCloud < AssetCloud::Base
+  attr_accessor :run_callbacks
+
+  bucket :tmp, AssetCloud::MemoryBucket
+
+  before_write :callback_before_write
+  after_write :callback_before_write
+
+
+  def method_missing(method, *args)
+    @run_callbacks << method.to_sym
+  end
+end
+
+describe CallbackCloud do
+  before { @fs = CallbackCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/') }
+
+  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)
+
+
+    @fs.write 'tmp/file.txt', '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)
+
+
+    @fs.delete 'tmp/file.txt'
+  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)
+
+
+    asset = @fs.build('tmp/file.txt')
+    asset.value = 'hello'
+    asset.store
+
+  end
+
+end
+
+describe MethodRecordingCloud do
+  before do
+    @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')
+    @fs.run_callbacks.should == [: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]
+  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')
+  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)
+
+    @asset.value = 'foo'
+    @asset.store.should == true
+    @asset.value.should == '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)
+
+    @asset.delete
+  end
+end

data/spec/file_system_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'fileutils'
+
+class FileSystemCloud < AssetCloud::Base
+  bucket AssetCloud::InvalidBucket
+  bucket :products, AssetCloud::FileSystemBucket
+  bucket :tmp,      AssetCloud::FileSystemBucket
+end
+
+
+describe FileSystemCloud do
+  directory = File.dirname(__FILE__) + '/files'
+
+  before do
+    @fs = FileSystemCloud.new(directory , 'http://assets/files' )
+    FileUtils.mkdir_p(directory + '/tmp')
+  end
+
+  after do
+    FileUtils.rm_rf(directory + '/tmp')
+  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)
+  end
+
+  it "should use filesystem bucekt 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)
+  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)
+  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
+  end
+
+  it "should be able to list files" do
+    @fs.ls('products').collect(&:key).should == ['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)
+
+      @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.stat('tmp/new_file.test').exist.should == 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
+    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'
+    end
+
+  end
+end