dragonfly 0.9.15 → 1.0

data/spec/dragonfly/model/validations_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'dragonfly/model/validations'
+
+describe Dragonfly::Model::Validations do
+
+  before(:each) do
+    @app = test_app
+  end
+
+  describe "validates_presence_of" do
+    before(:each) do
+      @item_class = new_model_class('Item', :preview_image_uid) do
+        dragonfly_accessor :preview_image
+        validates_presence_of :preview_image
+      end
+    end
+
+    it "should be valid if set" do
+      @item_class.new(:preview_image => "1234567890").should be_valid
+    end
+
+    it "should be invalid if not set" do
+      @item_class.new.should_not be_valid
+    end
+  end
+
+  describe "validates_size_of" do
+    before(:each) do
+      @item_class = new_model_class('Item', :preview_image_uid) do
+        dragonfly_accessor :preview_image
+        validates_size_of :preview_image, :within => (6..10)
+      end
+    end
+
+    it "should be valid if ok" do
+      @item_class.new(:preview_image => "1234567890").should be_valid
+    end
+
+    it "should be invalid if too small" do
+      @item_class.new(:preview_image => "12345").should_not be_valid
+    end
+  end
+
+  describe "validates_property" do
+
+    before(:each) do
+      @item_class = new_model_class('Item',
+        :preview_image_uid,
+        :other_image_uid,
+        :title
+      ) do
+        extend Dragonfly::Model::Validations
+
+        dragonfly_accessor :preview_image
+        dragonfly_accessor :other_image
+      end
+    end
+
+    before(:each) do
+      @item = @item_class.new(:preview_image => "1234567890")
+    end
+
+    it "should be valid if the property is correct" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :as => 'bungo'
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return('bungo')
+      @item.should be_valid
+    end
+
+    it "should be valid if nil, if not validated on presence (even with validates_property)" do
+      @item_class.class_eval do
+        validates_property :size, :of => :preview_image, :as => 234
+      end
+      @item.preview_image = nil
+      @item.should be_valid
+    end
+
+    it "should be invalid if the property is nil" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :in => ['bungo', 'jerry']
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return(nil)
+      @item.should_not be_valid
+      @item.errors[:preview_image].should == ["gungle is incorrect. It needs to be one of 'bungo', 'jerry'"]
+    end
+
+    it "should be invalid if the property is wrong" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :in => ['bungo', 'jerry']
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return('spangle')
+      @item.should_not be_valid
+      @item.errors[:preview_image].should == ["gungle is incorrect. It needs to be one of 'bungo', 'jerry', but was 'spangle'"]
+    end
+
+    it "is invalid if the property raises" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :as => 'bungo'
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_raise(RuntimeError, "yikes!")
+      @item.should_not be_valid
+      @item.errors[:preview_image].should == ["gungle is incorrect. It needs to be 'bungo'"]
+    end
+
+    it "should work for a range" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :in => (0..2)
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return(3)
+      @item.should_not be_valid
+      @item.errors[:preview_image].should == ["gungle is incorrect. It needs to be between 0 and 2, but was '3'"]
+    end
+
+    it "should validate individually" do
+      @item_class.class_eval do
+        validates_property :size, :of => [:preview_image, :other_image], :as => 9
+      end
+      @item.preview_image = "something"
+      @item.other_image = "something else"
+      @item.should_not be_valid
+      @item.errors[:preview_image].should == []
+      @item.errors[:other_image].should == ["size is incorrect. It needs to be '9', but was '14'"]
+    end
+
+    it "should include standard extra options like 'if' on mime type validation" do
+      @item_class.class_eval do
+        validates_property :size, :of => :preview_image, :as => 4, :if => :its_friday
+      end
+      @item.preview_image = '13 characters'
+      @item.should_receive(:its_friday).and_return(false)
+      @item.should be_valid
+    end
+
+    it "should allow case sensitivity to be turned off when :as is specified" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :as => 'oKtHeN', :case_sensitive => false
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return('OKTHEN')
+      @item.should be_valid
+    end
+
+    it "should allow case sensitivity to be turned off when :in is specified" do
+      @item_class.class_eval do
+        validates_property :gungle, :of => :preview_image, :in => ['oKtHeN'], :case_sensitive => false
+      end
+      @item.preview_image = "something"
+      @item.preview_image.should_receive(:gungle).and_return('OKTHEN')
+      @item.should be_valid
+    end
+
+    it "should require either :as or :in as an argument" do
+      lambda{
+        @item_class.class_eval do
+          validates_property :mime_type, :of => :preview_image
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should require :of as an argument" do
+      lambda{
+        @item_class.class_eval do
+          validates_property :mime_type, :as => 'hi/there'
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should allow for custom messages" do
+      @item_class.class_eval do
+        validates_property :size, :of => :preview_image, :as => 4, :message => "errado, seu burro"
+      end
+      @item.preview_image = "something"
+      @item.should_not be_valid
+      @item.errors[:preview_image].should  == ["errado, seu burro"]
+    end
+
+    it "should allow for custom messages including access to the property name and expected/allowed values" do
+      @item_class.class_eval do
+        validates_property :size, :of => :preview_image, :as => 4,
+          :message => proc{|actual, model| "Unlucky #{model.title}! Was #{actual}" }
+      end
+      @item.title = 'scubby'
+      @item.preview_image = "too long"
+      @item.should_not be_valid
+      @item.errors[:preview_image].should  == ["Unlucky scubby! Was 8"]
+    end
+
+  end
+
+end

data/spec/dragonfly/register_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Dragonfly::Register do
+
+  let (:register) { Dragonfly::Register.new }
+  let (:thing) { proc{ "BOO" } }
+
+  it "adds an item" do
+    register.add(:thing, thing)
+    register.get(:thing).should == thing
+  end
+
+  it "adds from a block" do
+    register.add(:thing, &thing)
+    register.get(:thing).should == thing
+  end
+
+  it "raises an error if neither are given" do
+    expect {
+      register.add(:something)
+    }.to raise_error(ArgumentError)
+  end
+
+  it "raises an error if getting one that doesn't exist" do
+    expect {
+      register.get(:thing)
+    }.to raise_error(Dragonfly::Register::NotFound)
+  end
+
+  it "allows getting with a string" do
+    register.add(:thing, thing)
+    register.get('thing').should == thing
+  end
+
+end

data/spec/dragonfly/routed_endpoint_spec.rb

@@ -15,7 +15,7 @@ describe Dragonfly::RoutedEndpoint do
     @endpoint = Dragonfly::RoutedEndpoint.new(@app) {|params, app|
       app.fetch(params[:uid])
     }
-    @app.datastore.stub!(:retrieve).with('some_uid').and_return Dragonfly::TempObject.new('wassup')
+    @uid = @app.store('wassup')
   end
 
   it "should raise an error when there are no routing parameters" do
@@ -33,20 +33,20 @@ describe Dragonfly::RoutedEndpoint do
   }.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 = response_for @endpoint.call(env_for('/blah', key => {:uid => @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'})
+    env = Rack::MockRequest.env_for("/big/buns?uid=#{@uid}", 'dragonfly.params' => {:something => 'else'})
     response = response_for @endpoint.call(env)
     response.body.should == 'wassup'
   end
-  
+
    it "should have nice inspect output" do
-     @endpoint.inspect.should =~ /<Dragonfly::RoutedEndpoint for app :test_[_\w]* >/
+     @endpoint.inspect.should =~ /<Dragonfly::RoutedEndpoint for app :default >/
    end
 
 end

data/spec/dragonfly/serializer_spec.rb

@@ -45,30 +45,30 @@ describe Dragonfly::Serializer do
     [{: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)
+      encoded = marshal_b64_encode(object)
       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
+      marshal_b64_decode(marshal_b64_encode(object)).should == object
     end
   end
 
-  describe "marshal_decode" do
+  describe "marshal_b64_decode" do
     it "should raise an error if the string passed in is empty" do
       lambda{
-        marshal_decode('')
+        marshal_b64_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')
+        marshal_b64_decode('ahasdkjfhasdkfjh')
       }.should raise_error(Dragonfly::Serializer::BadString)
     end
     describe "potentially harmful strings" do
       it "doesn't raise if not flagged to check for malicious strings" do
         class C; end
-        marshal_decode('BAhvOgZDBjoOQF9fc2VuZF9faQY').should be_a(C)
+        marshal_b64_decode('BAhvOgZDBjoOQF9fc2VuZF9faQY').should be_a(C)
       end
       ['_', 'hello', 'h2', '__send__', 'F'].each do |variable_name|
         it "raises if flagged to check for malicious strings and finds one" do
@@ -77,7 +77,7 @@ describe Dragonfly::Serializer do
           c.instance_eval{ instance_variable_set("@#{variable_name}", 1) }
           string = Dragonfly::Serializer.b64_encode(Marshal.dump(c))
           lambda{
-            marshal_decode(string, :check_malicious => true)
+            marshal_b64_decode(string, :check_malicious => true)
           }.should raise_error(Dragonfly::Serializer::MaliciousString)
         end
       end
@@ -90,27 +90,25 @@ describe Dragonfly::Serializer do
     [{'this' => 'should', 'work' => [3, 5.3, nil, {'egg' => false}]}, [], true]
   ].each do |object|
     it "should correctly json encode #{object.inspect} properly with no padding/line break" do
-      encoded = json_encode(object)
+      encoded = json_b64_encode(object)
       encoded.should be_a(String)
       encoded.should_not =~ /\n|=/
     end
+
     it "should correctly json encode and decode #{object.inspect} to the same object" do
-      json_decode(json_encode(object)).should == object
+      json_b64_decode(json_b64_encode(object)).should == object
     end
   end
 
-  describe "json_decode" do
-    it "optionally symbolizes keys" do
-      json_decode(json_encode('a' => 1), :symbolize_keys => true).should == {:a => 1}
-    end
+  describe "json_b64_decode" do
     it "should raise an error if the string passed in is empty" do
       lambda{
-        json_decode('')
+        json_b64_decode('')
       }.should raise_error(Dragonfly::Serializer::BadString)
     end
     it "should raise an error if the string passed in is gobbledeegook" do
       lambda{
-        json_decode('ahasdkjfhasdkfjh')
+        json_b64_decode('ahasdkjfhasdkfjh')
       }.should raise_error(Dragonfly::Serializer::BadString)
     end
   end

data/spec/dragonfly/server_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'rack/mock'
-require 'rack/cache'
 
 def request(app, path)
   Rack::MockRequest.new(app).get(path)
@@ -53,13 +52,9 @@ describe Dragonfly::Server do
 
       it "should return a cacheable response" do
         url = "/media/#{@job.serialize}"
-        cache = Rack::Cache.new(@server, :entitystore => 'heap:/')
-        response = request(cache, url)
-        response.status.should == 200
-        response.headers['X-Rack-Cache'].should == "miss, store"
-        response = request(cache, url)
+        response = request(@server, url)
         response.status.should == 200
-        response.headers['X-Rack-Cache'].should == "fresh"
+        response.headers['Cache-Control'].should == "public, max-age=31536000"
       end
 
       it "should return successfully even if the job is in the query string" do
@@ -113,7 +108,7 @@ describe Dragonfly::Server do
       end
 
       it "should return a 404 when the url is a well-encoded but bad array" do
-        url = "/media/#{Dragonfly::Serializer.json_encode([['egg', {'some' => 'args'}]])}"
+        url = "/media/#{Dragonfly::Serializer.json_b64_encode([['egg', {'some' => 'args'}]])}"
         response = request(@server, url)
         response.status.should == 404
         response.body.should == 'Not found'
@@ -121,21 +116,52 @@ describe Dragonfly::Server do
         response.headers['X-Cascade'].should be_nil
       end
 
-      it "should return a 403 Forbidden when someone uses fetch_file" do
-        response = request(@server, "/media/#{@app.fetch_file('/some/file.txt').serialize}")
+      it "should return a 403 Forbidden when someone uses fetch_url" do
+        response = request(@server, "/media/#{@app.fetch_url('some.url').serialize}")
         response.status.should == 403
         response.body.should == 'Forbidden'
         response.content_type.should == 'text/plain'
       end
+    end
 
-      it "should return a 403 Forbidden when someone uses fetch_url" do
-        response = request(@server, "/media/#{@app.fetch_url('some.url').serialize}")
+    describe "whitelists" do
+      def assert_ok(job)
+        response = request(@server, "/media/#{job.serialize}")
+        response.status.should == 200
+      end
+
+      def assert_forbidden(job)
+        response = request(@server, "/media/#{job.serialize}")
         response.status.should == 403
         response.body.should == 'Forbidden'
         response.content_type.should == 'text/plain'
       end
-    end
 
+      describe "fetch_file" do
+        it "should return a 403 Forbidden when someone uses fetch_file " do
+          assert_forbidden @app.fetch_file('samples/egg.png')
+        end
+
+        it "returns OK when on whitelist (using full path)" do
+          @server.add_to_fetch_file_whitelist [File.expand_path('samples/egg.png')]
+          assert_ok @app.fetch_file('samples/egg.png')
+        end
+      end
+
+      describe "fetch_url" do
+        let (:url) {'some.org/path:3000/boogie?yes=please'}
+
+        it "should return a 403 Forbidden when someone uses fetch_url " do
+          assert_forbidden @app.fetch_url(url)
+        end
+
+        it "returns OK when on whitelist (using full url)" do
+          stub_request(:get, url).to_return(:status => 200)
+          @server.add_to_fetch_url_whitelist ["http://#{url}"]
+          assert_ok @app.fetch_url(url)
+        end
+      end
+    end
   end
 
   describe "dragonfly response" do
@@ -164,52 +190,102 @@ describe Dragonfly::Server do
 
   describe "urls" do
 
-    before(:each) do
-      @app = test_app
-      @server = Dragonfly::Server.new(@app)
-      @server.url_format = '/media/:job/:basename.:format'
-      @job = @app.fetch('some_uid')
-    end
+    let (:app) { test_app }
+    let (:server) { Dragonfly::Server.new(app) }
+    let (:job) { app.fetch("some_uid") }
 
-    it "should generate the correct url when no basename/format" do
-      @server.url_for(@job).should == "/media/#{@job.serialize}"
-    end
+    describe "params" do
+      before(:each) do
+        server.url_format = '/media/:job/:zoo'
+      end
+      it "substitutes the relevant params" do
+        server.url_for(job).should == "/media/#{job.serialize}"
+      end
+      it "adds given params" do
+        server.url_for(job, :zoo => 'jokes', :on => 'me').should == "/media/#{job.serialize}/jokes?on=me"
+      end
+      it "uses the url_attr if it exists" do
+        job.url_attributes.zoo = 'hair'
+        server.url_for(job).should == "/media/#{job.serialize}/hair"
+      end
+      it "doesn't add any url_attributes that aren't needed" do
+        job.url_attributes.gump = 'flub'
+        server.url_for(job).should == "/media/#{job.serialize}"
+      end
+      it "overrides if a param is passed in" do
+        job.url_attributes.zoo = 'hair'
+        server.url_for(job, :zoo => 'dare').should == "/media/#{job.serialize}/dare"
+      end
 
-    it "should generate the correct url when there is a basename and no format" do
-      @server.url_for(@job, :basename => 'hello').should == "/media/#{@job.serialize}/hello"
-    end
+      describe "basename" do
+        before(:each) do
+          server.url_format = '/:job/:basename'
+        end
+        it "should use the name" do
+          job.url_attributes.name = 'hello.egg'
+          server.url_for(job).should == "/#{job.serialize}/hello"
+        end
+        it "should not set if neither exist" do
+          server.url_for(job).should == "/#{job.serialize}"
+        end
+      end
 
-    it "should generate the correct url when there is a basename and different format" do
-      @server.url_for(@job, :basename => 'hello', :format => 'gif').should == "/media/#{@job.serialize}/hello.gif"
+      describe "ext" do
+        before(:each) do
+          server.url_format = '/:job.:ext'
+        end
+        it "should use the name" do
+          job.url_attributes.name = 'hello.egg'
+          server.url_for(job).should == "/#{job.serialize}.egg"
+        end
+        it "should not set if neither exist" do
+          server.url_for(job).should == "/#{job.serialize}"
+        end
+      end
     end
 
-    it "should add extra params to the url query string" do
-      @server.url_for(@job, :a => 'thing', :b => 'nuther').should match_url "/media/#{@job.serialize}?a=thing&b=nuther"
-    end
+    describe "host" do
+      it "should add the host to the url if configured" do
+        server.url_host = 'http://some.server:4000'
+        server.url_for(job).should == "http://some.server:4000/#{job.serialize}"
+      end
 
-    it "should add the host to the url if configured" do
-      @server.url_host = 'http://some.server:4000'
-      @server.url_for(@job).should == "http://some.server:4000/media/#{@job.serialize}"
-    end
+      it "should add the host to the url if passed in" do
+        server.url_for(job, :host => 'https://bungle.com').should == "https://bungle.com/#{job.serialize}"
+      end
 
-    it "should add the host to the url if passed in" do
-      @server.url_for(@job, :host => 'https://bungle.com').should == "https://bungle.com/media/#{@job.serialize}"
+      it "should favour the passed in host" do
+        server.url_host = 'http://some.server:4000'
+        server.url_for(job, :host => 'https://smeedy').should == "https://smeedy/#{job.serialize}"
+      end
     end
 
-    it "should favour the passed in host" do
-      @server.url_host = 'http://some.server:4000'
-      @server.url_for(@job, :host => 'https://smeedy').should == "https://smeedy/media/#{@job.serialize}"
+    describe "path_prefix" do
+      before do
+        server.url_format = '/media/:job'
+      end
+
+      it "adds the path_prefix to the url if configured" do
+        server.url_path_prefix = '/logs'
+        server.url_for(job).should == "/logs/media/#{job.serialize}"
+      end
+
+      it "favours the passed in path_prefix" do
+        server.url_path_prefix = '/logs'
+        server.url_for(job, :path_prefix => '/bugs').should == "/bugs/media/#{job.serialize}"
+      end
+
+      it "goes after the host" do
+        server.url_for(job, :path_prefix => '/bugs', :host => 'http://wassup').should == "http://wassup/bugs/media/#{job.serialize}"
+      end
     end
 
     describe "Denial of Service protection" do
       before(:each) do
-        @app = test_app
-        @server = Dragonfly::Server.new(@app)
-        @server.protect_from_dos_attacks = true
-        @job = @app.fetch('some_uid')
+        server.protect_from_dos_attacks = true
       end
       it "should generate the correct url" do
-        @server.url_for(@job).should == "/#{@job.serialize}?sha=#{@job.sha}"
+        server.url_for(job).should == "/#{job.serialize}?sha=#{job.sha}"
       end
     end
 
@@ -219,7 +295,7 @@ describe Dragonfly::Server do
 
     before(:each) do
       @app = test_app
-      @app.generator.add(:test){ "TEST" }
+      @app.add_generator(:test){|content| content.update("TEST") }
       @server = Dragonfly::Server.new(@app)
       @job = @app.generate(:test)
     end
@@ -258,7 +334,7 @@ describe Dragonfly::Server do
       end
 
       it "should not apply the job if not asked to" do
-        @app.generator.should_not_receive(:generate)
+        @app.generators.get(:test).should_not_receive(:call)
         response = request(@server, "/#{@job.serialize}")
       end
     end