goliath 0.9.0

data/spec/unit/rack/default_mime_type_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'goliath/env'
+require 'goliath/rack/default_mime_type'
+
+describe Goliath::Rack::DefaultMimeType do
+  let(:app) { mock('app').as_null_object }
+  let(:dmt) { Goliath::Rack::DefaultMimeType.new(app) }
+  let(:env) do
+    env = Goliath::Env.new
+    env['status'] = mock('status').as_null_object
+    env
+  end
+
+  context 'accept header cleanup' do
+    it 'handles a nil header' do
+      env['HTTP_ACCEPT'] = nil
+      lambda { dmt.call(env) }.should_not raise_error
+    end
+
+    %w(gzip deflate compressed identity).each do |type|
+      it "removes #{type} from the accept header" do
+        env['HTTP_ACCEPT'] = "text/html, #{type}, text/javascript"
+        dmt.call(env)
+        env['HTTP_ACCEPT'].should == 'text/html, text/javascript'
+      end
+    end
+
+    it 'sets to */* if all entries removed' do
+      env['HTTP_ACCEPT'] = 'identity'
+      dmt.call(env)
+      env['HTTP_ACCEPT'].should == '*/*'
+    end
+  end
+end

data/spec/unit/rack/formatters/json_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'goliath/rack/formatters/json'
+
+describe Goliath::Rack::Formatters::JSON do
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Formatters::JSON.new('my app') }.should_not raise_error Exception
+  end
+
+  describe 'with a formatter' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @js = Goliath::Rack::Formatters::JSON.new(@app)
+    end
+
+    it 'checks content type for application/json' do
+      @js.json_response?({'Content-Type' => 'application/json'}).should be_true
+    end
+
+    it 'returns false for non-applicaton/json types' do
+      @js.json_response?({'Content-Type' => 'application/xml'}).should be_false
+    end
+
+    it 'calls the app with the provided environment' do
+      env_mock = mock('env').as_null_object
+      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      @js.call(env_mock)
+    end
+
+    it 'formats the body into json if content-type is json' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      lambda { Yajl::Parser.parse(body.first)['a'].should == 1 }.should_not raise_error Exception
+    end
+
+    it "doesn't format to json if the type is not application/json" do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+
+      Yajl::Parser.should_not_receive(:encode)
+      status, header, body = @js.call({})
+      body[:a].should == 1
+    end
+
+    it 'returns the status and headers' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+
+      Yajl::Parser.should_not_receive(:encode)
+      status, header, body = @js.call({})
+      status.should == 200
+      header.should == {'Content-Type' => 'application/xml'}
+    end
+  end
+end
+

data/spec/unit/rack/formatters/xml_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'goliath/rack/formatters/xml'
+require 'nokogiri'
+
+describe Goliath::Rack::Formatters::XML do
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Formatters::XML.new('my app') }.should_not raise_error Exception
+  end
+
+  describe 'with a formatter' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @xml = Goliath::Rack::Formatters::XML.new(@app)
+    end
+
+    it 'checks content type for application/xml' do
+      @xml.xml_response?({'Content-Type' => 'application/xml'}).should be_true
+    end
+
+    it 'returns false for non-applicaton/xml types' do
+      @xml.xml_response?({'Content-Type' => 'application/json'}).should be_false
+    end
+
+    it 'calls the app with the provided environment' do
+      env_mock = mock('env').as_null_object
+      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      @xml.call(env_mock)
+    end
+
+    it 'formats the body into xml if content-type is xml' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+
+      status, header, body = @xml.call({})
+      lambda { Nokogiri.parse(body.first).search('a').inner_text.should == '1' }.should_not raise_error Exception
+    end
+
+    it 'generates arrays correctly' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, [1, 2]])
+
+      status, header, body = @xml.call({})
+      lambda {
+        doc = Nokogiri.parse(body.first)
+        doc.search('item').first.inner_text.should == '1'
+        doc.search('item').last.inner_text.should == '2'
+      }.should_not raise_error Exception
+    end
+
+    it "doesn't format to xml if the type is not application/xml" do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      @xml.should_not_receive(:to_xml)
+      status, header, body = @xml.call({})
+      body[:a].should == 1
+    end
+
+    it 'returns the status and headers' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      @xml.should_not_receive(:to_xml)
+      status, header, body = @xml.call({})
+      status.should == 200
+      header.should == {'Content-Type' => 'application/json'}
+    end
+  end
+end
+

