goliath 0.9.1 → 0.9.2

data/spec/integration/trace_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../', 'examples/echo')
+
+
+describe Goliath::Rack::Tracer do
+  let(:err) { Proc.new { fail "API request failed" } }
+
+  it 'injects a trace param on a 200 (via async callback)' do
+    with_api(Echo) do
+      get_request({:query => {:echo => 'test'}}, err) do |c|
+        c.response_header['X_POSTRANK'].should =~ /trace\.start: [\d\.]+, total: [\d\.]+/
+      end
+    end
+  end
+
+  it 'injects a trace param on a 400 (direct callback)' do
+    with_api(Echo) do
+      get_request({}, err) do |c|
+        c.response_header['X_POSTRANK'].should =~ /trace\.start: [\d\.]+, total: [\d\.]+/
+      end
+    end
+  end
+end

data/spec/integration/valid_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'json'
 require File.join(File.dirname(__FILE__), '../../', 'examples/valid')
 
 describe Valid do
@@ -20,3 +21,23 @@ describe Valid do
     end
   end
 end
+
+class ValidationErrorInEndpoint < Goliath::API
+  def response(env)
+    raise Goliath::Validation::Error.new(420, 'You Must Chill')
+  end
+end
+
+describe ValidationErrorInEndpoint do
+  let(:err) { Proc.new { fail "API request failed" } }
+
+  it 'handles Goliath::Validation::Error correctly' do
+    with_api(ValidationErrorInEndpoint) do
+      get_request({}, err) do |c|
+        c.response.should == '[:error, "You Must Chill"]'
+        c.response_header.status.should == 420
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -5,8 +5,10 @@ Bundler.require
 
 require 'goliath/test_helper'
 
+Goliath.env = :test
+
 RSpec.configure do |c|
   c.include Goliath::TestHelper, :example_group => {
     :file_path => /spec\/integration/
   }
-end
+end

data/spec/unit/api_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'goliath/api'
+
+describe Goliath::API do
+
+  DummyApi = Class.new(Goliath::API)
+
+  describe 'middlewares' do
+    it "doesn't change after multi calls" do
+      2.times { Goliath::API.should have(2).middlewares }
+    end
+  end
+
+  describe ".maps?" do
+    context "when not using maps" do
+      it "returns false" do
+        DummyApi.maps?.should be_false
+      end
+    end
+
+    context "when using maps" do
+      it "returns true" do
+        DummyApi.map "/foo"
+        DummyApi.maps?.should be_true
+      end
+    end
+  end
+
+
+end

data/spec/unit/rack/builder_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Goliath::Rack::Builder do
+
+  SimpleMiddleware = Class.new
+  NestedMiddleware = Class.new
+
+  class NestedClassApi < Goliath::API
+    use NestedMiddleware, 'class'
+  end
+
+  class NestedBlockApi < Goliath::API
+    use NestedMiddleware, 'block'
+  end
+
+  class SimpleRouter < Goliath::API
+    use SimpleMiddleware
+    map "/class", NestedClassApi
+    map "/block" do
+      run NestedBlockApi.new
+    end
+  end
+
+  let(:router) { SimpleRouter.new }
+
+  describe '.build' do
+
+    it "builds rack app for api" do
+      Rack::Builder.should_receive(:app)
+      Goliath::Rack::Builder.build(router.class, router)
+    end
+
+    it "loads rack/goliath middlewares" do
+      SimpleMiddleware.should_receive(:new)
+      Goliath::Rack::Builder.build(router.class, router)
+    end
+
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'goliath/rack/formatters/plist'
+
+describe Goliath::Rack::Formatters::PLIST do
+  # this sucks, but I had install problems with nokogiri-plist
+  # and I would rather not use an alternative library that requires libxml or rexml
+  before(:all) do
+    class Object
+      def to_plist(*args) "plist: #{to_s}" end
+    end
+  end
+
+  after(:all) do
+    class Object
+      undef to_plist
+    end
+  end
+
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Formatters::PLIST.new('my app') }.should_not raise_error
+  end
+
+  describe 'with a formatter' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @m = Goliath::Rack::Formatters::PLIST.new(@app)
+    end
+
+    it 'formats the body into plist if content-type is plist' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/x-plist'}, {:a => 1, :b => 2}])
+
+      status, header, body = @m.call({})
+      body.should == ["plist: {:a=>1, :b=>2}"]
+    end
+
+    it "doesn't format to plist if the type is not plist" do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      status, header, body = @m.call({})
+      status.should == 200
+      header.should == {'Content-Type' => 'application/xml'}
+
+      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}])
+
+      status, header, body = @m.call({})
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'goliath/rack/formatters/yaml'
+
+describe Goliath::Rack::Formatters::YAML do
+  it 'accepts an app' do
+    lambda { Goliath::Rack::Formatters::YAML.new('my app') }.should_not raise_error
+  end
+
+  describe 'with a formatter' do
+    before(:each) do
+      @app = mock('app').as_null_object
+      @ym = Goliath::Rack::Formatters::YAML.new(@app)
+    end
+
+    it 'checks content type for text/yaml' do
+      @ym.yaml_response?({'Content-Type' => 'text/yaml'}).should be_true
+    end
+
+    it 'returns false for non-applicaton/yaml types' do
+      @ym.yaml_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}])
+      @ym.call(env_mock)
+    end
+
+    it 'formats the body into yaml if content-type is yaml' do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'text/yaml'}, {:a => 1, :b => 2}])
+
+      status, header, body = @ym.call({})
+      lambda { YAML.load(body.first)[:a].should == 1 }.should_not raise_error
+    end
+
+    it "doesn't format to yaml if the type is not text/yaml" do
+      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+
+      YAML.should_not_receive(:encode)
+      status, header, body = @ym.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}])
+
+      YAML.should_not_receive(:encode)
+      status, header, body = @ym.call({})
+      status.should == 200
+      header.should == {'Content-Type' => 'application/xml'}
+    end
+  end
+end

