dragonfly 0.6.2 → 0.7.0

data/spec/dragonfly/routed_endpoint_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def response_for(array)
+  Rack::MockResponse.new(*array)
+end
+
+describe Dragonfly::RoutedEndpoint do
+
+  def env_for(url, opts={})
+    Rack::MockRequest.env_for(url, opts)
+  end
+
+  before(:each) do
+    @app = test_app
+    @endpoint = Dragonfly::RoutedEndpoint.new(@app) {|params, app|
+      app.fetch(params[:uid])
+    }
+    @app.datastore.stub!(:retrieve).with('some_uid').and_return Dragonfly::TempObject.new('wassup')
+  end
+
+  it "should raise an error when there are no routing parameters" do
+    lambda{
+      @endpoint.call(env_for('/blah'))
+    }.should raise_error(Dragonfly::RoutedEndpoint::NoRoutingParams)
+  end
+
+  {
+    'Rails' => 'action_dispatch.request.path_parameters',
+    'Usher' => 'usher.params',
+    'HTTP Router' => 'router.params',
+    'Rack-Mount' => 'rack.routing_args',
+    'Dragonfly' => 'dragonfly.params'
+  }.each do |name, key|
+
+    it "should work with #{name} routing args" do
+      response = response_for @endpoint.call(env_for('/blah', key => {:uid => 'some_uid'}))
+      response.body.should == 'wassup'
+    end
+    
+  end
+
+  it "should merge with query parameters" do
+    env = Rack::MockRequest.env_for('/big/buns?uid=some_uid', 'dragonfly.params' => {:something => 'else'})
+    response = response_for @endpoint.call(env)
+    response.body.should == 'wassup'
+  end
+
+end

data/spec/dragonfly/serializer_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::Serializer do
+  
+  include Dragonfly::Serializer
+  
+  [
+    'a',
+    'sdhflasd',
+    '/2010/03/01/hello.png',
+    '//..',
+    'whats/up.egg.frog',
+    '£ñçùí;'
+  ].each do |string|
+    it "should encode #{string.inspect} properly with no padding/line break" do
+      b64_encode(string).should_not =~ /\n|=/
+    end
+    it "should correctly encode and decode #{string.inspect} to the same string" do
+      str = b64_decode(b64_encode(string))
+      str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
+      str.should == string
+    end
+  end
+  
+  [
+    :hello,
+    nil,
+    true,
+    4,
+    2.3,
+    'wassup man',
+    [3,4,5],
+    {:wo => 'there'},
+    [{:this => 'should', :work => [3, 5.3, nil, {false => 'egg'}]}, [], true]
+  ].each do |object|
+    it "should correctly marshal encode #{object.inspect} properly with no padding/line break" do
+      encoded = marshal_encode(object)
+      # raise encoded.index("\n").inspect
+      encoded.should be_a(String)
+      encoded.should_not =~ /\n|=/
+    end
+    it "should correctly marshal encode and decode #{object.inspect} to the same object" do
+      marshal_decode(marshal_encode(object)).should == object
+    end
+  end
+  
+  describe "marshal_decode" do
+    it "should raise an error if the string passed in is empty" do
+      lambda{
+        marshal_decode('')
+      }.should raise_error(Dragonfly::Serializer::BadString)
+    end
+    it "should raise an error if the string passed in is gobbledeegook" do
+      lambda{
+        marshal_decode('ahasdkjfhasdkfjh')
+      }.should raise_error(Dragonfly::Serializer::BadString)
+    end
+  end
+  
+end

data/spec/dragonfly/simple_cache_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::SimpleCache do
+  
+  before(:each) do
+    @cache = Dragonfly::SimpleCache.new(2)
+  end
+  
+  it "should act as a normal hash" do
+    @cache[:egg] = 'four'
+    @cache[:egg].should == 'four'
+  end
+  
+  it "should allow filling up to the limit" do
+    @cache[:a] = 1
+    @cache[:b] = 2
+    @cache.should == {:a => 1, :b => 2}
+  end
+  
+  it "should get rid of the first added when full" do
+    @cache[:a] = 1
+    @cache[:b] = 2
+    @cache[:c] = 3
+    @cache.should == {:b => 2, :c => 3}
+  end
+  
+end

