dragonfly 0.6.2 → 0.7.0

data/spec/dragonfly/loggable_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Testoast
+  include Dragonfly::Loggable
+end
+
+describe Dragonfly::Loggable do
+  
+  before(:each) do
+    @object = Testoast.new
+  end
+
+  describe "common", :shared => true do
+    it "should return a log" do
+      @object.log.should be_a(Logger)
+    end
+    it "should cache the log" do
+      @object.log.should == @object.log
+    end
+  end
+
+  describe "without being set" do
+    it "should return the log object as nil" do
+      @object.log_object.should be_nil
+    end
+    it_should_behave_like 'common'
+  end
+
+  describe "when set" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @object.log = @log
+    end
+    it "should return the new log" do
+      @object.log.should == @log
+    end
+    it "should return the log object" do
+      @object.log_object.should == @log
+    end
+    it_should_behave_like 'common'
+  end
+
+  describe "when set as a proc" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @object.log = proc{ @log }
+    end
+    it "should return the new log" do
+      @object.log.should == @log
+    end
+    it "should return the log object" do
+      @object.log_object.should be_a(Proc)
+    end
+    it "should allow for changing logs" do
+      logs = [@log]
+      @object.log = proc{ logs[0] }
+      @object.log.should == @log
+      
+      new_log = Logger.new($stdout)
+      logs[0] = new_log
+      
+      @object.log.should == new_log
+    end
+    it_should_behave_like 'common'
+  end
+  
+  describe "sharing logs" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @obj1 = Testoast.new
+      @obj2 = Testoast.new
+    end
+    it "should enable sharing logs" do
+      @obj1.log = proc{ @log }
+      @obj2.use_same_log_as(@obj1)
+      @obj2.log.should == @log
+    end
+  end
+
+end

data/spec/dragonfly/middleware_spec.rb

@@ -13,35 +13,55 @@ describe Dragonfly::Middleware do
 
   before(:each) do
     @stack = Rack::Builder.new do
-      use Dragonfly::Middleware, :images
+      use Dragonfly::Middleware, :images, '/media'
       run dummy_rack_app
     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')
+  it "should pass through for urls with incorrect prefix" do
+    Dragonfly[:images].should_not_receive(:call)
+    response = make_request(@stack, '/hello.png?howare=you')
     response.status.should == 200
     response.body.should == 'dummy_rack_app body'
   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']]
+  it "should pass through if the app returns and X-Cascade: pass" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [404, {"Content-Type" => 'text/plain', 'X-Cascade' => 'pass'}, ['Not found']]
     )
-    response = make_request(@stack, 'hello.png?howare=you')
-    response.status.should == 200
-    response.body.should == 'ABCD'
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.body.should == 'dummy_rack_app body'
   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']]
+  it "should return a 404 if the app returns a 404 for that url but no X-Cascade: pass" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [404, {"Content-Type" => 'text/plain'}, ['Not found']]
     )
-    response = make_request(@stack, 'hello.png?howare=you')
-    response.status.should == 400
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.status.should == 404
+  end
+
+  %w(0.1 0.9 0.10 1.0 1.0.0 1.0.1).each do |version|
+    it "should pass through if the rack version is #{version} (i.e. no X-Cascade: pass) and the app returns 404" do
+      Rack.should_receive(:version).and_return(version)
+      Dragonfly[:images].should_receive(:call).and_return(
+        [404, {"Content-Type" => 'text/plain'}, ['Not found']]
+      )
+      response = make_request(@stack, '/media/hello.png?howare=you')
+      response.status.should == 200
+      response.body.should == 'dummy_rack_app body'
+    end
+  end
+
+  %w(1.1 1.1.1 2.9).each do |version|
+  end
+
+  it "should return as per the dragonfly app if the app returns a 200" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [200, {"Content-Type" => 'text/plain'}, ['ABCD']]
+    )
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.status.should == 200
     response.body.should == 'ABCD'
   end
   

data/spec/dragonfly/processing/r_magick_processor_spec.rb

@@ -1,201 +1,217 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Dragonfly::Processing::RMagickProcessor do
+
+  before(:each) do
+    sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @processor = Dragonfly::Processing::RMagickProcessor.new
+  end
+
+  describe "resize" do
   
-  describe "generate" do
-    before(:each) do
-      @processor = Dragonfly::Processing::RMagickProcessor.new
+    it "should work correctly with xNN" do
+      image = @processor.resize(@image, 'x30')
+      image.should have_width(24)
+      image.should have_height(30)
     end
-    
-    it "should generate an image with the given dimensions, defaulting to png format" do
-      image = @processor.generate(23,12)
-      image.should have_width(23)
-      image.should have_height(12)
-      image.should have_format('png')
+  
+    it "should work correctly with NNx" do
+      image = @processor.resize(@image, '30x')
+      image.should have_width(30)
+      image.should have_height(38)
     end
