dragonfly 0.1.0

data/spec/dragonfly/app_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rack/mock'
+
+describe Dragonfly::App do
+
+  def make_request(app, url)
+    Rack::MockRequest.new(app).get(url)
+  end
+
+  describe ".instance" do
+    
+    it "should create a new instance if it didn't already exist" do
+      app = Dragonfly::App.instance(:images)
+      app.should be_a(Dragonfly::App)
+    end
+    
+    it "should return an existing instance if called by name" do
+      app = Dragonfly::App.instance(:images)
+      Dragonfly::App.instance(:images).should == app
+    end
+    
+    it "should also work using square brackets" do
+      Dragonfly::App[:images].should == Dragonfly::App.instance(:images)
+    end
+    
+  end
+  
+  describe ".new" do
+    it "should not be callable" do
+      lambda{
+        Dragonfly::App.new
+      }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe "errors" do
+
+    before(:each) do
+      @app = Dragonfly::App[:images]
+    end
+
+    it "should return 400 if UrlHandler::IncorrectSHA is raised" do
+      @app.url_handler.should_receive(:url_to_parameters).and_raise(Dragonfly::UrlHandler::IncorrectSHA)
+      response = make_request(@app, '/some_uid.png?s=sadfas')
+      response.status.should == 400
+    end
+    
+    it "should return 400 if UrlHandler::SHANotGiven is raised" do
+      @app.url_handler.should_receive(:url_to_parameters).and_raise(Dragonfly::UrlHandler::SHANotGiven)
+      response = make_request(@app, '/some_uid.png?s=asdfghsg')
+      response.status.should == 400
+    end
+    
+    it "should return 404 if url handler raises an unknown url exception" do
+      @app.url_handler.should_receive(:url_to_parameters).and_raise(Dragonfly::UrlHandler::UnknownUrl)
+      response = make_request(@app, '/')
+      response.status.should == 404
+    end
+
+    it "should return 404 if the datastore raises data not found" do
+      @app.url_handler.protect_from_dos_attacks = false
+      @app.should_receive(:fetch).and_raise(Dragonfly::DataStorage::DataNotFound)
+      response = make_request(@app, 'hello.png')
+      response.status.should == 404
+    end
+
+  end
+
+end

data/spec/dragonfly/configurable_spec.rb

@@ -0,0 +1,193 @@
+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
+  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 also call a block which has been set as part of the configuration" do
+      @cow.should_receive(:fart).exactly(:once).and_return('paaarrp!')
+      @lazy.configure{|c| c.sound = lambda{ @cow.fart }}
+      @lazy.sound.should == 'paaarrp!'
+      @lazy.sound.should == 'paaarrp!'
+    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 do |nt|
+          nt.age = 50
+        end
+      end
+
+      @car.nested_thing.age.should == 50
+
+    end
+
+  end
+  
+  describe "configuring with a configurer" do
+    it "should allow configuration by a configurer" do
+      cool_configuration = Object.new
+      def cool_configuration.apply_configuration(car)
+        car.configure do |c|
+          c.colour = 'vermelho'
+        end
+      end
+      @car.configure_with(cool_configuration)
+      @car.colour.should == 'vermelho'
+      @car.top_speed.should == 216
+    end
+  end
+  
+end

data/spec/dragonfly/data_storage/data_store_spec.rb

@@ -0,0 +1,47 @@
+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
+      @data_store.store(@temp_object).should_not == @data_store.store(@temp_object)
+    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
+    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
+    
+    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
+  end
+
+end

data/spec/dragonfly/data_storage/file_data_store_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/data_store_spec'
+
+describe Dragonfly::DataStorage::FileDataStore do
+  
+  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")
+  end
+  
+  it_should_behave_like 'data_store'
+  
+  describe "store" do
+    
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('goobydoo')
+    end
+    
+    def it_should_write_to_file(storage_path, temp_object)
+      FileUtils.should_receive(:cp).with(temp_object.path, storage_path)
+    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 store the file with a numbered suffix if the filename already exists" 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)
+      @data_store.store(@temp_object)
+    end
+    
+    it "should store the file with an incremented number suffix if the filename already exists" 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)
+      @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 use the basename (all but part after last dot) of the temp_object name if it exists" do
+      @temp_object.name = 'hello.you.png'
+      it_should_write_to_file("#{@file_pattern_prefix}_hello.you", @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)
+      @data_store.store(@temp_object)
+    end
+
+    it "should return the filepath without the root of the stored file" do
+      @data_store.store(@temp_object).should == "#{@file_pattern_prefix_without_root}_file"
+    end
+    
+    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
+      FileUtils.should_receive(:cp).and_raise(Errno::EACCES)
+      lambda{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::DataStorage::UnableToStore)
+    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

