fog-dragonfly 0.8.1

data/spec/dragonfly/config/r_magick_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Dragonfly::Config::RMagick do
+
+  before(:each) do
+    @app = test_app
+  end
+
+  it "should configure all to use the filesystem by default" do
+    @app.configure_with(Dragonfly::Config::RMagick)
+    @app.analyser.get_registered(Dragonfly::Analysis::RMagickAnalyser).use_filesystem.should be_true
+    @app.processor.get_registered(Dragonfly::Processing::RMagickProcessor).use_filesystem.should be_true
+    @app.encoder.get_registered(Dragonfly::Encoding::RMagickEncoder).use_filesystem.should be_true
+    @app.generator.get_registered(Dragonfly::Generation::RMagickGenerator).use_filesystem.should be_true
+  end
+
+  it "should configure all not to use the filesystem if requested" do
+    @app.configure_with(Dragonfly::Config::RMagick, :use_filesystem => false)
+    @app.analyser.get_registered(Dragonfly::Analysis::RMagickAnalyser).use_filesystem.should be_false
+    @app.processor.get_registered(Dragonfly::Processing::RMagickProcessor).use_filesystem.should be_false
+    @app.encoder.get_registered(Dragonfly::Encoding::RMagickEncoder).use_filesystem.should be_false
+    @app.generator.get_registered(Dragonfly::Generation::RMagickGenerator).use_filesystem.should be_false
+  end
+
+end

