oahu-dragonfly 0.8.2

data/spec/dragonfly/loggable_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+class Testoast
+  include Dragonfly::Loggable
+end
+
+describe Dragonfly::Loggable do
+  
+  before(:each) do
+    @object = Testoast.new
+  end
+
+  shared_examples_for "common" do
+    it "should return a log" do
+      @object.log.should be_a(Logger)
+    end
+    it "should cache the log" do
+      @object.log.should == @object.log
+    end
+  end
+
+  describe "without being set" do
+    it "should return the log object as nil" do
+      @object.log_object.should be_nil
+    end
+    it_should_behave_like 'common'
+  end
+
+  describe "when set" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @object.log = @log
+    end
+    it "should return the new log" do
+      @object.log.should == @log
+    end
+    it "should return the log object" do
+      @object.log_object.should == @log
+    end
+    it_should_behave_like 'common'
+  end
+
+  describe "when set as a proc" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @object.log = proc{ @log }
+    end
+    it "should return the new log" do
+      @object.log.should == @log
+    end
+    it "should return the log object" do
+      @object.log_object.should be_a(Proc)
+    end
+    it "should allow for changing logs" do
+      logs = [@log]
+      @object.log = proc{ logs[0] }
+      @object.log.should == @log
+      
+      new_log = Logger.new($stdout)
+      logs[0] = new_log
+      
+      @object.log.should == new_log
+    end
+    it_should_behave_like 'common'
+  end
+  
+  describe "sharing logs" do
+    before(:each) do
+      @log = Logger.new($stdout)
+      @obj1 = Testoast.new
+      @obj2 = Testoast.new
+    end
+    it "should enable sharing logs" do
+      @obj1.log = proc{ @log }
+      @obj2.use_same_log_as(@obj1)
+      @obj2.log.should == @log
+    end
+  end
+
+end

data/spec/dragonfly/middleware_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'rack'
+
+def dummy_rack_app
+  lambda{|env| [200, {"Content-Type" => "text/html"}, ["dummy_rack_app body"]] }
+end
+
+describe Dragonfly::Middleware do
+
+  def make_request(app, url)
+    Rack::MockRequest.new(app).get(url)
+  end
+
+  before(:each) do
+    @stack = Rack::Builder.new do
+      use Dragonfly::Middleware, :images
+      run dummy_rack_app
+    end
+  end
+
+  it "should pass through if the app returns X-Cascade: pass" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [404, {"Content-Type" => 'text/plain', 'X-Cascade' => 'pass'}, ['Not found']]
+    )
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.body.should == 'dummy_rack_app body'
+    response.status.should == 200
+  end
+
+  it "should return a 404 if the app returns a 404" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [404, {"Content-Type" => 'text/plain'}, ['Not found']]
+    )
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.status.should == 404
+  end
+
+  it "should return as per the dragonfly app if the app returns a 200" do
+    Dragonfly[:images].should_receive(:call).and_return(
+      [200, {"Content-Type" => 'text/plain'}, ['ABCD']]
+    )
+    response = make_request(@stack, '/media/hello.png?howare=you')
+    response.status.should == 200
+    response.body.should == 'ABCD'
+  end
+  
+end

data/spec/dragonfly/routed_endpoint_spec.rb

