dragonfly 0.6.2 → 0.7.0

data/spec/dragonfly/configurable_spec.rb

@@ -54,6 +54,10 @@ describe Dragonfly::Configurable do
         end
       }.should raise_error(Dragonfly::Configurable::BadConfigAttribute)
     end
+    
+    it "should return itself" do
+      @car.configure{|c|}.should == @car
+    end
   end
   
   describe "getting configuration" do
@@ -203,6 +207,16 @@ describe Dragonfly::Configurable do
       end
       @car.colour.should == 'branco'
     end
+    
+    it "should return itself" do
+      @car.configure_with(@cool_configuration).should == @car
+    end
+    
+    it "should ask the object which object to configure with if a symbol is given" do
+      @car.should_receive(:configurer_for).with(:cool).and_return(@cool_configuration)
+      @car.configure_with(:cool)
+      @car.colour.should == 'vermelho'
+    end
   end
   
 end

data/spec/dragonfly/data_storage/data_store_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 describe "data_store", :shared => true do
 
   # Using these shared spec requires you to set the inst var @data_store
-  
+
   before(:each) do
     @temp_object = Dragonfly::TempObject.new('gollum')
   end
@@ -13,12 +13,39 @@ describe "data_store", :shared => true do
       temp_object2 = Dragonfly::TempObject.new('gollum')
       @data_store.store(@temp_object).should_not == @data_store.store(temp_object2)
     end
+    it "should allow for passing in options as a second argument" do
+      @data_store.store(@temp_object, :some => :option)
+    end
   end
-  
+
   describe "retrieve" do
-    it "should retrieve the stored data" do
-      uid = @data_store.store(@temp_object)
-      Dragonfly::TempObject.new(@data_store.retrieve(uid)).data.should == @temp_object.data
+
+    describe "without extra info" do
+      before(:each) do
+        uid = @data_store.store(@temp_object)
+        @obj, @extra_info = @data_store.retrieve(uid)
+      end
+
+      it "should retrieve the stored data" do
+        Dragonfly::TempObject.new(@obj).data.should == @temp_object.data
+      end
+
+      it { @extra_info[:name].should be_nil }
+      it { @extra_info[:meta].should be_a(Hash) }
+    end
+
+    describe "when extra info is given" do
+      before(:each) do
+        temp_object = Dragonfly::TempObject.new('gollum',
+          :name => 'danny.boy',
+          :meta => {:bitrate => '35'}
+        )
+        @uid = @data_store.store(temp_object)
+        @obj, @extra_info = @data_store.retrieve(@uid)
+      end
+
+      it { @extra_info[:name].should == 'danny.boy' }
+      it { @extra_info[:meta].should include_hash(:bitrate => '35') }
     end
 
     it "should raise an exception if the data doesn't exist" do
@@ -27,9 +54,9 @@ describe "data_store", :shared => true do
       }.should raise_error(Dragonfly::DataStorage::DataNotFound)
     end
   end
-  
+
   describe "destroy" do
-    
+
     it "should destroy the stored data" do
       uid = @data_store.store(@temp_object)
       @data_store.destroy(uid)
@@ -37,7 +64,7 @@ describe "data_store", :shared => true do
         @data_store.retrieve(uid)
       }.should raise_error(Dragonfly::DataStorage::DataNotFound)
     end
-    
+
   end
 
-end
+end

data/spec/dragonfly/data_storage/file_data_store_spec.rb

@@ -3,19 +3,19 @@ require File.dirname(__FILE__) + '/data_store_spec'
 
 describe Dragonfly::DataStorage::FileDataStore do
   
+  def touch_file(filename)
+    FileUtils.mkdir_p(File.dirname(filename))
+    FileUtils.touch(filename)
+  end
+  
   before(:each) do
     @data_store = Dragonfly::DataStorage::FileDataStore.new
     @data_store.root_path = '/var/tmp/dragonfly_test'