data/spec/unit/rack/heartbeat_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'goliath/rack/heartbeat'
+require 'goliath/env'
+
+describe Goliath::Rack::Heartbeat do
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Heartbeat.new('my app') }.should_not raise_error(Exception)
+  end
+
+  describe 'with the middleware' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @env = Goliath::Env.new
+      @env['status'] = mock('status').as_null_object
+      @hb = Goliath::Rack::Heartbeat.new(@app)
+    end
+
+    it 'allows /status as a path prefix' do
+      @app.should_receive(:call)
+      @env['PATH_INFO'] = '/status_endpoint'
+      @hb.call(@env)
+    end
+
+    it "doesn't call the app when request /status" do
+      @app.should_not_receive(:call)
+      @env['PATH_INFO'] = '/status'
+      @hb.call(@env)
+    end
+
+    it 'returns the status, headers and body from the app on non-/status' do
+      @env['PATH_INFO'] = '/v1'
+      @app.should_receive(:call).and_return([200, {'a' => 'b'}, {'c' => 'd'}])
+      status, headers, body = @hb.call(@env)
+      status.should == 200
+      headers.should == {'a' => 'b'}
+      body.should == {'c' => 'd'}
+    end
+
+    it 'returns the correct status, headers and body on /status' do
+      @env['PATH_INFO'] = '/status'
+      status, headers, body = @hb.call(@env)
+      status.should == 200
+      headers.should == {}
+      body.should == 'OK'
+    end
+  end
+end

data/spec/unit/rack/params_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'goliath/rack/params'
+
+describe Goliath::Rack::Params do
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Params.new('my app') }.should_not raise_error(Exception)
+  end
+
+  describe 'with middleware' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @env = {}
+      @params = Goliath::Rack::Params.new(@app)
+    end
+
+    it 'parses the query string' do
+      @env['QUERY_STRING'] = 'foo=bar&baz=bonkey'
+
+      ret = @params.retrieve_params(@env)
+      ret['foo'].should == 'bar'
+      ret['baz'].should == 'bonkey'
+    end
+
+    it 'parses the post body' do
+      @env['rack.input'] = StringIO.new
+      @env['rack.input'] << "foo=bar&baz=bonkey"
+      @env['rack.input'].rewind
+
+      ret = @params.retrieve_params(@env)
+      ret['foo'].should == 'bar'
+      ret['baz'].should == 'bonkey'
+    end
+
+    it 'parses arrays of data' do
+      @env['QUERY_STRING'] = 'foo=bar&foo=baz&foo=foos'
+
+      ret = @params.retrieve_params(@env)
+      ret['foo'].is_a?(Array).should be_true
+      ret['foo'].length.should == 3
+      ret['foo'].should == %w(bar baz foos)
+    end
+
+    it 'combines query string and post body params' do
+      @env['QUERY_STRING'] = "baz=bar"
+
+      @env['rack.input'] = StringIO.new
+      @env['rack.input'] << "foos=bonkey"
+      @env['rack.input'].rewind
+
+      ret = @params.retrieve_params(@env)
+      ret['baz'].should == 'bar'
+      ret['foos'].should == 'bonkey'
+    end
+
+    it 'handles empty query and post body' do
+      ret = @params.retrieve_params(@env)
+      ret.is_a?(Hash).should be_true
+      ret.should be_empty
+    end
+
+    it 'prefers post body over query string' do
+      @env['QUERY_STRING'] = "foo=bar1&baz=bar"
+
+      @env['rack.input'] = StringIO.new
+      @env['rack.input'] << "foo=bar2&baz=bonkey"
+      @env['rack.input'].rewind
+
+      ret = @params.retrieve_params(@env)
+      ret['foo'].should == 'bar2'
+      ret['baz'].should == 'bonkey'
+    end
+
+    it 'sets the params into the environment' do
+      @app.should_receive(:call).with do |app_env|
+        app_env.has_key?('params').should be_true
+        app_env['params']['a'].should == 'b'
+      end
+
+      @env['QUERY_STRING'] = "a=b"
+      @params.call(@env)
+    end
+
+    it 'returns status, headers and body from the app' do
+      app_headers = {'Content-Type' => 'hash'}
+      app_body = {:a => 1, :b => 2}
+      @app.should_receive(:call).and_return([200, app_headers, app_body])
+
+      status, headers, body = @params.call(@env)
+      status.should == 200
+      headers.should == app_headers
+      body.should == app_body
+    end
+  end
+end

