fog-dragonfly 0.8.1

data/spec/dragonfly/active_model_extensions/spec_helper.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+begin
+  require 'active_model'
+rescue LoadError => e
+  # When there's NO active_model
+  require File.dirname(__FILE__) + '/active_record_setup'
+else
+  # When there IS active model
+  require File.dirname(__FILE__) + '/active_model_setup'
+end

data/spec/dragonfly/analyser_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::Analyser do
+  
+  before(:each) do
+    @analyser = Dragonfly::Analyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+  
+  describe "analysis_methods module" do
+    
+    before(:each) do
+      @analyser.add(:num_letters){|temp_object, letter| temp_object.data.count(letter) }
+      @obj = Object.new
+      @obj.extend @analyser.analysis_methods
+    end
+    
+    it "should return a module" do
+      @analyser.analysis_methods.should be_a(Module)
+    end
+    
+    it "should provide the object with the analyser method" do
+      @obj.analyser.should == @analyser
+    end
+    
+    it "should provide the object with the direct analysis method, provided that analyse method exists" do
+      def @obj.analyse(meth, *args)
+        analyser.analyse Dragonfly::TempObject.new('HELLO'), meth, *args
+      end
+      @obj.num_letters('L').should == 2
+    end
+    
+  end
+  
+  describe "analyse" do
+    it "should return nil if the function isn't defined" do
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+    it "should return nil if the function can't be handled" do
+      @analyser.add(:width){ throw :unable_to_handle }
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+  end
+  
+  describe "analysis_method_names" do
+    it "should return the analysis methods" do
+      @analyser.add(:width){}
+      @analyser.add(:height){}
+      @analyser.analysis_method_names.should == [:width, :height]
+    end
+  end
+  
+  describe "cache" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('HELLO')
+    end
+
+    def it_should_analyse_using(meth, temp_object, *args)
+      result = mock('result')
+      @analyser.should_receive(:call_last).with(meth, temp_object, *args).exactly(:once).and_return result
+      @analyser.analyse(temp_object, meth, *args).should == result
+      result
+    end
+
+    it "should do the analysis the first time" do
+      it_should_analyse_using(:blah, @temp_object, :arg1)
+    end
+
+    describe "when already called" do
+      before(:each) do
+        @result = it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not do it subsequent times but still return the result" do
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+      end
+      
+      it "should not use the cache if the temp_object is different" do
+        temp_object = Dragonfly::TempObject.new('aaa')
+        it_should_analyse_using(:blah, temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the method name is different" do
+        it_should_analyse_using(:egghead, @temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the args are different" do
+        it_should_analyse_using(:blah, @temp_object, :arg2)
+      end
+      
+      it "should do it again if the cache has been cleared" do
+        @analyser.clear_cache!
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not use the cache if it has been turned off" do
+        @analyser.enable_cache = false
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+      
+    end
+
+    describe "cache size" do
+      it "should not exceed the cache size" do
+        @analyser.cache_size = 2
+
+        res1 = it_should_analyse_using(:blah, @temp_object, :arg1)
+        res2 = it_should_analyse_using(:blah, @temp_object, :arg2)
+        res3 = it_should_analyse_using(:blah, @temp_object, :arg3) # Should kick out first one
+        
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+
+        # Third analysis should still be cached
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg3).should == res3
+      end
+    end
+
+  end
+  
+end

data/spec/dragonfly/analysis/file_command_analyser_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+png_path = File.dirname(__FILE__) + '/../../../samples/egg.png'
+
+describe Dragonfly::Analysis::FileCommandAnalyser do
+  
+  before(:each) do
+    @analyser = Dragonfly::Analysis::FileCommandAnalyser.new
+  end
+  
+  describe "mime_type" do
+    
+    describe "when using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = true
+        @temp_object = Dragonfly::TempObject.new(File.new(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the data string" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@data}.should be_nil
+      end
+    end
+    
+    describe "when not using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = false
+        @temp_object = Dragonfly::TempObject.new(File.read(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the file" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@tempfile}.should be_nil
+      end
+      
+      {
+        :jpg => 'image/jpeg',
+        :png => 'image/png',
+        :gif => 'image/gif',
+        :tif => 'image/tiff'
+      }.each do |format, mime_type|
+        it "should work properly (without a broken pipe error) for big files of format #{format}" do
+          data = Dragonfly::Generation::RMagickGenerator.new.plasma(1000, 1000, format).first
+          temp_object = Dragonfly::TempObject.new(data)
+          @analyser.mime_type(temp_object).should == mime_type
+        end
+      end
+      
+    end
+  
+  end
+  
+end

data/spec/dragonfly/analysis/image_magick_analyser_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'dragonfly/analysis/shared_analyser_spec'
+
+describe Dragonfly::Analysis::ImageMagickAnalyser do
+  
+  before(:each) do
+    image_path = File.dirname(__FILE__) + '/../../../samples/beach.png'
+    @image = Dragonfly::TempObject.new(File.new(image_path))
+    @analyser = Dragonfly::Analysis::ImageMagickAnalyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+
+  it_should_behave_like "image analyser methods"
+
+end

data/spec/dragonfly/analysis/r_magick_analyser_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'dragonfly/analysis/shared_analyser_spec'
+
+describe Dragonfly::Analysis::RMagickAnalyser do
+  
+  before(:each) do
+    image_path = File.dirname(__FILE__) + '/../../../samples/beach.png'
+    @image = Dragonfly::TempObject.new(File.new(image_path))
+    @analyser = Dragonfly::Analysis::RMagickAnalyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+  
+  describe "when using the filesystem" do
+    before(:each) do
+      @analyser.use_filesystem = true
+    end
+    it_should_behave_like "image analyser methods"
+  end
+  
+  describe "when not using the filesystem" do
+    before(:each) do
+      @analyser.use_filesystem = false
+    end
+    it_should_behave_like "image analyser methods"
+  end
+  
+end

data/spec/dragonfly/analysis/shared_analyser_spec.rb

@@ -0,0 +1,51 @@
+# NEEDS:
+#
+# @image
+# @processor
+#
+describe "image analyser methods", :shared => true do
+  
+  it "should return the width" do
+    @analyser.width(@image).should == 280
+  end
+
+  it "should return the height" do
+    @analyser.height(@image).should == 355
+  end
+
+  it "should return the aspect ratio" do
+    @analyser.aspect_ratio(@image).should == (280.0/355.0)
+  end
+
+  it "should say if it's portrait" do
+    @analyser.portrait?(@image).should be_true
+  end
+
+  it "should say if it's landscape" do
+    @analyser.landscape?(@image).should be_false
+  end
+
+  it "should return the number of colours" do
+    @analyser.number_of_colours(@image).should == 34703
+  end
+
+  it "should return the depth" do
+    @analyser.depth(@image).should == 8
+  end
+
+  it "should return the format" do
+    @analyser.format(@image).should == :png
+  end
+
+  %w(width height aspect_ratio number_of_colours depth format portrait? landscape?).each do |meth|
+    it "should throw unable_to_handle in #{meth.inspect} if it's not an image file" do
+      suppressing_stderr do
+        temp_object = Dragonfly::TempObject.new('blah')
+        lambda{
+          @analyser.send(meth, temp_object)
+        }.should throw_symbol(:unable_to_handle)
+      end
+    end
+  end
+
+end

data/spec/dragonfly/app_spec.rb

@@ -0,0 +1,280 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rack/mock'
+
+def request(app, path)
+  Rack::MockRequest.new(app).get(path)
+end
+
+describe Dragonfly::App do
+
+  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[: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 "mime types" do
+    describe "#mime_type_for" do
+      before(:each) do
+        @app = test_app
+      end
+      it "should return the correct mime type for a symbol" do
+        @app.mime_type_for(:png).should == 'image/png'
+      end
+      it "should work for strings" do
+        @app.mime_type_for('png').should == 'image/png'
+      end
+      it "should work with uppercase strings" do
+        @app.mime_type_for('PNG').should == 'image/png'
+      end
+      it "should work with a dot" do
+        @app.mime_type_for('.png').should == 'image/png'
+      end
+      it "should return nil if not known" do
+        @app.mime_type_for(:mark).should be_nil
+      end
+      it "should allow for configuring extra mime types" do
+        @app.register_mime_type 'mark', 'application/mark'
+        @app.mime_type_for(:mark).should == 'application/mark'
+      end
+      it "should override existing mime types when registered" do
+        @app.register_mime_type :png, 'ping/pong'
+        @app.mime_type_for(:png).should == 'ping/pong'
+      end
+      it "should have a per-app mime-type configuration" do
+        other_app = Dragonfly[:other_app]
+        @app.register_mime_type(:mark, 'first/one')
+        other_app.register_mime_type(:mark, 'second/one')
+        @app.mime_type_for(:mark).should == 'first/one'
+        other_app.mime_type_for(:mark).should == 'second/one'
+      end
+    end
+
+    describe "#resolve_mime_type" do
+      before(:each) do
+        @app = test_app
+        @app.analyser.add :format do |temp_object|
+          :png
+        end
+        @app.analyser.add :mime_type do |temp_object|
+          'image/jpeg'
+        end
+        @app.encoder.add do |temp_object|
+          'ENCODED DATA YO'
+        end
+      end
+
+      it "should return the correct mime_type if the temp_object has a format" do
+        temp_object = Dragonfly::TempObject.new("HIMATE", :format => :tiff, :name => 'test.pdf')
+        @app.resolve_mime_type(temp_object).should == 'image/tiff'
+      end
+
+      it "should use the file extension if it has no format" do
+        temp_object = Dragonfly::TempObject.new("HIMATE", :name => 'test.pdf')
+        @app.resolve_mime_type(temp_object).should == 'application/pdf'
+      end
+
+      it "should not use the file extension if it's been switched off (fall back to mime_type analyser)" do
+        @app.infer_mime_type_from_file_ext = false
+        temp_object = Dragonfly::TempObject.new("HIMATE", :name => 'test.pdf')
+        @app.resolve_mime_type(temp_object).should == 'image/jpeg'
+      end
+
+      it "should fall back to the mime_type analyser if the temp_object has no ext" do
+        temp_object = Dragonfly::TempObject.new("HIMATE", :name => 'test')
+        @app.resolve_mime_type(temp_object).should == 'image/jpeg'
+      end
+
+      describe "when the temp_object has no name" do
+
+        before(:each) do
+          @temp_object = Dragonfly::TempObject.new("HIMATE")
+        end
+
+        it "should fall back to the mime_type analyser" do
+          @app.resolve_mime_type(@temp_object).should == 'image/jpeg'
+        end
+
+        it "should fall back to the format analyser if the mime_type analyser doesn't exist" do
+          @app.analyser.functions.delete(:mime_type)
+          @app.resolve_mime_type(@temp_object).should == 'image/png'
+        end
+
+        it "should fall back to the app's fallback mime_type if no mime_type/format analyser exists" do
+          @app.analyser.functions.delete(:mime_type)
+          @app.analyser.functions.delete(:format)
+          @app.resolve_mime_type(@temp_object).should == 'application/octet-stream'
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "without path prefix or DOS protection" do
+    before(:each) do
+      @app = test_app
+      @job = Dragonfly::Job.new(@app).fetch('some_uid')
+      @app.datastore.stub!(:retrieve).with('some_uid').and_return "Hi there"
+      @app.configure{|c| c.protect_from_dos_attacks = false }
+    end
+    it "should correctly respond with the job data" do
+      response = request(@app, "/#{@job.serialize}")
+      response.status.should == 200
+      response.body.should == "Hi there"
+    end
+    it "should generate the correct url" do
+      @app.url_for(@job).should == "/#{@job.serialize}"
+    end
+  end
+
+  describe "url_path_prefix" do
+    before(:each) do
+      @app = test_app
+      @job = Dragonfly::Job.new(@app)
+    end
+    it "should add the path prefix to the url if configured" do
+      @app.url_path_prefix = '/media'
+      @app.url_for(@job).should =~ %r{^/media/\w+$}
+    end
+    it "should add the path prefix to the url if passed in" do
+      @app.url_for(@job, :path_prefix => '/eggs').should =~ %r{^/eggs/\w+$}
+    end
+    it "should favour the passed in one" do
+      @app.url_path_prefix = '/media'
+      @app.url_for(@job, :path_prefix => '/bacon').should =~ %r{^/bacon/\w+$}
+    end
+  end
+
+  describe "url_host" do
+    before(:each) do
+      @app = test_app
+      @job = Dragonfly::Job.new(@app)
+    end
+    it "should add the host to the url if configured" do
+      @app.url_host = 'http://some.server:4000'
+      @app.url_for(@job).should =~ %r{^http://some\.server:4000/\w+$}
+    end
+    it "should add the host to the url if passed in" do
+      @app.url_for(@job, :host => 'https://bungle.com').should =~ %r{^https://bungle\.com/\w+$}
+    end
+    it "should favour the passed in one" do
+      @app.url_host = 'http://some.server:4000'
+      @app.url_for(@job, :host => 'https://smeedy').should =~ %r{^https://smeedy/\w+$}
+    end
+  end
+
+  describe "url_suffix" do
+    before(:each) do
+      @app = test_app
+      @job = Dragonfly::Job.new(@app)
+    end
+    it "should add the suffix to the url if configured" do
+      @app.url_suffix = 'hellodudes'
+      @app.url_for(@job).should =~ /\w+hellodudes$/
+    end
+    it "should add the suffix to the url if passed in" do
+      @app.url_for(@job, :suffix => '/howdy.pardner').should =~ /\w+\/howdy\.pardner$/
+    end
+    it "should favour the passed in one" do
+      @app.url_suffix = 'hellodudes'
+      @app.url_for(@job, :suffix => '/howdy.pardner').should =~ /\w+\/howdy\.pardner$/
+    end
+    it "should accept a proc yielding the job" do
+      @app.url_suffix = proc{|job| job.uid }
+      @job.fetch!('some_uid')
+      @app.url_for(@job).should =~ /\w+some_uid$/
+    end
+  end
+  
+  describe "url params" do
+    before(:each) do
+      @app = test_app
+      @job = Dragonfly::Job.new(@app)
+    end
+    it "should add extra params to the url query string" do
+      @app.url_for(@job, :suffix => '/suffix', :a => 'thing', :b => 'nuther').should =~ /\w+\/suffix\?a=thing&b=nuther$/
+    end
+  end
+
+  describe "Denial of Service protection" do
+    before(:each) do
+      @app = test_app
+      @app.protect_from_dos_attacks = true
+      @job = Dragonfly::Job.new(@app).fetch('some_uid')
+    end
+    it "should generate the correct url" do
+      @app.url_for(@job).should == "/#{@job.serialize}?s=#{@job.sha}"
+    end
+  end
+
+  describe "configuring with saved configurations" do
+    before(:each) do
+      @app = test_app
+    end
+
+    {
+      :imagemagick => Dragonfly::Config::ImageMagick,
+      :image_magick => Dragonfly::Config::ImageMagick,
+      :rmagick => Dragonfly::Config::RMagick,
+      :r_magick => Dragonfly::Config::RMagick,
+      :rails => Dragonfly::Config::Rails,
+      :heroku => Dragonfly::Config::Heroku,
+    }.each do |key, klass|
+      it "should map #{key} to #{klass}" do
+        klass.should_receive(:apply_configuration).with(@app)
+        @app.configure_with(key)
+      end
+    end
+
+    it "should description" do
+      lambda {
+        @app.configure_with(:eggs)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#store" do
+    before(:each) do
+      @app = test_app
+    end
+    it "should allow just storing content" do
+      @app.datastore.should_receive(:store).with(a_temp_object_with_data("HELLO"), {})
+      @app.store("HELLO")
+    end
+    it "should allow storing using a TempObject" do
+      temp_object = Dragonfly::TempObject.new("HELLO")
+      @app.datastore.should_receive(:store).with(temp_object, {})
+      @app.store(temp_object)
+    end
+    it "should allow storing with extra stuff" do
+      @app.datastore.should_receive(:store).with(
+        a_temp_object_with_data("HELLO", :meta => {:egg => :head}),
+        {:option => :blarney}
+      )
+      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+    end
+  end
+
+end