-    
-    # Set 'now' to a date in the past
-    Time.stub!(:now).and_return Time.mktime(1984,"may",4,14,28,1)
-    @file_pattern_prefix_without_root = '1984/05/04/142801'
-    @file_pattern_prefix = "#{@data_store.root_path}/#{@file_pattern_prefix_without_root}"
   end
   
   after(:each) do
     # Clean up created files
-    FileUtils.rm_rf("#{@data_store.root_path}/1984")
+    FileUtils.rm_rf("#{@data_store.root_path}")
   end
   
   it_should_behave_like 'data_store'
@@ -27,54 +27,55 @@ describe Dragonfly::DataStorage::FileDataStore do
   describe "store" do
     
     def it_should_write_to_file(storage_path, temp_object)
-      FileUtils.should_receive(:cp).with(temp_object.path, storage_path)
+      temp_object.should_receive(:to_file).with(storage_path).and_return(mock('file', :close => nil))
+    end
+    
+    before(:each) do
+      # Set 'now' to a date in the past
+      Time.stub!(:now).and_return Time.mktime(1984,"may",4,14,28,1)
+      @file_pattern_prefix_without_root = '1984/05/04/'
+      @file_pattern_prefix = "#{@data_store.root_path}/#{@file_pattern_prefix_without_root}"
     end
     
     it "should store the file in a folder based on date, with default filename" do
-      it_should_write_to_file("#{@file_pattern_prefix}_file", @temp_object)
+      it_should_write_to_file("#{@file_pattern_prefix}file", @temp_object)
       @data_store.store(@temp_object)
     end
 
     it "should use the temp_object name if it exists" do
-      @temp_object.name = 'hello'
-      it_should_write_to_file("#{@file_pattern_prefix}_hello", @temp_object)
-      @data_store.store(@temp_object)
-    end
-    
-    it "should strip the extension of the temp_object name" do
-      @temp_object.name = 'hello.you.png'
-      it_should_write_to_file("#{@file_pattern_prefix}_hello.you", @temp_object)
+      @temp_object.should_receive(:name).at_least(:once).and_return('hello.there')
+      it_should_write_to_file("#{@file_pattern_prefix}hello.there", @temp_object)
       @data_store.store(@temp_object)
     end
 
-    it "should use the default file suffix if the temp_object name is blank" do
-      @temp_object.name = ''
-      it_should_write_to_file("#{@file_pattern_prefix}_file", @temp_object)
+    it "should get rid of funny characters in the temp_object name" do
+      @temp_object.should_receive(:name).at_least(:once).and_return('A Picture with many spaces in its name (at 20:00 pm).png')
+      it_should_write_to_file("#{@file_pattern_prefix}A_Picture_with_many_spaces_in_its_name_at_20_00_pm_.png", @temp_object)
       @data_store.store(@temp_object)
     end
 
     describe "when the filename already exists" do
 
-      it "should store the file with a numbered suffix" do
-        FileUtils.mkdir_p(@file_pattern_prefix)
-        FileUtils.touch("#{@file_pattern_prefix}_file")
-        it_should_write_to_file("#{@file_pattern_prefix}_file_2", @temp_object)
+      it "should use a different filename" do
+        touch_file("#{@file_pattern_prefix}file")
+        @data_store.should_receive(:disambiguate).with('file').and_return('file_2')
+        it_should_write_to_file("#{@file_pattern_prefix}file_2", @temp_object)
         @data_store.store(@temp_object)
       end
     
-      it "should store the file with a numbered suffix taking into account the name" do
-        @temp_object.name = 'hello.png'
-        FileUtils.mkdir_p(@file_pattern_prefix)
-        FileUtils.touch("#{@file_pattern_prefix}_hello")
-        it_should_write_to_file("#{@file_pattern_prefix}_hello_2", @temp_object)
+      it "should use a different filename taking into account the name and ext" do
+        @temp_object.should_receive(:name).at_least(:once).and_return('hello.png')
+        touch_file("#{@file_pattern_prefix}hello.png")
+        @data_store.should_receive(:disambiguate).with('hello.png').and_return('blah.png')
         @data_store.store(@temp_object)
       end