data/spec/dragonfly/simple_endpoint_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rack/mock'
+
+def request(app, path)
+  Rack::MockRequest.new(app).get(path)
+end
+
+describe Dragonfly::SimpleEndpoint do
+
+  before(:each) do
+    @app = test_app
+    @app.protect_from_dos_attacks = false
+    @uid = @app.store('HELLO THERE')
+    @endpoint = Dragonfly::SimpleEndpoint.new(@app)
+  end
+  
+  after(:each) do
+    @app.destroy(@uid)
+  end
+
+  it "should return the thing when given the url" do
+    url = "/#{@app.fetch(@uid).serialize}"
+    response = request(@endpoint, url)
+    response.status.should == 200
+    response.body.should == 'HELLO THERE'
+    response.content_type.should == 'application/octet-stream'
+  end
+
+  it "should return a 400 if no sha given but protection on" do
+    @app.protect_from_dos_attacks = true
+    url = "/#{@app.fetch(@uid).serialize}"
+    response = request(@endpoint, url)
+    response.status.should == 400
+  end
+  
+  it "should return a 400 if wrong sha given and protection on" do
+    @app.protect_from_dos_attacks = true
+    url = "/#{@app.fetch(@uid).serialize}?s=asdfs"
+    response = request(@endpoint, url)
+    response.status.should == 400
+  end
+  
+  it "should return a 404 when the url isn't known" do
+    response = request(@endpoint, '/sadhfasdfdsfsdf')
+    response.status.should == 404
+    response.body.should == 'Not found'
+    response.content_type.should == 'text/plain'
+  end
+  
+  it "should return a 404 when the url is a well-encoded but bad array" do
+    url = "/#{Dragonfly::Serializer.marshal_encode([[:egg, {:some => 'args'}]])}"
+    response = request(@endpoint, url)
+    response.status.should == 404
+    response.body.should == 'Not found'
+    response.content_type.should == 'text/plain'
+  end
+
+  it "should still work when mapped to a prefix" do
+    endpoint = @endpoint
+    rack_app = Rack::Builder.new do
+      map '/some_prefix' do
+        run endpoint
+      end
+    end.to_app
+    url = "/some_prefix/#{@app.fetch(@uid).serialize}"
+    response = request(rack_app, url)
+    response.status.should == 200
+    response.body.should == 'HELLO THERE'
+  end
+
+  it "should return a simple text response at the root" do
+    response = request(@endpoint, '/')
+    response.status.should == 200
+    response.body.length.should > 0
+    response.content_type.should == 'text/plain'
+  end
+
+end

data/spec/dragonfly/temp_object_spec.rb

@@ -22,6 +22,15 @@ describe Dragonfly::TempObject do
     File.new('/tmp/test_file')
   end
   
+  def new_temp_object(data, opts={})
+    klass = opts.delete(:class) || Dragonfly::TempObject
+    klass.new(initialization_object(data), opts)
+  end
+  
+  def initialization_object(data)
+    raise NotImplementedError, "This should be implemented in the describe block!"
+  end
+  
   def get_parts(temp_object)
     parts = []
     temp_object.each do |bytes|
@@ -41,78 +50,102 @@ describe Dragonfly::TempObject do
   
   describe "common behaviour", :shared => true do
 
-    before(:each) do
-      @temp_object = new_temp_object('HELLO')
-    end
+    describe "simple initialization" do
 
-    describe "data" do
-      it "should return the data correctly" do
-        @temp_object.data.should == 'HELLO'
+      before(:each) do
+        @temp_object = new_temp_object('HELLO')
       end
-    end
 
-    describe "file" do
-      it "should return a readable file" do
-        @temp_object.file.should be_a(File)
-      end
-      it "should contain the correct data" do
-        @temp_object.file.read.should == 'HELLO'
-      end
-      it "should yield a file then close it if a block is given" do
-        @temp_object.file do |f|
-          f.read.should == 'HELLO'
-          f.should_receive :close
+      describe "data" do
+        it "should return the data correctly" do
+          @temp_object.data.should == 'HELLO'
         end
       end
-      it "should return whatever is returned from the block if a block is given" do
-        @temp_object.file do |f|
-          'doogie'
-        end.should == 'doogie'
-      end
-    end
 
-    describe "tempfile" do
-      it "should create a closed tempfile" do
-        @temp_object.tempfile.should be_a(Tempfile)
-        @temp_object.tempfile.should be_closed
+      describe "file" do
+        it "should return a readable file" do
+          @temp_object.file.should be_a(File)
+        end
+        it "should contain the correct data" do
+          @temp_object.file.read.should == 'HELLO'
+        end
+        it "should yield a file then close it if a block is given" do
+          @temp_object.file do |f|
+            f.read.should == 'HELLO'
+            f.should_receive :close
+          end
+        end
+        it "should return whatever is returned from the block if a block is given" do
+          @temp_object.file do |f|
+            'doogie'
+          end.should == 'doogie'
+        end
       end
-      it "should contain the correct data" do
-        @temp_object.tempfile.open.read.should == 'HELLO'
+
+      describe "tempfile" do
+        it "should create a closed tempfile" do
+          @temp_object.tempfile.should be_a(Tempfile)
+          @temp_object.tempfile.should be_closed
+        end
+        it "should contain the correct data" do
+          @temp_object.tempfile.open.read.should == 'HELLO'
+        end
       end
