fog-dragonfly 0.8.1

data/spec/dragonfly/data_storage/mongo_data_store_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+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 :database => 'dragonfly_test'
+  end
+  
+  it_should_behave_like 'data_store'
+  
+  describe "authenticating" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('Feijão verde')
+    end
+    
+    it "should not attempt to authenticate if a username is not given" do
+      @data_store.db.should_not_receive(:authenticate)
+      @data_store.store(@temp_object)    
+    end
+    
+    it "should attempt to authenticate once if a username is given" do
+      @data_store.username = 'terry'
+      @data_store.password = 'butcher'
+      @data_store.db.should_receive(:authenticate).exactly(:once).with('terry','butcher').and_return(true)
+      uid = @data_store.store(@temp_object)
+      @data_store.retrieve(uid)
+    end
+  end
+
+end

data/spec/dragonfly/data_storage/s3_data_store_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/data_store_spec'
+require 'yaml'
+
+describe Dragonfly::DataStorage::S3DataStore do
+
+  # To run these tests, put a file ".s3_spec.yml" in the dragonfly root dir, like this:
+  # key: XXXXXXXXXX
+  # secret: XXXXXXXXXX
+  # enabled: true
+  if File.exist?(file = File.expand_path('../../../../.s3_spec.yml', __FILE__))
+    config = YAML.load_file(file)
+    KEY = config['key']
+    SECRET = config['secret']
+    enabled = config['enabled']
+  else
+    enabled = false
+  end
+
+  if enabled
+
+    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 = KEY
+          d.secret_access_key = SECRET
+        end
+      end
+
+      it_should_behave_like 'data_store'
+
+      describe "generate_uid" do
+        context "without a specific_uid" do
+          it 'should the default value' do
+            @data_store.send(:generate_uid, "hello").should =~ /\d+\/\d+\/\d+\/\d+\/\d+\/\d+\/\w+\/hello/
+          end
+        end
+
+        context "with a specific_uid" do
+          before do
+            @data_store.specific_uid = lambda{|name| name}
+          end
+
+          after do
+            @data_store.specific_uid = nil
+          end
+
+          it 'should call the specific_uid lambda' do
+            @data_store.send(:generate_uid, "hello").should == 'hello'
+          end
+        end
+      end
+
+      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
+
+        it "should allow for setting the path manually" do
+          temp_object = Dragonfly::TempObject.new('eggheads')
+          uid = @data_store.store(temp_object, :path => 'hello/there')
+          uid.should == 'hello/there'
+          data, extra = @data_store.retrieve(uid)
+          data.should == 'eggheads'
+        end
+
+        it "should work fine when not using the filesystem" do
+          @data_store.use_filesystem = false
+          temp_object = Dragonfly::TempObject.new('gollum')
+          uid = @data_store.store(temp_object)
+          @data_store.retrieve(uid).should == ["gollum", {:meta=>{}, :format=>nil, :name=>nil}]
+        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(:imagemagick) 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/encoding/image_magick_encoder_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Dragonfly::Encoding::ImageMagickEncoder do
+  
+  before(:all) do
+    sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355, 135KB
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @encoder = Dragonfly::Encoding::ImageMagickEncoder.new
+  end
+  
+  describe "#encode" do
+    
+    it "should encode the image to the correct format" do
+      image = @encoder.encode(@image, :gif)
+      image.should have_format('gif')
+    end
+    
+    it "should throw :unable_to_handle if the format is not handleable" do
+      lambda{
+        @encoder.encode(@image, :goofy)
+      }.should throw_symbol(:unable_to_handle)
+    end
+    
+    it "should do nothing if the image is already in the correct format" do
+      image = @encoder.encode(@image, :png)
+      image.should == @image
+    end
+
+    it "should allow for extra args" do
+      image = @encoder.encode(@image, :jpg, '-quality 1')
+      image.should have_format('jpeg')
+      image.should have_size('1.45KB')
+    end
+    
+    it "should still work even if the image is already in the correct format and args are given" do
+      image = @encoder.encode(@image, :png, '-quality 1')
+      image.should_not == @image
+    end
+  end
+  
+end

data/spec/dragonfly/encoding/r_magick_encoder_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Dragonfly::Encoding::RMagickEncoder do
+  
+  before(:all) do
+    sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @encoder = Dragonfly::Encoding::RMagickEncoder.new
+  end
+  
+  describe "#encode" do
+    
+    it "should encode the image to the correct format" do
+      image = @encoder.encode(@image, :gif)
+      image.should have_format('gif')
+    end
+    
+    it "should throw :unable_to_handle if the format is not handleable" do
+      lambda{
+        @encoder.encode(@image, :goofy)
+      }.should throw_symbol(:unable_to_handle)
+    end
+    
+    it "should do nothing if the image is already in the correct format" do
+      image = @encoder.encode(@image, :png)
+      image.should == @image
+    end
+    
+    it "should work when not using the filesystem" do
+      @encoder.use_filesystem = false
+      image = @encoder.encode(@image, :gif)
+      image.should have_format('gif')
+    end
+
+  end
+  
+end

data/spec/dragonfly/function_manager_spec.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+Spec::Matchers.define :have_keys do |*keys|
+  match 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

data/spec/dragonfly/generation/hash_with_css_style_keys_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Dragonfly::Generation::HashWithCssStyleKeys do
+  
+  before(:each) do
+    @hash = Dragonfly::Generation::HashWithCssStyleKeys[
+      :font_style => 'normal',
+      :'font-weight' => 'bold',
+      'font_colour' => 'white',
+      'font-size' => 23,
+      :hello => 'there'
+    ]
+  end
+
+  describe "accessing using underscore symbol style" do
+    it{ @hash[:font_style].should == 'normal' }
+    it{ @hash[:font_weight].should == 'bold' }
+    it{ @hash[:font_colour].should == 'white' }
+    it{ @hash[:font_size].should == 23 }
+    it{ @hash[:hello].should == 'there' }
+    it{ @hash[:non_existent_key].should be_nil }
+  end
+
+end

data/spec/dragonfly/generation/image_magick_generator_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'dragonfly/generation/shared_generator_spec'
+
+describe Dragonfly::Generation::ImageMagickGenerator do
+
+  before(:each) do
+    @generator = Dragonfly::Generation::ImageMagickGenerator.new
+  end
+
+  it_should_behave_like 'image generator'
+
+end

data/spec/dragonfly/generation/r_magick_generator_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'dragonfly/generation/shared_generator_spec'
+
+describe Dragonfly::Generation::RMagickGenerator do
+
+  before(:each) do
+    @generator = Dragonfly::Generation::RMagickGenerator.new
+  end
+
+  describe "when using the filesystem" do
+    before(:each) do
+      @generator.use_filesystem = true
+    end
+    it_should_behave_like 'image generator'
+  end
+  
+  describe "when not using the filesystem" do
+    before(:each) do
+      @generator.use_filesystem = false
+    end
+    it_should_behave_like 'image generator'
+  end
+  
+end