-    
-      it "should store the file with an incremented number suffix" do
-        FileUtils.mkdir_p(@file_pattern_prefix)
-        FileUtils.touch("#{@file_pattern_prefix}_file")
-        FileUtils.touch("#{@file_pattern_prefix}_file_2")
-        it_should_write_to_file("#{@file_pattern_prefix}_file_3", @temp_object)
+
+      it "should keep trying until it finds a free filename" do
+        touch_file("#{@file_pattern_prefix}file")
+        touch_file("#{@file_pattern_prefix}file_2")
+        @data_store.should_receive(:disambiguate).with('file').and_return('file_2')
+        @data_store.should_receive(:disambiguate).with('file_2').and_return('file_3')
+        it_should_write_to_file("#{@file_pattern_prefix}file_3", @temp_object)
         @data_store.store(@temp_object)
       end
 
@@ -83,18 +84,30 @@ describe Dragonfly::DataStorage::FileDataStore do
     describe "return value" do
 
       it "should return the filepath without the root of the stored file when a file name is not provided" do
-        @data_store.store(@temp_object).should == "#{@file_pattern_prefix_without_root}_file"
+        @data_store.store(@temp_object).should == "#{@file_pattern_prefix_without_root}file"
       end
     
       it "should return the filepath without the root of the stored file when a file name is provided" do
-        @temp_object.name = 'hello.you.png'
-        @data_store.store(@temp_object).should == "#{@file_pattern_prefix_without_root}_hello.you"
+        @temp_object.should_receive(:name).at_least(:once).and_return('hello.you.png')
+        @data_store.store(@temp_object).should == "#{@file_pattern_prefix_without_root}hello.you.png"
       end
     
     end
 
   end
   
+  describe "disambiguate" do
+    it "should add a suffix" do
+      @data_store.disambiguate('file').should =~ /^file_\w+$/
+    end
+    it "should add a suffix to the basename" do
+      @data_store.disambiguate('file.png').should =~ /^file_\w+\.png$/
+    end
+    it "should be random(-ish)" do
+      @data_store.disambiguate('file').should_not == @data_store.disambiguate('file')
+    end
+  end
+  
   describe "errors" do
 
     it "should raise an error if it can't create a directory" do
@@ -103,12 +116,22 @@ describe Dragonfly::DataStorage::FileDataStore do
     end
   
     it "should raise an error if it can't create a file" do
-      FileUtils.should_receive(:cp).and_raise(Errno::EACCES)
+      @temp_object.should_receive(:to_file).and_raise(Errno::EACCES)
       lambda{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::DataStorage::UnableToStore)
     end
 
   end
   
+  describe "retrieve" do
+    it "should be able to retrieve any file, stored or not (and without extra data)" do
+      FileUtils.mkdir_p("#{@data_store.root_path}/jelly_beans/are")
+      File.open("#{@data_store.root_path}/jelly_beans/are/good", 'w'){|f| f.write('hey dog') }
+      file, meta = @data_store.retrieve("jelly_beans/are/good")
+      file.read.should == 'hey dog'
+      meta.should == {}
+    end
+  end
+  
   describe "destroying" do
 
     it "should raise an error if the data doesn't exist" do

data/spec/dragonfly/data_storage/mongo_data_store_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/data_store_spec'
+require 'mongo'
+
+describe Dragonfly::DataStorage::MongoDataStore do
+  
+  before(:each) do
+    begin
+      Mongo::Connection.new
+    rescue Mongo::ConnectionFailure => e
+      pending "You need to start mongo on localhost:27017 to test the MongoDataStore"
+    end
+    @data_store = Dragonfly::DataStorage::MongoDataStore.new
+  end
+  
+  it_should_behave_like 'data_store'
+
+end

data/spec/dragonfly/data_storage/s3_data_store_spec.rb

@@ -3,49 +3,44 @@ require File.dirname(__FILE__) + '/data_store_spec'
 
 describe Dragonfly::DataStorage::S3DataStore do
 