data/spec/unit/rack/render_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'goliath/rack/render'
+require 'goliath/goliath'
+
+describe Goliath::Rack::Render do
+  let(:env) do
+    env = Goliath::Env.new
+    env['params'] = {}
+    env
+  end
+
+  let(:app) { mock('app').as_null_object }
+  let(:render) { Goliath::Rack::Render.new(app) }
+
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Render.new('my app') }.should_not raise_error(Exception)
+  end
+
+  it 'returns the status, body and app headers' do
+    app_body = {'c' => 'd'}
+
+    app.should_receive(:call).and_return([200, {'a' => 'b'}, app_body])
+    status, headers, body = render.call(env)
+
+    status.should == 200
+    headers['a'].should == 'b'
+    body.should == app_body
+  end
+
+  describe 'Vary' do
+    it 'adds Accept to provided Vary header' do
+      app.should_receive(:call).and_return([200, {'Vary' => 'Cookie'}, {}])
+      status, headers, body = render.call(env)
+      headers['Vary'].should == 'Cookie,Accept'
+    end
+
+    it 'sets Accept if there is no Vary header' do
+      app.should_receive(:call).and_return([200, {}, {}])
+      status, headers, body = render.call(env)
+      headers['Vary'].should == 'Accept'
+    end
+  end
+
+  describe 'Content-Type' do
+    before(:each) do
+      app.should_receive(:call).and_return([200, {}, {}])
+    end
+
+    describe 'from header' do
+      %w(application/json text/html application/rss+xml application/xml).each do |type|
+        it "handles content type for #{type}" do
+          env['HTTP_ACCEPT'] = type
+          status, headers, body = render.call(env)
+          headers['Content-Type'].should =~ /^#{Regexp.escape(type)}/
+        end
+      end
+    end
+
+    describe 'from URL param' do
+      {'rss' => 'application/rss+xml',
+       'xml' => 'application/xml',
+       'html' => 'text/html',
+       'json' => 'application/json'}.each_pair do |format, content_type|
+        it "converts #{format} to #{content_type}" do
+          env['params']['format'] = format
+          status, headers, body = render.call(env)
+          headers['Content-Type'].should =~ /^#{Regexp.escape(content_type)}/
+        end
+      end
+    end
+
+    it 'prefers URL format over header' do
+      env['HTTP_ACCEPT'] = 'application/xml'
+      env['params']['format'] = 'json'
+      status, headers, body = render.call(env)
+      headers['Content-Type'].should =~ %r{^application/json}
+    end
+
+    describe 'charset' do
+      it 'is set if not present' do
+        env['params']['format'] = 'json'
+        status, headers, body = render.call(env)
+        headers['Content-Type'].should =~ /; charset=utf-8$/
+      end
+    end
+  end
+end