-    it "should allow specifying the format" do
-      image = @processor.generate(23, 12, :gif)
-      image.should have_format('gif')
+  
+    it "should work correctly with NNxNN" do
+      image = @processor.resize(@image, '30x30')
+      image.should have_width(24)
+      image.should have_height(30)
     end
-  end
-
-  describe "processing methods" do
   
-    before(:each) do
-      sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
-      @image = Dragonfly::TempObject.new(File.new(sample_file))
-      @processor = Dragonfly::Processing::RMagickProcessor.new
+    it "should work correctly with NNxNN!" do
+      image = @processor.resize(@image, '30x30!')
+      image.should have_width(30)
+      image.should have_height(30)
     end
   
-    describe "resize" do
-    
-      it "should work correctly with xNN" do
-        image = @processor.resize(@image, :geometry => 'x30')
-        image.should have_width(24)
-        image.should have_height(30)
-      end
+    it "should work correctly with NNxNN%" do
+      image = @processor.resize(@image, '25x50%')
+      image.should have_width(70)
+      image.should have_height(178)
+    end
+  
+    describe "NNxNN>" do
     
-      it "should work correctly with NNx" do
-        image = @processor.resize(@image, :geometry => '30x')
-        image.should have_width(30)
-        image.should have_height(38)
+      it "should not resize if the image is smaller than specified" do
+        image = @processor.resize(@image, '1000x1000>')
+        image.should have_width(280)
+        image.should have_height(355)
       end
     
-      it "should work correctly with NNxNN" do
-        image = @processor.resize(@image, :geometry => '30x30')
+      it "should resize if the image is larger than specified" do
+        image = @processor.resize(@image, '30x30>')
         image.should have_width(24)
         image.should have_height(30)
       end
     
-      it "should work correctly with NNxNN!" do
-        image = @processor.resize(@image, :geometry => '30x30!')
-        image.should have_width(30)
-        image.should have_height(30)
-      end
-    
-      it "should work correctly with NNxNN%" do
-        image = @processor.resize(@image, :geometry => '25x50%')
-        image.should have_width(70)
-        image.should have_height(178)
-      end
-    
-      describe "NNxNN>" do
-      
-        it "should not resize if the image is smaller than specified" do
-          image = @processor.resize(@image, :geometry => '1000x1000>')
-          image.should have_width(280)
-          image.should have_height(355)
-        end
-      
-        it "should resize if the image is larger than specified" do
-          image = @processor.resize(@image, :geometry => '30x30>')
-          image.should have_width(24)
-          image.should have_height(30)
-        end
-      
-      end
-    
-      describe "NNxNN<" do
-      
-        it "should not resize if the image is larger than specified" do
-          image = @processor.resize(@image, :geometry => '10x10<')
-          image.should have_width(280)
-          image.should have_height(355)
-        end
-      
-        it "should resize if the image is smaller than specified" do
-          image = @processor.resize(@image, :geometry => '400x400<')
-          image.should have_width(315)
-          image.should have_height(400)
-        end
-      
-      end
-    
     end
   
-    describe "crop" do # Difficult to test here other than dimensions
+    describe "NNxNN<" do
     
-      it "should not crop if no args given" do
-        image = @processor.crop(@image)
+      it "should not resize if the image is larger than specified" do
+        image = @processor.resize(@image, '10x10<')
         image.should have_width(280)
         image.should have_height(355)
       end
     
-      it "should crop using the offset given" do
-        image = @processor.crop(@image, :x => '7', :y => '12')
-        image.should have_width(273)
-        image.should have_height(343)
-      end
-    
-      it "should crop using the dimensions given" do
-        image = @processor.crop(@image, :width => '10', :height => '20')
-        image.should have_width(10)
-        image.should have_height(20)
-      end
-    
-      it "should crop in one dimension if given" do
-        image = @processor.crop(@image, :width => '10')
-        image.should have_width(10)
-        image.should have_height(355)
-      end
-    
-      it "should take into account the gravity given" do
-        image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
-        image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
-        image1.should_not == image2
-      end
-    
-      it "should clip bits of the image outside of the requested crop area when not nw gravity" do
-        # Rmagick was previously throwing an error when the cropping area was outside the image size, when
-        # using a gravity other than nw
-        image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
-        image.should have_width(180)
-        image.should have_height(155)
+      it "should resize if the image is smaller than specified" do
+        image = @processor.resize(@image, '400x400<')
+        image.should have_width(315)
+        image.should have_height(400)
       end
     
     end
+  
+  end
 
-    describe "greyscale" do
-      it "should not raise an error" do
-        # Bit tricky to test
-        @processor.greyscale(@image)
-      end
+  describe "crop" do # Difficult to test here other than dimensions
+  
+    it "should not crop if no args given" do
+      image = @processor.crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
     end