@@ -0,0 +1,48 @@
+require '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 '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/server_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+require 'rack/mock'
+require 'rack/cache'
+
+def request(app, path)
+  Rack::MockRequest.new(app).get(path)
+end
+
+describe Dragonfly::Server do
+
+  describe "responses" do
+
+    before(:each) do
+      @app = test_app
+      @uid = @app.store('HELLO THERE')
+      @server = Dragonfly::Server.new(@app)
+      @server.url_format = '/media/:job'
+      @job = @app.fetch(@uid)
+    end
+
+    after(:each) do
+      @app.destroy(@uid)
+    end
+
+    describe "successful urls" do
+      before(:each) do
+        @server.url_format = '/media/:job/:name.:format'
+      end
+
+      [
+        '',
+        '/name',
+        '/name.ext'
+      ].each do |suffix|
+
+        it "should return successfully when given the url with suffix #{suffix.inspect}" do
+          url = "/media/#{@job.serialize}#{suffix}"
+          response = request(@server, url)
+          response.status.should == 200
+          response.body.should == 'HELLO THERE'
+          response.content_type.should == 'application/octet-stream'
+        end
+
+      end
+
+      it "should return successfully with the correct sha given and protection on" do
+        @server.protect_from_dos_attacks = true
+        url = "/media/#{@job.serialize}?sha=#{@job.sha}"
+        response = request(@server, url)
+        response.status.should == 200
+        response.body.should == 'HELLO THERE'
+      end
+
+    end
+
+    it "should return successfully even if the job is in the query string" do
+      @server.url_format = '/'
+      url = "/?job=#{@job.serialize}"
+      response = request(@server, url)
+      response.status.should == 200
+      response.body.should == 'HELLO THERE'
+    end
+
+    it "should return a 400 if no sha given but protection on" do
+      @server.protect_from_dos_attacks = true
+      url = "/media/#{@job.serialize}"
+      response = request(@server, url)
+      response.status.should == 400
+    end
+
+    it "should return a 400 if wrong sha given and protection on" do
+      @server.protect_from_dos_attacks = true
+      url = "/media/#{@job.serialize}?sha=asdfs"
+      response = request(@server, url)
+      response.status.should == 400
+    end
+
+    ['/media', '/media/'].each do |url|
+      it "should return a 404 when no job given, e.g. #{url.inspect}" do
+        response = request(@server, url)
+        response.status.should == 404
+        response.body.should == 'Not found'
+        response.content_type.should == 'text/plain'
+        response.headers['X-Cascade'].should == 'pass'
+      end
+    end
+
+    it "should return a 404 when the url matches but doesn't correspond to a job" do
+      response = request(@server, '/media/sadhfasdfdsfsdf')
+      response.status.should == 404
+      response.body.should == 'Not found'
+      response.content_type.should == 'text/plain'
+      response.headers['X-Cascade'].should be_nil
+    end
+
+    it "should return a 404 when the url isn't known at all" do
+      response = request(@server, '/jfasd/dsfa')
+      response.status.should == 404
+      response.body.should == 'Not found'
+      response.content_type.should == 'text/plain'
+      response.headers['X-Cascade'].should == 'pass'
+    end
+
+    it "should return a 404 when the url is a well-encoded but bad array" do
+      url = "/media/#{Dragonfly::Serializer.marshal_encode([[:egg, {:some => 'args'}]])}"
+      response = request(@server, url)
+      response.status.should == 404
+      response.body.should == 'Not found'
+      response.content_type.should == 'text/plain'
+      response.headers['X-Cascade'].should be_nil
+    end
+
+    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.status.should == 200
+      response.headers['X-Rack-Cache'].should == "fresh"
+    end
+
+  end
+
+  describe "dragonfly response" do
+    before(:each) do
+      @app = test_app
+      @server = Dragonfly::Server.new(@app)
+      @server.url_format = '/media/:job'
+    end
+
+    it "should return a simple text response" do
+      request(@server, '/dragonfly').should be_a_text_response
+    end
+
+    it "should be configurable" do
+      @server.dragonfly_url = '/hello'
+      request(@server, '/hello').should be_a_text_response
+      request(@server, '/dragonfly').status.should == 404
+    end
+
+    it "should be possible to turn it off" do
+      @server.dragonfly_url = nil
+      request(@server, '/').status.should == 404
+      request(@server, '/dragonfly').status.should == 404
+    end
+  end
+
+  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
+
+    it "should generate the correct url when no basename/format" do
+      @server.url_for(@job).should == "/media/#{@job.serialize}"
+    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
+
+    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"
+    end
+
+    it "should add extra params to the url query string" do
+      @server.url_for(@job, :a => 'thing', :b => 'nuther').should == "/media/#{@job.serialize}?a=thing&b=nuther"
+    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/media/#{@job.serialize}"
+    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}"
+    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')
+      end
+      it "should generate the correct url" do
+        @server.url_for(@job).should == "/#{@job.serialize}?sha=#{@job.sha}"
+      end
+    end
+
+  end
+
+  describe "before_serve callback" do
+
+    context "with no stop in the callback" do
+      before(:each) do
+        @app = test_app
+        @app.generator.add(:test){ "TEST" }
+        @server = Dragonfly::Server.new(@app)
+        @job = @app.generate(:test)
+        @x = x = ""
+        @server.before_serve do |job, env|
+          x << job.data
+        end
+      end
+
+      it "should be called before serving" do
+        response = request(@server, "/#{@job.serialize}")
+        response.body.should == 'TEST'
+        @x.should == 'TEST'
+      end
+
+      it "should not be called before serving a 404 page" do
+        response = request(@server, "blah")
+        response.status.should == 404
+        @x.should == ""
+      end
+    end
+
+    context "with a throw :halt in the callback" do
+      before(:each) do
+        @app = test_app
+        @app.generator.add(:test){ "TEST" }
+        @server = Dragonfly::Server.new(@app)
+        @job = @app.generate(:test)
+        @x = x = ""
+        @server.before_serve do |job, env|
+          x << job.data
+          throw :halt, [200, {}, 'hello']
+        end
+      end
+      it 'return the response instead the job.result' do
+        response = request(@server, "/#{@job.serialize}")
+        response.body.should == 'hello'
+        @x.should == 'TEST'
+      end
+    end
+
+  end
+
+  describe "after_serve callback" do
+
+    before(:each) do
+      @app = test_app
+      @app.generator.add(:test){ "TEST" }
+      @server = Dragonfly::Server.new(@app)
+      @job = @app.generate(:test)
+      @x = x = ""
+      @server.after_serve do |job, env|
+        x << job.data
+      end
+    end
+
+    it "should be called after serving" do
+      response = request(@server, "/#{@job.serialize}")
+      response.body.should == 'TEST'
+      @x.should == 'TEST'
+    end
+
+    it "should not be called after serving a 404 page" do
+      response = request(@server, "blah")
+      response.status.should == 404
+      @x.should == ""
+    end
+
+  end
+
+end