-    end
     
-    describe "path" do
-      it "should return the absolute file path" do
-        @temp_object.path.should == @temp_object.tempfile.path
+      describe "path" do
+        it "should return the absolute file path" do
+          @temp_object.path.should == @temp_object.tempfile.path
+        end
       end
-    end
     
-    describe "size" do
-      it "should return the size in bytes" do
-        @temp_object.size.should == 5
+      describe "size" do
+        it "should return the size in bytes" do
+          @temp_object.size.should == 5
+        end
       end
-    end
 
-    describe "to_file" do
-      before(:each) do
-        @filename = 'eggnog.txt'
-        FileUtils.rm(@filename) if File.exists?(@filename)
+      describe "to_file" do
+        before(:each) do
+          @filename = 'eggnog.txt'
+          FileUtils.rm(@filename) if File.exists?(@filename)
+        end
+        after(:each) do
+          FileUtils.rm(@filename) if File.exists?(@filename)
+        end
+        it "should write to a file" do
+          @temp_object.to_file(@filename)
+          File.exists?(@filename).should be_true
+        end
+        it "should write the correct data to the file" do
+          @temp_object.to_file(@filename)
+          File.read(@filename).should == 'HELLO'
+        end
+        it "should return a readable file" do
+          file = @temp_object.to_file(@filename)
+          file.should be_a(File)
+          file.read.should == 'HELLO'
+        end
       end
-      after(:each) do
-        FileUtils.rm(@filename) if File.exists?(@filename)
+      
+    end
+
+    describe "initializing attributes too" do
+      it "should set the name" do
+        temp_object = Dragonfly::TempObject.new(initialization_object('HELLO'), :name => 'monkey.egg')
+        temp_object.name.should == 'monkey.egg'
       end
-      it "should write to a file" do
-        @temp_object.to_file(@filename)
-        File.exists?(@filename).should be_true
+      it "should set the meta" do
+        temp_object = Dragonfly::TempObject.new(initialization_object('HELLO'), :meta => {:dr => 'doolittle'})
+        temp_object.meta.should == {:dr => 'doolittle'}
       end
-      it "should write the correct data to the file" do
-        @temp_object.to_file(@filename)
-        File.read(@filename).should == 'HELLO'
+      it "should set the format" do
+        temp_object = Dragonfly::TempObject.new(initialization_object('HELLO'), :format => :jpg)
+        temp_object.format.should == :jpg
       end
-      it "should return a readable file" do
-        file = @temp_object.to_file(@filename)
-        file.should be_a(File)
-        file.read.should == 'HELLO'
+      it "should raise an error if an invalid option is given" do
+        lambda {
+          Dragonfly::TempObject.new(initialization_object('HELLO'), :doobie => 'doo')
+        }.should raise_error(ArgumentError)
       end
     end
 
@@ -127,7 +160,7 @@ describe Dragonfly::TempObject do
       end
       it "should yield the number of bytes specified in the class configuration" do
         klass = Class.new(Dragonfly::TempObject)
-        temp_object = new_temp_object(File.read(sample_path('round.gif')), klass)
+        temp_object = new_temp_object(File.read(sample_path('round.gif')), :class => klass)
         klass.block_size = 3001
         parts = get_parts(temp_object)
         parts[0...-1].each do |part|
@@ -142,8 +175,8 @@ describe Dragonfly::TempObject do
   
   describe "initializing from a string" do
 
-    def new_temp_object(data, klass=Dragonfly::TempObject)
-      klass.new(data)
+    def initialization_object(data)
+      data
     end
 
     it_should_behave_like "common behaviour"
@@ -157,8 +190,8 @@ describe Dragonfly::TempObject do
   
   describe "initializing from a tempfile" do
 
-    def new_temp_object(data, klass=Dragonfly::TempObject)
-      klass.new(new_tempfile(data))
+    def initialization_object(data)
+      new_tempfile(data)
     end
 
     it_should_behave_like "common behaviour"
@@ -172,8 +205,8 @@ describe Dragonfly::TempObject do
   
   describe "initializing from a file" do
 
-    def new_temp_object(data, klass=Dragonfly::TempObject)
-      klass.new(new_file(data))
+    def initialization_object(data)
+      new_file(data)
     end
 
     it_should_behave_like "common behaviour"
@@ -201,41 +234,6 @@ describe Dragonfly::TempObject do
     end
   end
   
