dragonfly 0.9.15 → 1.0

data/spec/dragonfly/data_storage/mongo_data_store_spec.rb

@@ -1,81 +0,0 @@
-# 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 "connecting to a replica set" do
-    it "should initiate a replica set connection if hosts is set" do
-      @data_store.hosts = ['1.2.3.4:27017', '1.2.3.4:27017']
-      @data_store.connection_opts = {:name => 'testingset'}
-      Mongo::ReplSetConnection.should_receive(:new).with(['1.2.3.4:27017', '1.2.3.4:27017'], :name => 'testingset')
-      @data_store.connection
-    end
-  end
-  
-  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
-
-  describe "extra options" do
-
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('testingyo')
-    end
-
-    [:content_type, :mime_type].each do |key|
-      it "should allow setting content type on store with #{key.inspect}" do
-        uid = @data_store.store(@temp_object, key => 'text/plain')
-        @data_store.grid.get(BSON::ObjectId(uid)).content_type.should == 'text/plain'
-        @data_store.grid.get(BSON::ObjectId(uid)).read.should == 'testingyo'
-      end
-    end
-  end
-
-end

data/spec/dragonfly/data_storage/s3_data_store_spec.rb

@@ -1,277 +0,0 @@
-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 from the temp_object if set" do
-      temp_object = Dragonfly::TempObject.new('eggheads', :name => 'doobie')
-      uid = @data_store.store(temp_object)
-      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', :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, 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
-
-    if enabled # Fog.mock! doesn't act consistently here
-      it "should reset the connection and try again if Fog throws a socket EOFError" do
-        temp_object = Dragonfly::TempObject.new('gollum')
-        @data_store.storage.should_receive(:put_object).exactly(:once).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything, hash_including)
-        @data_store.store(temp_object)
-      end
-
-      it "should just let it raise if Fog throws a socket EOFError again" do
-        temp_object = Dragonfly::TempObject.new('gollum')
-        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        expect{
-          @data_store.store(temp_object)
-        }.to raise_error(Excon::Errors::SocketError)
-      end
-    end
-  end
-
-  # Doesn't appear to raise anything right now
-  # 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
-
-  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(BUCKET_NAME, 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(BUCKET_NAME, 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(BUCKET_NAME, 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
-
-    it "should store with the content-type if passed in" do
-      @data_store.storage.should_receive(:put_object) do |_, __, ___, headers|
-        headers['Content-Type'].should == 'text/plain'
-      end
-      @data_store.store(@temp_object, :mime_type => 'text/plain')
-    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://#{BUCKET_NAME}\.#{@data_store.domain}/some/path/on/s3\?AWSAccessKeyId=#{@data_store.access_key_id}&Signature=[\w%]+&Expires=1301476942$}
-    end
-
-    it "should allow for using https" do
-      @data_store.url_for(@uid, :scheme => 'https').should == "https://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
-    end
-
-    it "should allow for always using https" do
-      @data_store.url_scheme = 'https'
-      @data_store.url_for(@uid).should == "https://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
-    end
-
-    it "should allow for customizing the host" do
-      @data_store.url_for(@uid, :host => 'customised.domain.com/and/path').should == "http://customised.domain.com/and/path/some/path/on/s3"
-    end
-
-    it "should allow the url_host to be customised permanently" do
-      url_host = 'customised.domain.com/and/path'
-      @data_store.url_host = url_host
-      @data_store.url_for(@uid).should == "http://#{url_host}/some/path/on/s3"
-    end
-
-  end
-
-end

data/spec/dragonfly/data_storage/shared_data_store_examples.rb

@@ -1,77 +0,0 @@
-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', :bitrate => '35', :name => 'danny.boy')
-        @uid = @data_store.store(temp_object)
-        @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

@@ -1,154 +0,0 @@
-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