-  # Uncomment this to test it with an actual internet connection
-  # describe "common data_store behaviour" do
-  #   
-  #   before(:each) do
-  #     @data_store = Dragonfly::DataStorage::S3DataStore.new
-  #     @data_store.configure do |d|
-  #       d.bucket_name = 'dragonfly_test'
-  #       d.access_key_id = 'xxxxxxxxxx'
-  #       d.secret_access_key = 'xxxxxxxxxx'
-  #     end
-  #   end
-  #   
-  #   it_should_behave_like 'data_store'
-  #   
-  # end
+  # Change this to test it with an actual internet connection
+  enabled = false
+  
+  if enabled
 
-  describe "specific s3_data_store behaviour" do
-    before(:each) do
-      @data_store = Dragonfly::DataStorage::S3DataStore.new
-      @data_store.configure do |d|
-        d.bucket_name = 'dragonfly_test'
-        d.access_key_id = 'my_key_id'
-        d.secret_access_key = 'my_secret_access_key'
+    describe "common data_store behaviour" do
+    
+      before(:each) do
+        @data_store = Dragonfly::DataStorage::S3DataStore.new
+        @data_store.configure do |d|
+          d.bucket_name = 'dragonfly_test'
+          d.access_key_id = 'XXX'
+          d.secret_access_key = 'XXX'
+        end
       end
-      @temp_object = Dragonfly::TempObject.new('gollum')
-      AWS::S3::Base.stub!(:establish_connection!).with(
-        :access_key_id => @data_store.access_key_id,
-        :secret_access_key => @data_store.secret_access_key
-      )
-      AWS::S3::Bucket.stub!(:create).with(@data_store.bucket_name)
-      AWS::S3::Service.stub!(:buckets).and_return([])
-      AWS::S3::S3Object.stub!(:store).with(anything, anything, @data_store.bucket_name)
-      AWS::S3::S3Object.stub!(:value).with(anything, @data_store.bucket_name)
-      AWS::S3::S3Object.stub!(:delete).with(anything, @data_store.bucket_name)
-    end
     
-
-    describe "store" do
-      it "should return a unique identifier for each storage" do
-        temp_object2 = Dragonfly::TempObject.new('gollum')
-        @data_store.store(@temp_object).should_not == @data_store.store(temp_object2)
+      it_should_behave_like 'data_store'
+    
+      describe "store" do
+        it "should return a unique identifier for each storage" do
+          temp_object = Dragonfly::TempObject.new('gollum')
+          temp_object2 = Dragonfly::TempObject.new('gollum')
+          @data_store.store(temp_object).should_not == @data_store.store(temp_object2)
+        end
+      
+        it "should work ok with files with funny names" do
+          temp_object = Dragonfly::TempObject.new('eggheads',
+            :name =>  'A Picture with many spaces in its name (at 20:00 pm).png'
+          )
+          uid = @data_store.store(temp_object)
+          uid.should =~ /A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/
+          data, extra = @data_store.retrieve(uid)
+          data.should == 'eggheads'
+        end
       end
+    
     end
+
   end
 
-end
+end

data/spec/dragonfly/deprecation_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Deprecated stuff" do
+
+  describe "job urls" do
+    
+    before(:each) do
+      @app = test_app.configure_with(:rmagick) do |c|
+        c.log = Logger.new($stdout)
+      end
+      @job = @app.fetch('eggs')
+    end
+    
+    it { @job.url(:gif).should == @job.gif.url }
+    it { @job.url('20x20').should == @job.thumb('20x20').url }
+    it { @job.url('20x20', :gif).should == @job.thumb('20x20', :gif).url }
+
+  end
+
+end