+  
+    it "should crop using the offset given" do
+      image = @processor.crop(@image, :x => '7', :y => '12')
+      image.should have_width(273)
+      image.should have_height(343)
+    end
+  
+    it "should crop using the dimensions given" do
+      image = @processor.crop(@image, :width => '10', :height => '20')
+      image.should have_width(10)
+      image.should have_height(20)
+    end
+  
+    it "should crop in one dimension if given" do
+      image = @processor.crop(@image, :width => '10')
+      image.should have_width(10)
+      image.should have_height(355)
+    end
+  
+    it "should take into account the gravity given" do
+      image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+  
+    it "should clip bits of the image outside of the requested crop area when not nw gravity" do
+      # Rmagick was previously throwing an error when the cropping area was outside the image size, when
+      # using a gravity other than nw
+      image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
+      image.should have_width(180)
+      image.should have_height(155)
+    end
+  
+  end
 
-    describe "resize_and_crop" do
-    
-      it "should do nothing if no args given" do
-        image = @processor.resize_and_crop(@image)
-        image.should have_width(280)
-        image.should have_height(355)
-      end
-    
-      it "should crop to the correct dimensions" do
-        image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
-        image.should have_width(100)
-        image.should have_height(100)
-      end
-    
-      it "should allow cropping in one dimension" do
-        image = @processor.resize_and_crop(@image, :width => '100')
-        image.should have_width(100)
-        image.should have_height(355)
-      end
-    
-      it "should take into account the gravity given" do
-        image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
-        image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
-        image1.should_not == image2
-      end
-    
+  describe "greyscale" do
+    it "should not raise an error" do
+      # Bit tricky to test
+      @processor.greyscale(@image)
     end
+  end
+
+  describe "resize_and_crop" do
   
-    describe "rotate" do
-    
-      it "should rotate by 90 degrees" do
-        image = @processor.rotate(@image, :amount => '90')
-        image.should have_width(355)
-        image.should have_height(280)
-      end
-    
-      it "should not rotate given a larger height and the '>' qualifier" do
-        image = @processor.rotate(@image, :amount => 90, :qualifier => '>')
-        image.should have_width(280)
-        image.should have_height(355)
-      end
-    
-      it "should rotate given a larger height and the '<' qualifier" do
-        image = @processor.rotate(@image, :amount => 90, :qualifier => '<')
-        image.should have_width(355)
-        image.should have_height(280)
-      end
-    
-      it "should do nothing if no amount given" do
-        image = @processor.rotate(@image)
-        image.should have_width(280)
-        image.should have_height(355)
-      end
-    
+    it "should do nothing if no args given" do
+      image = @processor.resize_and_crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+  
+    it "should crop to the correct dimensions" do
+      image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
+      image.should have_width(100)
+      image.should have_height(100)
+    end
+  
+    it "should allow cropping in one dimension" do
+      image = @processor.resize_and_crop(@image, :width => '100')
+      image.should have_width(100)
+      image.should have_height(355)
+    end
+  
+    it "should take into account the gravity given" do
+      image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+  
+  end
+
+  describe "rotate" do
+  
+    it "should rotate by 90 degrees" do
+      image = @processor.rotate(@image, 90)
+      image.should have_width(355)
+      image.should have_height(280)
+    end
+  
+    it "should not rotate given a larger height and the '>' qualifier" do
+      image = @processor.rotate(@image, 90, :qualifier => '>')
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+  
+    it "should rotate given a larger height and the '<' qualifier" do
+      image = @processor.rotate(@image, 90, :qualifier => '<')
+      image.should have_width(355)
+      image.should have_height(280)
+    end
+  
+  end
+
+  describe "thumb" do
+    it "should call resize if the correct string given" do
+      @processor.should_receive(:resize).with(@image, '30x40').and_return(image = mock)
+      @processor.thumb(@image, '30x40').should == image
+    end
+    it "should call resize_and_crop if the correct string given" do
+      @processor.should_receive(:resize_and_crop).with(@image, :width => '30', :height => '40', :gravity => 'se').and_return(image = mock)
+      @processor.thumb(@image, '30x40#se').should == image
+    end
+    it "should call crop if x and y given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => '+10', :y => '+20', :gravity => nil).and_return(image = mock)
+      @processor.thumb(@image, '30x40+10+20').should == image
+    end
+    it "should call crop if just gravity given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => nil, :y => nil, :gravity => 'sw').and_return(image = mock)
+      @processor.thumb(@image, '30x40sw').should == image
+    end
+    it "should call crop if x, y and gravity given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => '-10', :y => '-20', :gravity => 'se').and_return(image = mock)
+      @processor.thumb(@image, '30x40-10-20se').should == image
+    end
+    it "should raise an argument error if an unrecognized string is given" do
+      lambda{ @processor.thumb(@image, '30x40#ne!') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "flip" do
+    it "should flip the image, leaving the same dimensions" do
+      image = @processor.flip(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+  end
+
+  describe "flop" do
+    it "should flop the image, leaving the same dimensions" do
+      image = @processor.flop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
     end
   end