data/spec/unit/rack/params_spec.rb

@@ -19,6 +19,7 @@ describe Goliath::Rack::Params do
 
       ret = @params.retrieve_params(@env)
       ret['foo'].should == 'bar'
+      ret[:foo].should == 'bar'
       ret['baz'].should == 'bonkey'
     end
 
@@ -38,6 +39,8 @@ describe Goliath::Rack::Params do
       ret['foo'].should == 'bar'
       ret['baz'].should == 'bonkey'
       ret['zonk'].should == {'donk' => 'monk'}
+      ret[:zonk].should == {'donk' => 'monk'}
+      ret[:zonk][:donk].should == 'monk'
     end
 
     it 'parses arrays of data' do
@@ -47,6 +50,7 @@ describe Goliath::Rack::Params do
       ret['foo'].is_a?(Array).should be_true
       ret['foo'].length.should == 3
       ret['foo'].should == %w(bar baz foos)
+      ret[:foo].should == %w(bar baz foos)
     end
 
     it 'parses multipart data' do
@@ -67,6 +71,7 @@ Berry\r
 
       ret = @params.retrieve_params(@env)
       ret['submit-name'].should == 'Larry'
+      ret[:"submit-name"].should == 'Larry'
       ret['submit-name-with-content'].should == 'Berry'
     end
 
@@ -140,8 +145,25 @@ Berry\r
 
         ret = @params.retrieve_params(@env)
         ret['foo'].should == 'bar'
+        ret[:foo].should == 'bar'
+      end
+      
+      it "handles empty input gracefully on JSON" do
+        @env['CONTENT_TYPE'] = 'application/json'
+        @env['rack.input'] = StringIO.new
+        
+        ret = @params.retrieve_params(@env)
+        ret.should be_empty
       end
 
+      it "raises a BadRequestError on invalid JSON" do
+        @env['CONTENT_TYPE'] = 'application/json'
+        @env['rack.input'] = StringIO.new
+        @env['rack.input'] << %|{"foo":"bar" BORKEN}|
+        @env['rack.input'].rewind
+
+        lambda{ @params.retrieve_params(@env) }.should raise_error(Goliath::Validation::BadRequestError)
+      end
 
       it "doesn't parse unknown content types" do
         @env['CONTENT_TYPE'] = 'fake/form -- type'

data/spec/unit/rack/render_spec.rb

@@ -41,13 +41,21 @@ describe Goliath::Rack::Render do
     end
   end
 
+  CONTENT_TYPES = {
+    'rss' => 'application/rss+xml',
+    'xml' => 'application/xml',
+    'html' => 'text/html',
+    'json' => 'application/json',
+    'yaml' => 'text/yaml',
+  }
+
   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|
+      CONTENT_TYPES.values.each do |type|
         it "handles content type for #{type}" do
           env['HTTP_ACCEPT'] = type
           status, headers, body = render.call(env)
@@ -57,10 +65,7 @@ describe Goliath::Rack::Render do
     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|
+      CONTENT_TYPES.each_pair do |format, content_type|
         it "converts #{format} to #{content_type}" do
           env['params']['format'] = format
           status, headers, body = render.call(env)

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

@@ -30,7 +30,7 @@ describe Goliath::Rack::Validation::NumericRange do
     end
 
     it 'uses the first value, if the value is an array' do
-      @env['params']['id'] = [10,11,12]
+      @env['params']['id'] = [10, 11, 12]
       @nr.call(@env)
       @env['params']['id'].should == 10
     end
@@ -58,6 +58,13 @@ describe Goliath::Rack::Validation::NumericRange do
     end
   end
 
