oahu-dragonfly 0.8.2

data/spec/dragonfly/data_storage/mongo_data_store_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'spec_helper'
+require File.dirname(__FILE__) + '/shared_data_store_examples'
+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
+
+  describe "sharing already configured stuff" do
+    before(:each) do
+      @connection = Mongo::Connection.new
+      @temp_object = Dragonfly::TempObject.new('asdf')
+    end
+    
+    it "should allow sharing the connection" do
+      @data_store.connection = @connection
+      @connection.should_receive(:db).with('dragonfly_test').and_return(db=mock)
+      @data_store.db.should == db
+    end
+    
+    it "should allow sharing the db" do
+      db = @connection.db('dragonfly_test_yo')
+      @data_store.db = db
+      @data_store.grid.instance_eval{@db}.should == db # so wrong
+    end
+  end
+
+end

data/spec/dragonfly/data_storage/s3_data_store_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require File.dirname(__FILE__) + '/shared_data_store_examples'
+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
+
+    # Make sure it's a new bucket name
+    BUCKET_NAME = "dragonfly-test-#{Time.now.to_i.to_s(36)}"
+
+    before(:each) do
+      WebMock.allow_net_connect!
+      @data_store = Dragonfly::DataStorage::S3DataStore.new
+      @data_store.configure do |d|
+        d.bucket_name = BUCKET_NAME
+        d.access_key_id = KEY
+        d.secret_access_key = SECRET
+        d.region = 'eu-west-1'
+      end
+    end
+
+  else
+
+    BUCKET_NAME = 'test-bucket'
+
+    before(:each) do
+      Fog.mock!
+      @data_store = Dragonfly::DataStorage::S3DataStore.new
+      @data_store.configure do |d|
+        d.bucket_name = BUCKET_NAME
+        d.access_key_id = 'XXXXXXXXX'
+        d.secret_access_key = 'XXXXXXXXX'
+        d.region = 'eu-west-1'
+      end
+    end
+
+  end
+
+  it_should_behave_like 'data_store'
+
+  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 use the name in the meta if set" do
+      temp_object = Dragonfly::TempObject.new('eggheads')
+      uid = @data_store.store(temp_object, :meta => {:name =>  'doobie'})
+      uid.should =~ /doobie$/
+      data, meta = @data_store.retrieve(uid)
+      data.should == 'eggheads'
+    end
+
+    it "should work ok with files with funny names" do
+      temp_object = Dragonfly::TempObject.new('eggheads')
+      uid = @data_store.store(temp_object, :meta => {:name =>  'A Picture with many spaces in its name (at 20:00 pm).png'})
+      uid.should =~ /A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/
+      data, meta = @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, meta = @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).first.should == "gollum"
+    end
+
+    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
+  end
+
+  if enabled # Fog.mock! doesn't work consistently with real one here
+
+    describe "destroy" do
+      before(:each) do
+        @temp_object = Dragonfly::TempObject.new('gollum')
+      end
+      it "should raise an error if the data doesn't exist on destroy" do
+        uid = @data_store.store(@temp_object)
+        @data_store.destroy(uid)
+        lambda{
+          @data_store.destroy(uid)
+        }.should raise_error(Dragonfly::DataStorage::DataNotFound)
+      end
+    end
+
+  end
+
+  describe "domain" do
+    it "should default to the US" do
+      @data_store.region = nil
+      @data_store.domain.should == 's3.amazonaws.com'
+    end
+
+    it "should return the correct domain" do
+      @data_store.region = 'eu-west-1'
+      @data_store.domain.should == 's3-eu-west-1.amazonaws.com'
+    end
+
+    it "does raise an error if an unknown region is given" do
+      @data_store.region = 'latvia-central'
+      lambda{
+        @data_store.domain
+      }.should raise_error
+    end
+  end
+
+  describe "not configuring stuff properly" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new("Hi guys")
+    end
+
+    it "should require a bucket name on store" do
+      @data_store.bucket_name = nil
+      proc{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+
+    it "should require an access_key_id on store" do
+      @data_store.access_key_id = nil
+      proc{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+
+    it "should require a secret access key on store" do
+      @data_store.secret_access_key = nil
+      proc{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+
+    it "should require a bucket name on retrieve" do
+      @data_store.bucket_name = nil
+      proc{ @data_store.retrieve('asdf') }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+
+    it "should require an access_key_id on retrieve" do
+      @data_store.access_key_id = nil
+      proc{ @data_store.retrieve('asdf') }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+
+    it "should require a secret access key on retrieve" do
+      @data_store.secret_access_key = nil
+      proc{ @data_store.retrieve('asdf') }.should raise_error(Dragonfly::Configurable::NotConfigured)
+    end
+  end
+
+  describe "autocreating the bucket" do
+    it "should create the bucket on store if it doesn't exist" do
+      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      @data_store.store(Dragonfly::TempObject.new("asdfj"))
+    end
+
+    it "should not try to create the bucket on retrieve if it doesn't exist" do
+      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      @data_store.send(:storage).should_not_receive(:put_bucket)
+      proc{ @data_store.retrieve("gungle") }.should raise_error(Dragonfly::DataStorage::DataNotFound)
+    end
+  end
+
+  describe "headers" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('fjkdlsa')
+      @data_store.storage_headers = {'x-amz-foo' => 'biscuithead'}
+    end
+
+    it "should allow configuring globally" do
+      @data_store.storage.should_receive(:put_object).with('test-bucket', anything, anything,
+        hash_including('x-amz-foo' => 'biscuithead')
+      )
+      @data_store.store(@temp_object)
+    end
+
+    it "should allow adding per-store" do
+      @data_store.storage.should_receive(:put_object).with('test-bucket', anything, anything,
+        hash_including('x-amz-foo' => 'biscuithead', 'hello' => 'there')
+      )
+      @data_store.store(@temp_object, :headers => {'hello' => 'there'})
+    end
+
+    it "should let the per-store one take precedence" do
+      @data_store.storage.should_receive(:put_object).with('test-bucket', anything, anything,
+        hash_including('x-amz-foo' => 'override!')
+      )
+      @data_store.store(@temp_object, :headers => {'x-amz-foo' => 'override!'})
+    end
+
+    it "should not mess with the meta" do
+      @data_store.storage.should_receive(:put_object) do |_, __, ___, headers|
+        headers['x-amz-meta-extra'].should =~ /^\w+$/
+      end
+      @data_store.store(@temp_object, :headers => {'hello' => 'there'})
+    end
+  end
+
+  describe "urls for serving directly" do
+
+    before(:each) do
+      @uid = 'some/path/on/s3'
+    end
+
+    it "should use the bucket subdomain" do
+      @data_store.url_for(@uid).should == "http://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should use the bucket subdomain for other regions too" do
+      @data_store.region = 'eu-west-1'
+      @data_store.url_for(@uid).should == "http://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should give an expiring url" do
+      @data_store.url_for(@uid, :expires => 1301476942).should =~
+        %r{^https://#{@data_store.domain}/#{BUCKET_NAME}/some/path/on/s3\?AWSAccessKeyId=#{@data_store.access_key_id}&Signature=[\w%]+&Expires=1301476942$}
+    end
+
+  end
+
+end

data/spec/dragonfly/data_storage/shared_data_store_examples.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+shared_examples_for "data_store" 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 meta" do
+      before(:each) do
+        uid = @data_store.store(@temp_object)
+        @obj, @meta = @data_store.retrieve(uid)
+      end
+
+      it "should retrieve the stored data" do
+        Dragonfly::TempObject.new(@obj).data.should == @temp_object.data
+      end
+      
+      it "should return a meta hash (probably empty)" do
+        @meta.should be_a(Hash)
+      end
+
+    end
+
+    describe "when meta is given" do
+      before(:each) do
+        temp_object = Dragonfly::TempObject.new('gollum')
+        @uid = @data_store.store(temp_object, :meta => {:bitrate => '35', :name => 'danny.boy'})
+        @obj, @meta = @data_store.retrieve(@uid)
+      end
+
+      it "should return the stored meta" do
+        @meta[:bitrate].should == '35'
+        @meta[:name].should == 'danny.boy'
+      end
+    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/function_manager_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+RSpec::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