data/spec/dragonfly/configurable_spec.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::Configurable do
+
+  before(:each) do
+    class Car
+      include Dragonfly::Configurable
+      configurable_attr :colour
+      configurable_attr :top_speed, 216
+      def self.other_thing=(thing); end
+    end
+    @car = Car.new
+  end
+
+  describe "setup" do
+    it "should provide attr_readers for configurable attributes" do
+      @car.should respond_to(:colour)
+    end
+
+    it "should provide attr_writers for configurable attributes" do
+      @car.colour = 'verde'
+      @car.colour.should == 'verde'
+    end
+
+    it "should set default values for configurable attributes" do
+      @car.top_speed.should == 216
+    end
+
+    it "should set the default as nil if not specified" do
+      @car.colour.should be_nil
+    end
+    
+    it "should allow specifying configurable attrs as strings" do
+      class Bike
+        include Dragonfly::Configurable
+        configurable_attr 'colour', 'rude'
+      end
+      Bike.new.colour.should == 'rude'
+    end
+  end
+
+  describe "configuring" do    
+    it "should allow you to change values" do
+      @car.configure do |c|
+        c.colour = 'red'
+      end
+      @car.colour.should == 'red'
+    end
+    
+    it "should not allow you to call other methods on the object via the configuration" do
+      lambda{
+        @car.configure do |c|
+          c.other_thing = 5
+        end
+      }.should raise_error(Dragonfly::Configurable::BadConfigAttribute)
+    end
+    
+    it "should return itself" do
+      @car.configure{|c|}.should == @car
+    end
+  end
+  
+  describe "getting configuration" do
+    it "should return the configuration as a hash" do
+      @car.configuration.should == {:colour => nil, :top_speed => 216}
+    end
+    it "should not allow you to change the configuration via the hash" do
+      @car.configuration[:top_speed] = 555
+      @car.top_speed.should == 216
+    end
+  end
+  
+  describe "multiple objects" do
+    it "should return the default configuration" do
+      Car.default_configuration.should == {:colour => nil, :top_speed => 216}
+    end
+    it "should allow instances to be configured differently" do
+      car1 = Car.new
+      car1.configure{|c| c.colour = 'green'}
+      car2 = Car.new
+      car2.configure{|c| c.colour = 'yellow'}
+      car1.configuration.should == {:colour => 'green', :top_speed => 216}
+      car2.configuration.should == {:colour => 'yellow', :top_speed => 216}
+    end
+  end
+  
+  describe "lazy attributes" do
+    before(:each) do
+      cow = @cow = mock('cow')
+      class Lazy; end
+      Lazy.class_eval do
+        include Dragonfly::Configurable
+        configurable_attr(:sound){ cow.moo }
+      end
+      @lazy = Lazy.new
+    end
+    it "should not call the block if the configurable attribute is set to something else" do
+      @cow.should_not_receive(:moo)
+      @lazy.configure{|c| c.sound = 'baa' }
+      @lazy.sound.should == 'baa'
+    end
+    it "should call the block if it's not been changed, once it's accessed" do
+      @cow.should_receive(:moo).and_return('mooo!')
+      @lazy.sound.should == 'mooo!'
+    end
+    it "should not call the block when accessed again" do
+      @cow.should_receive(:moo).exactly(:once).and_return('mooo!')
+      @lazy.sound.should == 'mooo!'
+      @lazy.sound.should == 'mooo!'
+    end
+    it "should not call an explicitly passed in proc" do
+      @lazy.configure{|c| c.sound = lambda{ @cow.fart }}
+      @lazy.sound.should be_a(Proc)
+    end
+  end
+  
+  describe "using in the singleton class" do
+    it "should work" do
+      class OneOff
+        class << self
+          include Dragonfly::Configurable
+          configurable_attr :food, 'bread'
+        end
+      end
+      OneOff.food.should == 'bread'
+    end
+  end
+  
+  describe "configuration method" do
+    
+    before(:each) do
+      class ClassWithMethod
+        include Dragonfly::Configurable
+        def add_thing(thing)
+          'poo'
+        end
+        def remove_thing(thing)
+          'bum'
+        end
+        configuration_method :add_thing, :remove_thing
+      end
+      @thing = ClassWithMethod.new
+    end
+    
+    it "should allow calling the method through 'configure'" do
+      @thing.configure do |c|
+        c.add_thing('duck')
+        c.remove_thing('dog')
+      end
+    end
+    
+  end
+  
+  describe "nested configurable objects" do
+
+    it "should allow configuring nested configurable objects" do
+
+      class NestedThing
+        include Dragonfly::Configurable
+        configurable_attr :age, 29
+      end
+
+      class Car
+        def nested_thing
+          @nested_thing ||= NestedThing.new
+        end
+      end
+
+      @car.configure do |c|
+        c.nested_thing.configure do |nt|
+          nt.age = 50
+        end
+      end
+
+      @car.nested_thing.age.should == 50
+
+    end
+
+  end
+  
+  describe "configuring with a configurer" do
+    before(:each) do
+      @cool_configuration = Object.new
+      def @cool_configuration.apply_configuration(car, colour=nil)
+        car.configure do |c|
+          c.colour = (colour || 'vermelho')
+        end
+      end
+    end
+    
+    it "should allow configuration by a configurer" do
+      @car.configure_with(@cool_configuration)
+      @car.colour.should == 'vermelho'
+      @car.top_speed.should == 216
+    end
+    
+    it "should pass any args through to the configurer" do
+      @car.configure_with(@cool_configuration, 'preto')
+      @car.colour.should == 'preto'
+    end
+    
+    it "should yield a block for any extra configuration" do
+      @car.configure_with(@cool_configuration) do |c|
+        c.colour = 'branco'
+      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/core_ext/string_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe String do
+  
+  describe "to_method_name" do
+    if RUBY_VERSION =~ /^1.8/
+      it "should return a string" do
+        'hello'.to_method_name.should == 'hello'
+      end
+    else
+      it "should return a symbol" do
+        'hello'.to_method_name.should == :hello
+      end
+    end
+  end
+  
+end

data/spec/dragonfly/core_ext/symbol_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Symbol do
+  
+  describe "to_method_name" do
+    if RUBY_VERSION =~ /^1.8/
+      it "should return a string" do
+        :hello.to_method_name.should == 'hello'
+      end
+    else
+      it "should return a symbol" do
+        :hello.to_method_name.should == :hello
+      end
+    end
+  end
+  
+end

data/spec/dragonfly/data_storage/data_store_spec.rb