+  it 'converts to a float with :as => Float' do
+    nr = Goliath::Rack::Validation::NumericRange.new(@app, {:key => 'id', :min => 1.1, :as => Float})
+    @env['params']['id'] = 1.5
+    nr.call(@env)
+    @env['params']['id'].should == 1.5
+  end
+
   it 'raises error if key is not set' do
     lambda { Goliath::Rack::Validation::NumericRange.new('app', {:min => 5}) }.should raise_error
   end

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

@@ -3,7 +3,11 @@ require 'goliath/rack/validation/request_method'
 
 describe Goliath::Rack::Validation::RequestMethod do
   before(:each) do
+    @app_headers = {'Content-Type' => 'asdf'}
+    @app_body = {'a' => 'b'}
+
     @app = mock('app').as_null_object
+    @app.stub!(:call).and_return([200, @app_headers, @app_body])
   end
 
   it 'accepts an app' do
@@ -18,25 +22,21 @@ describe Goliath::Rack::Validation::RequestMethod do
 
     it 'raises error if method is invalid' do
       @env['REQUEST_METHOD'] = 'fubar'
-      lambda { @rm.call(@env) }.should raise_error(Goliath::Validation::Error)
+      @rm.call(@env).should == [405, {'Allow' => 'GET, POST'}, {:error => "Invalid request method"}]
     end
 
     it 'allows valid methods through' do
       @env['REQUEST_METHOD'] = 'GET'
-      lambda { @rm.call(@env) }.should_not raise_error
+      @rm.call(@env).should == [200, @app_headers, @app_body]
     end
 
     it 'returns 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])
-
       @env['REQUEST_METHOD'] = 'POST'
 
       status, headers, body = @rm.call(@env)
       status.should == 200
-      headers.should == app_headers
-      body.should == app_body
+      headers.should == @app_headers
+      body.should == @app_body
     end
   end
 

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

@@ -7,24 +7,26 @@ describe Goliath::Rack::Validation::RequiredParam do
   end
 
   it 'accepts options on create' do
-    opts = { :type => 1, :key => 2 }
+    opts = { :type => 1, :key => 2, :message => 'is required' }
     lambda { Goliath::Rack::Validation::RequiredParam.new('my app', opts) }.should_not raise_error
   end
 
-  it 'defaults type and key' do
+  it 'defaults type, key and message' do
     @rp = Goliath::Rack::Validation::RequiredParam.new('app')
     @rp.key.should_not be_nil
     @rp.key.should_not =~ /^\s*$/
 
     @rp.type.should_not be_nil
     @rp.type.should_not =~ /^\s*$/
+
+    @rp.message.should == 'identifier missing'
   end
 
   describe 'with middleware' do
     before(:each) do
       @app = mock('app').as_null_object
       @env = {'params' => {}}
-      @rp = Goliath::Rack::Validation::RequiredParam.new(@app, {:type => 'Monkey', :key => 'mk'})
+      @rp = Goliath::Rack::Validation::RequiredParam.new(@app, {:type => 'Monkey', :key => 'mk', :message => 'is required'})
     end
 
     it 'stores type and key options' do
@@ -32,6 +34,11 @@ describe Goliath::Rack::Validation::RequiredParam do
       @rp.key.should == 'mk'
     end
 
+    it 'calls validation_error with a custom message' do
+      @rp.should_receive(:validation_error).with(anything, 'Monkey is required')
+      @rp.call(@env)
+    end
+
     it 'returns the app status, headers and body' do
       app_headers = {'Content-Type' => 'app'}
       app_body = {'b' => 'c'}
@@ -45,47 +52,44 @@ describe Goliath::Rack::Validation::RequiredParam do
       body.should == app_body
     end
 
-    describe 'key_valid!' do
+    describe 'key_valid?' do
       it 'raises exception if the key is not provided' do
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it 'raises exception if the key is blank' do
         @env['params']['mk'] = ''
-
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it 'raises exception if the key is nil' do
         @env['params']['mk'] = nil
-
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it 'handles an empty array' do
         @env['params']['mk'] = []
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it 'handles an array of nils' do
         @env['params']['mk'] = [nil, nil, nil]
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it 'handles an array of blanks' do
         @env['params']['mk'] = ['', '', '']
-        lambda { @rp.key_valid!(@env['params']) }.should raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_false
       end
 
       it "doesn't raise if the key provided" do
         @env['params']['mk'] = 'my value'
-
-        lambda { @rp.key_valid!(@env['params']) }.should_not raise_error(Goliath::Validation::Error)
+        @rp.key_valid?(@env['params']).should be_true
       end
 
       it "doesn't raise if the array contains valid data" do
         @env['params']['mk'] = [1, 2, 3, 4]
-        lambda{ @rp.key_valid!(@env['params']) }.should_not raise_error
+        @rp.key_valid?(@env['params']).should be_true
       end
     end
   end