data/spec/unit/rack/validation/boolean_value_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'goliath/rack/validation/boolean_value'
+
+describe Goliath::Rack::Validation::BooleanValue do
+  before(:each) do
+    @app = mock('app').as_null_object
+    @env = {'params' => {}}
+  end
+
+  describe 'with middleware' do
+    before(:each) do
+      @bv = Goliath::Rack::Validation::BooleanValue.new(@app, {:key => 'id', :default => true})
+    end
+
+    it 'uses the default if the key is not present' do
+      @bv.call(@env)
+      @env['params']['id'].should == true
+    end
+
+    it 'uses the default if the key is nil' do
+      @env['params']['id'] = nil
+      @bv.call(@env)
+      @env['params']['id'].should == true
+    end
+
+    it 'uses the default if the key is blank' do
+      @env['params']['id'] = ""
+      @bv.call(@env)
+      @env['params']['id'].should == true
+    end
+
+    it 'a random value is false' do
+      @env['params']['id'] = 'blarg'
+      @bv.call(@env)
+      @env['params']['id'].should == false
+    end
+
+    %w(t true TRUE T 1).each do |type|
+      it "considers #{type} true" do
+        @env['params']['id'] = type
+        @bv.call(@env)
+        @env['params']['id'].should == true
+      end
+    end
+
+    %w(f false FALSE F 0).each do |type|
+      it "considers #{type} false" do
+        @env['params']['id'] = type
+        @bv.call(@env)
+        @env['params']['id'].should == false
+      end
+    end
+  end
+end

data/spec/unit/rack/validation/default_params_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'goliath/rack/validation/default_params'
+
+describe Goliath::Rack::Validation::DefaultParams do
+  it 'accepts an app' do
+    opts = {:defaults => ['title'], :key => 'fields'}
+    lambda { Goliath::Rack::Validation::DefaultParams.new('my app', opts) }.should_not raise_error(Exception)
+  end
+
+  it 'requires defaults to be set' do
+    lambda { Goliath::Rack::Validation::DefaultParams.new('my app', {:key => 'test'}) }.should raise_error(Exception)
+  end
+
+  it 'requires key to be set' do
+    lambda { Goliath::Rack::Validation::DefaultParams.new('my app', {:defaults => 'test'}) }.should raise_error(Exception)
+  end
+
+  describe 'with middleware' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @env = {'params' => {}}
+      @rf = Goliath::Rack::Validation::DefaultParams.new(@app, {:key => 'fl', :defaults => ['title', 'link']})
+    end
+
+    it 'passes through provided key if set' do
+      @env['params']['fl'] = ['pubdate', 'content']
+      @rf.call(@env)
+      @env['params']['fl'].should == ['pubdate', 'content']
+    end
+
+    it 'sets defaults if no key set' do
+      @rf.call(@env)
+      @env['params']['fl'].should == ['title', 'link']
+    end
+
+    it 'sets defaults if no key set' do
+      @env['params']['fl'] = nil
+      @rf.call(@env)
+      @env['params']['fl'].should == ['title', 'link']
+    end
+
+    it 'sets defaults if no key is empty' do
+      @env['params']['fl'] = []
+      @rf.call(@env)
+      @env['params']['fl'].should == ['title', 'link']
+    end
+
+    it 'handles a single item' do
+      @env['params']['fl'] = 'title'
+      @rf.call(@env)
+      @env['params']['fl'].should == 'title'
+    end
+
+    it 'handles a blank string' do
+      @env['params']['fl'] = ''
+      @rf.call(@env)
+      @env['params']['fl'].should == ['title', 'link']
+    end
+
+    it 'returns the app status, headers and body' do
+      app_headers = {'Content-Type' => 'asdf'}
+      app_body = {'a' => 'b'}
+      @app.should_receive(:call).and_return([200, app_headers, app_body])
+
+      status, headers, body = @rf.call(@env)
+      status.should == 200
+      headers.should == app_headers
+      body.should == app_body
+    end
+  end
+end