@@ -0,0 +1,76 @@
+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
+
+  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)
+    end
+    it "should return a unique identifier for each storage even when the first is deleted" do
+      uid1 = @data_store.store(@temp_object)
+      @data_store.destroy(uid1)
+      uid2 = @data_store.store(@temp_object)
+      uid1.should_not == uid2
+    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
+
+    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
+      lambda{
+        @data_store.retrieve('gooble/gubbub')
+      }.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)
+      lambda{
+        @data_store.retrieve(uid)
+      }.should raise_error(Dragonfly::DataStorage::DataNotFound)
+    end
+
+  end
+
+end

data/spec/dragonfly/data_storage/file_data_store_spec.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+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'
+  end
+  
+  after(:each) do
+    # Clean up created files
+    FileUtils.rm_rf("#{@data_store.root_path}")
+  end
+  
+  it_should_behave_like 'data_store'
+  
+  before(:each) do
+    @temp_object = Dragonfly::TempObject.new('goobydoo')
+  end
+  
+  describe "store" do
+    
+    def it_should_write_to_file(storage_path, temp_object)
+      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/14_28_01_0_'
+      @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)
+      @data_store.store(@temp_object)
+    end
+
+    it "should use the temp_object name if it exists" do
+      @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 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 use a different filename" do
+        touch_file("#{@file_pattern_prefix}file")
+        @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}file").and_return("#{@file_pattern_prefix}file_2")
+        it_should_write_to_file("#{@file_pattern_prefix}file_2", @temp_object)
+        @data_store.store(@temp_object)
+      end
+    
+      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("#{@file_pattern_prefix}hello.png").and_return("#{@file_pattern_prefix}blah.png")
+        @data_store.store(@temp_object)
+      end
+
+      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_pattern_prefix}file").and_return("#{@file_pattern_prefix}file_2")
+        @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}file_2").and_return("#{@file_pattern_prefix}file_3")
+        it_should_write_to_file("#{@file_pattern_prefix}file_3", @temp_object)
+        @data_store.store(@temp_object)
+      end
+
+      describe "specifying the uid" do
+        it "should allow for specifying the path to use" do
+          it_should_write_to_file("#{@data_store.root_path}/hello/there/mate.png", @temp_object)
+          @data_store.store(@temp_object, :path => 'hello/there/mate.png')
+        end
+        it "should correctly disambiguate if the file exists" do
+          touch_file("#{@data_store.root_path}/hello/there/mate.png")
+          @data_store.should_receive(:disambiguate).with("#{@data_store.root_path}/hello/there/mate.png").and_return("#{@data_store.root_path}/hello/there/mate_2.png")
+          it_should_write_to_file("#{@data_store.root_path}/hello/there/mate_2.png", @temp_object)
+          @data_store.store(@temp_object, :path => 'hello/there/mate.png')
+        end
+      end
+
+    end
+
+    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"
+      end
+    
+      it "should return the filepath without the root of the stored file when a file name is provided" do
+        @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('/some/file').should =~ %r{^/some/file_\w+$}
+    end
+    it "should add a suffix to the basename" do
+      @data_store.disambiguate('/some/file.png').should =~ %r{^/some/file_\w+\.png$}
+    end
+    it "should be random(-ish)" do
+      @data_store.disambiguate('/some/file').should_not == @data_store.disambiguate('/some/file')
+    end
+  end
+  
+  describe "errors" do
+
+    it "should raise an error if it can't create a directory" do
+      FileUtils.should_receive(:mkdir_p).and_raise(Errno::EACCES)
+      lambda{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::DataStorage::UnableToStore)
+    end
+  
+    it "should raise an error if it can't create a file" do
+      @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 return a closed file" do
+      uid = @data_store.store(@temp_object)
+      file, extra = @data_store.retrieve(uid)
+      file.should be_closed
+    end
+    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(file.path).should == 'hey dog'
+      meta.should == {}
+    end
+  end
+  
+  describe "destroying" do
+
+    it "should raise an error if the data doesn't exist" do
+      lambda{
+        @data_store.destroy('gooble/gubbub')
+      }.should raise_error(Dragonfly::DataStorage::DataNotFound)
+    end
+
+    it "should prune empty directories when destroying" do
+      uid = @data_store.store(@temp_object)
+      @data_store.destroy(uid)
+      @data_store.root_path.should be_an_empty_directory
+    end
+
+  end
+
+end