data/spec/dragonfly/extended_temp_object_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::ExtendedTempObject do
+  
+  it "should raise an error if not configured with an app" do
+    temp_object = Dragonfly::ExtendedTempObject.new('asdf')
+    lambda{
+      temp_object.process(:dummy)
+    }.should raise_error(Dragonfly::ExtendedTempObject::NotConfiguredError)
+  end
+  
+  describe "when configured correctly" do
+    
+    before(:each) do
+      @analyser = mock('analyser', :has_analysis_method? => false)
+      @analyser.stub!(:has_analysis_method?).with(:width).and_return(true)
+      @processor = mock('processor')
+      @encoder = mock('encoder')
+      @app = mock('app', :analyser => @analyser, :processor => @processor, :encoder => @encoder)
+      @klass = Class.new(Dragonfly::ExtendedTempObject)
+      @klass.app = @app
+      @object = @klass.new('asdf')
+    end
+    
+    describe "analysis" do
+      
+      it "should respond to something that the analyser responds to" do
+        @analyser.should_receive(:has_analysis_method?).with(:some_method).and_return(true)
+        @object.should respond_to(:some_method)
+      end
+      
+      it "should not respond to something that the analyser doesn't respond to" do
+        @analyser.should_receive(:has_analysis_method?).with(:some_method).and_return(false)
+        @object.should_not respond_to(:some_method)
+      end
+
+      it "should delegate the analysis to the analyser" do
+        @analyser.should_receive(:width).with(@object).and_return(4)
+        @object.width.should == 4
+      end
+      
+      it "should cache the result so that it doesn't call it a second time" do
+        @analyser.should_receive(:width).with(@object).and_return(4)
+        @object.width.should == 4
+
+        @analyser.should_not_receive(:width)
+        @object.width.should == 4
+      end
+      
+      it "should do the analysis again when it has been modified" do
+        @analyser.should_receive(:width).with(@object).and_return(4)
+        @object.width.should == 4
+        
+        @object.modify_self!('hellothisisnew')
+        
+        @analyser.should_receive(:width).with(@object).and_return(17)
+        @object.width.should == 17
+        
+        @analyser.should_not_receive(:width)
+        @object.width.should == 17
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/dragonfly/middleware_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rack'
+
+describe Dragonfly::Middleware do
+  
+  def make_request(app, url)
+    Rack::MockRequest.new(app).get(url)
+  end
+  
+  before(:each) do
+    @stack = Rack::Builder.new do
+      use Dragonfly::Middleware, :images
+      run lambda{|env| [200, {"Content-Type" => "text/html"}, ["#{env['PATH_INFO']}, #{env['QUERY_STRING']}"]] }
+    end
+  end
+  
+  it "should continue the calling chain if the app returns a 404 for that url" do
+    Dragonfly::App[:images].should_receive(:call).and_return(
+      [404, {"Content-Type" => 'text/plain'}, ['Not found']]
+    )
+    response = make_request(@stack, 'hello.png?howare=you')
+    response.status.should == 200
+    response.body.should == 'hello.png, howare=you'
+  end
+  
+  it "should return as per the dragonfly app if the app returns a 200" do
+    Dragonfly::App[:images].should_receive(:call).and_return(
+      [200, {"Content-Type" => 'text/plain'}, ['ABCD']]
+    )
+    response = make_request(@stack, 'hello.png?howare=you')
+    response.status.should == 200
+    response.body.should == 'ABCD'
+  end
+  
+  it "should return as per the dragonfly app if the app returns a 400" do
+    Dragonfly::App[:images].should_receive(:call).and_return(
+      [400, {"Content-Type" => 'text/plain'}, ['ABCD']]
+    )
+    response = make_request(@stack, 'hello.png?howare=you')
+    response.status.should == 400
+    response.body.should == 'ABCD'
+  end
+  
+end