data/spec/dragonfly/function_manager_spec.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def have_keys(*keys)
+  simple_matcher("have keys #{keys.join(', ')}") do |given|
+    given.keys.map{|sym| sym.to_s }.sort == keys.map{|sym| sym.to_s }.sort
+  end
+end
+
+describe Dragonfly::FunctionManager do
+  
+  before(:each) do
+    @fm = Dragonfly::FunctionManager.new
+  end
+
+  describe "registering functions" do
+    
+    describe "registering procs" do
+
+      let(:func){ proc{ "HELLO" } }
+    
+      it "should allow registering procs" do
+        @fm.add :hello, func
+        @fm.functions.should == {:hello => [func]}
+      end
+    
+      it "should allow registering using block syntax" do
+        @fm.add(:hello, &func)
+        @fm.functions.should == {:hello => [func]}
+      end
+
+    end
+
+    describe "registering classes" do
+
+      before(:each) do
+        @class = Class.new do
+          def doogie(buff)
+            "eggheads #{buff}"
+          end
+          def bumfries(smarmey)
+            "sharkboy"
+          end
+        end
+        @fm.register(@class)
+      end
+
+      it "should add the methods" do
+        @fm.functions.should have_keys(:doogie, :bumfries)
+      end
+      
+      it "should record the registered object" do
+        @fm.objects.length.should eql(1)
+        @fm.objects.first.should be_a(@class)
+      end
+      
+      it "should work when calling" do
+        @fm.call_last(:doogie, 3).should == "eggheads 3"
+      end
+      
+      it "should return the object when registering" do
+        @fm.register(@class).should be_a(@class)
+      end
+
+    end
+    
+  end
+
+  describe "configuring on registration" do
+    
+    before(:each) do
+      @class = Class.new do
+        include Dragonfly::Configurable
+        configurable_attr :height, 183
+        def initialize(age=6)
+          @age = age
+        end
+        def height_and_age
+          [height, @age]
+        end
+      end
+      @fm.register(@class)
+    end
+
+    it "should pass the args on register to the object initializer" do
+      @fm.register(@class, 43)
+      @fm.call_last(:height_and_age).should == [183, 43]
+    end
+    
+    it "should run configure if a block given" do
+      @fm.register(@class){|c| c.height = 180 }
+      @fm.call_last(:height_and_age).should == [180, 6]
+    end
+    
+    it "should not include configurable methods in the functions" do
+      @fm.functions.keys.should == [:height_and_age]
+    end
+  end
+
+  describe "calling" do
+
+    describe "errors" do
+      it "should raise an error for call_last if the function doesn't exist" do
+        lambda{
+          @fm.call_last(:i_dont_exist)
+        }.should raise_error(Dragonfly::FunctionManager::NotDefined)
+      end
+      
+      it "should raise an error if the function is defined but unable to handle" do
+        @fm.add(:chicken){ throw :unable_to_handle }
+        lambda{
+          @fm.call_last(:chicken)
+        }.should raise_error(Dragonfly::FunctionManager::UnableToHandle)
+      end
+    end
+
+    describe "simple" do
+      it "should correctly call a registered block" do
+        @fm.add(:egg){|num| num + 1 }
+        @fm.call_last(:egg, 4).should == 5
+      end
+      it "should correctly call a registered class" do
+        klass = Class.new do
+          def dog(num)
+            num * 2
+          end
+        end
+        @fm.register(klass)
+        @fm.call_last(:dog, 4).should == 8
+      end
+      it "should correctly call an object that responds to 'call'" do
+        obj = Object.new
+        def obj.call(num); num - 3; end
+        @fm.add(:spoon, obj)
+        @fm.call_last(:spoon, 4).should == 1
+      end
+    end
+
+    describe "with more than one implementation of same function" do
+      it "should use the last registered" do
+        @fm.add(:bingo){|num| num + 1 }
+        @fm.add(:bingo){|num| num - 1 }
+        @fm.call_last(:bingo, 4).should == 3
+      end
+      
+      it "should skip methods that throw :unable_to_handle" do
+        @fm.add(:bingo){|num| num + 1 }
+        @fm.add(:bingo){|num| throw :unable_to_handle }
+        @fm.call_last(:bingo, 4).should == 5
+      end
+    end
+
+  end
+
+end