-  describe "modify_self!" do
-
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('DATA_ONE')
-      @temp_object.data # Make sure internal stuff is initialized
-      @temp_object.file #
-    end
-    it "should modify itself" do
-      @temp_object.modify_self!('DATA_TWO')
-      @temp_object.data.should == 'DATA_TWO'
-    end
-    it "should return itself" do
-      @temp_object.modify_self!('DATA_TWO').should == @temp_object
-    end
-    it "should modify itself when the new object is a file" do
-      @temp_object.modify_self!(File.new(SAMPLES_DIR + '/beach.png'))
-      @temp_object.data.should == File.read(SAMPLES_DIR + '/beach.png')
-    end
-    it "should modify itself when the new object is a tempfile" do
-      tempfile = new_tempfile
-      data = tempfile.read
-      @temp_object.modify_self!(tempfile)
-      @temp_object.data.should == data
-    end
-    it "should still work when the object is itself" do
-      @temp_object.modify_self!(@temp_object)
-      @temp_object.data.should == 'DATA_ONE'
-    end
-    it "should keep the same name" do
-      @temp_object.name = 'billy.bob'
-      @temp_object.modify_self!('WASSUP PUNk')
-      @temp_object.name.should == 'billy.bob'
-    end
-  end
-  
   describe "name" do
     before(:each) do
       @obj = new_tempfile
@@ -254,46 +252,83 @@ describe Dragonfly::TempObject do
       temp_object = Dragonfly::TempObject.new(file)
       temp_object.name.should == 'round.gif'
     end
-    it "should still be nil if set to empty string" do
-      temp_object = Dragonfly::TempObject.new('sdf')
-      temp_object.name = ''
+    it "should still be nil if set to empty string on initialize" do
+      temp_object = Dragonfly::TempObject.new('sdf', :name => '')
       temp_object.name.should be_nil
     end
   end
   
   describe "ext" do
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('asfsadf')
-    end
     it "should use the correct extension from name" do
-      @temp_object.name = 'hello.there.mate'
-      @temp_object.ext.should == 'mate'
+      temp_object = Dragonfly::TempObject.new('asfsadf', :name => 'hello.there.mate')
+      temp_object.ext.should == 'mate'
     end
     it "should be nil if name has none" do
-      @temp_object.name = 'hello'
-      @temp_object.ext.should be_nil
+      temp_object = Dragonfly::TempObject.new('asfsadf', :name => 'hello')
+      temp_object.ext.should be_nil
     end
     it "should be nil if name is nil" do
-      @temp_object.name = nil
-      @temp_object.ext.should be_nil
+      temp_object = Dragonfly::TempObject.new('asfsadf')
+      temp_object.ext.should be_nil
     end
   end
-  
+
   describe "basename" do
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('asfsadf')
-    end
     it "should use the correct basename from name" do
-      @temp_object.name = 'hello.there.mate'
-      @temp_object.basename.should == 'hello.there'
+      temp_object = Dragonfly::TempObject.new('A', :name => 'hello.there.mate')
+      temp_object.basename.should == 'hello.there'
     end
     it "should be the name if it has no ext" do
-      @temp_object.name = 'hello'
-      @temp_object.basename.should == 'hello'
+      temp_object = Dragonfly::TempObject.new('A', :name => 'hello')
+      temp_object.basename.should == 'hello'
     end
     it "should be nil if name is nil" do
-      @temp_object.name = nil
-      @temp_object.basename.should be_nil
+      temp_object = Dragonfly::TempObject.new('A', :name => nil)
+      temp_object.basename.should be_nil
+    end
+  end
+  
+  describe "meta" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('get outta here!')
+    end
+    it "should return an empty hash if not set" do
+      @temp_object.meta.should == {}
+    end
+    it "should allow setting" do
+      @temp_object.meta[:teeth] = 'many'
+      @temp_object.meta.should == {:teeth => 'many'}
+    end
+  end
+  
+  describe "format" do
+    it "should return nil if not set" do
+      temp_object = Dragonfly::TempObject.new('wassin my belly??!')
+      temp_object.format.should be_nil
+    end
+    it "should allow setting on initialize" do
+      temp_object = Dragonfly::TempObject.new('wassin my belly??!', :format => :jpg)
+      temp_object.format.should == :jpg
+    end
+  end
+  
+  describe "extract_attributes_from" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new("ne'er gonna give you up",
+        :meta => {:a => 4},
+        :name => 'fred.txt'
+      )
+      @attributes = {:meta => {:b => 5}, :ogle => 'bogle'}
+      @temp_object.extract_attributes_from(@attributes)
+    end
+    it "should overwrite its own attributes if specified" do
+      @temp_object.meta.should == {:b => 5}
+    end
+    it "should leave non-specified attributes untouched" do
+      @temp_object.name.should == 'fred.txt'
+    end
+    it "should remove attributes from the hash" do
+      @attributes.should == {:ogle => 'bogle'}
     end
   end